#1515 Updates version to 0.6.0 alpha 5 (#1516)

Co-authored-by: Dennis Sheirer <dsheirer@github.com>

.github/ISSUE_TEMPLATE/bug-report.md

@@ -0,0 +1,38 @@
+---
+name: Bug Report
+about: Create a report to help us improve sdrtrunk
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**sdrtrunk Version**
+Indicate which sdrtrunk version you are using.  Use 'master-branch' if you are running the latest code.
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Application Log**
+If applicable, include either the full application log,or a snippet of the error logging.
+
+**Desktop (optional - complete the following information):**
+ - OS: [e.g. iOS]
+ - CPU Cores: [e.g. 4 cores]
+ - RAM:[e.g. 16GB]
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: feature
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/how-to-question-or-does-the-software-support-xxx.md

@@ -0,0 +1,16 @@
+---
+name: How-To Question or Does The Software Support xxx
+about: End user question or support discussion
+title: STOP - Don't Use Issue Reporting to Post End-User Questions!!!
+labels: ''
+assignees: ''
+
+---
+
+STOP !!!!
+
+GitHub issues are for reporting software bugs or requesting enhancements.
+
+If you have a question about how to use the software, or if you want to know if sdrtrunk supports a protocol, tuner, or other aspect, please post your question in one of the Support forums.
+
+Visit: https://github.com/DSheirer/sdrtrunk/wiki

.github/workflows/gradle.yml

@@ -22,10 +22,10 @@ jobs:
 
     steps:
       - uses: actions/checkout@v2
-      - name: Set up JDK 17
+      - name: Set up JDK 19
         uses: actions/setup-java@v2
         with:
-          java-version: '17'
+          java-version: '19'
           distribution: 'liberica'
           java-package: 'jdk+fx'
       - name: Build with Gradle

.idea/misc.xml

@@ -4,7 +4,7 @@
   <component name="FrameworkDetectionExcludesConfiguration">
     <file type="web" url="file://$PROJECT_DIR$" />
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="liberica-18.0.1-fx" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_19_PREVIEW" project-jdk-name="liberica-19.0.1.fx" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

README.md

@@ -3,91 +3,22 @@
 # sdrtrunk
 A cross-platform java application for decoding, monitoring, recording and streaming trunked mobile and related radio protocols using Software Defined Radios (SDR).
 
-* [Getting Started](https://github.com/DSheirer/sdrtrunk/wiki/GettingStarted_V0.3.0)
-* [User's Manual Version 0.3.0 and 0.4.0](https://github.com/DSheirer/sdrtrunk/wiki/UserManual_V0.3.0)
-* [Playlist Editor User Manual Version 0.5.0](https://github.com/DSheirer/sdrtrunk/wiki/Playlist-Editor)
+* [Getting Started](https://github.com/DSheirer/sdrtrunk/wiki/Getting-Started)
+* [User's Manual](https://github.com/DSheirer/sdrtrunk/wiki/User-Manual)
 * [Download](https://github.com/DSheirer/sdrtrunk/releases)
-* [Support Group](https://groups.google.com/forum/#!forum/sdrtrunk)
-* [Discord Support Channel](https://discord.gg/HJQaKYE)
+* [Support](https://github.com/DSheirer/sdrtrunk/wiki/Support)
 
-![sdrtrunk Application Overview - Version 0.3.0](https://github.com/DSheirer/sdrtrunk/wiki/v0.3/images/ApplicationOverview_V0.3.0.png)
-**Figure 1:** sdrtrunk **Version 0.3.0** Application Screenshot
+![sdrtrunk Application](https://github.com/DSheirer/sdrtrunk/wiki/images/sdrtrunk.png)
+**Figure 1:** sdrtrunk Application Screenshot
 
-# End User Instructions:
-
-If you simply want to download and run the program, please follow these instructions.
-
-## Download the latest sdrtrunk release for your operating system
- 
+## Download the Latest Release
 All release versions of sdrtrunk are available from the [releases](https://github.com/DSheirer/sdrtrunk/releases) tab.
 
 * **(alpha)** These versions are under development feature previews and likely to contain bugs and unexpected behavior.
 * **(beta)** These versions are currently being tested for bugs and functionality prior to final release.
 * **(final)** These versions have been tested and are the current release version.
 
-## Unzip the release
-
-Use 7-zip or any zip utility to unzip the release file
-
-## Start the application
-
-Once unzipped, open a command prompt to where you unzipped the release.  Change to the **/bin** directory and use the launch script to start the application:
-* **Windows** sdr-trunk.bat
-* **Linux/OSX** ./sdr-trunk
-
-## Optional - P25/DMR Audio
-If you're using sdrtrunk with a P25 or DMR radio system, you'll need to compile and include the [JMBE](https://github.com/DSheirer/sdrtrunk/wiki/JMBE) digital audio library.
-
-In Version 0.5.0 and higher, the SDRTrunk application has support for building the JMBE library.  On the menu, choose **View >> User Preferences** and then click the **Decoder >> JMBE Audio Library** tab.
-
-For versions prior to Version 0.5.0, the [JMBE](https://github.com/DSheirer/sdrtrunk/wiki/JMBE) wiki page contains instructions for downloading the JMBE audio library source code and compiling the JMBE library.  Once you have compiled the library, launch the sdrtrunk application.  From the menu bar, choose **View >> Preferences**.  In the **JMBE Audio Codec** section, update the path to where your compiled JMBE library is located.  Any channels that are started after you set the path will be able to produce P25 audio.
-
 ## Minimum System Requirements
 * **Operating System:** Windows (~~32 or~~ 64-bit), Linux (~~32 or~~ 64-bit) or Mac/Linux (64-bit, 10.14 or higher)
 * **CPU:** 4-core
 * **RAM:** 8GB or more (preferred).  Depending on usage, 4GB may be sufficient.
-
-# Developer Instructions:
-
-If you're interested in modifying and/or compiling the source code, please follow these instructions to use gradle to compile the code. 
-
-## Build the project
-sdrtrunk uses the gradle build system. This requires **OpenJDK 17** or higher installed on your local computer.  
-
-### OpenJDK
-There are many vendors producing OpenJDK distributions.  A few that I use are:
-* [Azul Zulu OpenJDK](https://www.azul.com/downloads/?package=jdk)
-* [Bellsoft Liberica OpenJDK](https://bell-sw.com/pages/downloads/#/java-17-lts%20/%20current)
-* [SDKMAN](https://sdkman.io/) - Linux Only
-
-Use the gradle wrapper to build the source code:
-
-### Linux
-```
-./gradlew clean build
-```
-### Windows
-```
-gradlew.bat clean build
-```
-
-The **/build/distributions** folder will contain the zip file of the compiled program.  Unzip it and launch the program from the scripts in the **/bin** directory.
-
-## Run the Application (from Gradle)
-
-### Linux
-```
-./gradlew clean run
-```
-### Windows
-```
-gradlew.bat clean run
-```
-
-
-## Development
-All dependencies/versions are controlled from build.gradle.
-To change the new release version tag of artifact - change property:
-```
-version = '0.5.0'
-```

artifacts/sdrplay-api-headers/README.txt

@@ -0,0 +1,36 @@
+Auto-generating Java code from SDRPlay API using jextract.
+
+Note: the api headers in the 3.11 folder are equivalent to the 3.08 headers.  The only
+difference from the 3.07 headers is the addition of the boolean 'valid' flag to DeviceT structure.
+
+1. Download JDK19 compatible build of jextract JDK: https://jdk.java.net/jextract/
+2. If generating on windows platform, modify the sdrplay_api.h to remove the windows
+   pieces of the file.  Specifically:
+2a. Comment out these lines but leave the *HANDLE typedef:
+
+//#if defined(_M_X64) || defined(_M_IX86) || defined(_M_ARM64)
+//#include "windows.h"
+//#elif defined (__GNUC__)
+typedef void *HANDLE;
+//#endif
+
+//#ifndef _SDRPLAY_DLL_QUALIFIER
+//#if !defined(STATIC_LIB) && (defined(_M_X64) || defined(_M_IX86) || defined(_M_ARM64))
+//#define _SDRPLAY_DLL_QUALIFIER __declspec(dllimport)
+//#elif defined(STATIC_LIB) || defined(__GNUC__)
+//#define _SDRPLAY_DLL_QUALIFIER
+//#endif
+//#endif  // _SDRPLAY_DLL_QUALIFIER
+
+2b. Remove the '_SDRPLAY_DLL_QUALIFIER' from in front of the method declarations
+
+2c. Change the 3.11 version string to 3.08 either in the header file, or in the generated java class
+
+3. Open command prompt to the root source code where the generated files should be placed:
+..\SDRtrunk\sdrplay-api\src\main\java
+
+4. Generate the code:
+c:\Users\Denny\Downloads\jdk-19-ea2-panama\bin\jextract "C:\Users\Denny\git\sdrtrunk\sdrplay-api\api\v3_11\sdrplay_api.h" -l libsdrplay_api --source
+
+5. Do this for all versions of the API.
+

artifacts/sdrplay-api-headers/v3_07/sdrplay_api.h

@@ -0,0 +1,229 @@
+#ifndef SDRPLAY_API_H
+#define SDRPLAY_API_H
+
+#include "sdrplay_api_dev.h"
+#include "sdrplay_api_rx_channel.h"
+#include "sdrplay_api_callback.h"
+
+//#if defined(_M_X64) || defined(_M_IX86)
+//#include "windows.h"
+//#elif defined (__GNUC__)
+typedef void *HANDLE;
+//#endif
+
+//#ifndef _SDRPLAY_DLL_QUALIFIER
+//#if !defined(STATIC_LIB) && (defined(_M_X64) || defined(_M_IX86))
+//#define _SDRPLAY_DLL_QUALIFIER __declspec(dllimport)
+//#elif defined(STATIC_LIB) || defined(__GNUC__)
+//#define _SDRPLAY_DLL_QUALIFIER
+//#endif
+//#endif  // _SDRPLAY_DLL_QUALIFIER
+
+// Application code should check that it is compiled against the same API version
+// sdrplay_api_ApiVersion() returns the API version 
+#define SDRPLAY_API_VERSION                   (float)(3.07)
+
+// API Constants
+#define SDRPLAY_MAX_DEVICES                   (16)
+#define SDRPLAY_MAX_TUNERS_PER_DEVICE         (2)
+
+#define SDRPLAY_MAX_SER_NO_LEN                (64)
+#define SDRPLAY_MAX_ROOT_NM_LEN               (32)
+
+#define SDRPLAY_RSP1_ID                       (1)
+#define SDRPLAY_RSP1A_ID                      (255)
+#define SDRPLAY_RSP2_ID                       (2)
+#define SDRPLAY_RSPduo_ID                     (3)
+#define SDRPLAY_RSPdx_ID                      (4)
+
+// Enum types
+typedef enum
+{
+    sdrplay_api_Success               = 0,
+    sdrplay_api_Fail                  = 1,
+    sdrplay_api_InvalidParam          = 2,
+    sdrplay_api_OutOfRange            = 3,
+    sdrplay_api_GainUpdateError       = 4,
+    sdrplay_api_RfUpdateError         = 5,
+    sdrplay_api_FsUpdateError         = 6,
+    sdrplay_api_HwError               = 7,
+    sdrplay_api_AliasingError         = 8,
+    sdrplay_api_AlreadyInitialised    = 9,
+    sdrplay_api_NotInitialised        = 10,
+    sdrplay_api_NotEnabled            = 11,
+    sdrplay_api_HwVerError            = 12,
+    sdrplay_api_OutOfMemError         = 13,
+    sdrplay_api_ServiceNotResponding  = 14,
+    sdrplay_api_StartPending          = 15,
+    sdrplay_api_StopPending           = 16,
+    sdrplay_api_InvalidMode           = 17,
+    sdrplay_api_FailedVerification1   = 18,
+    sdrplay_api_FailedVerification2   = 19,
+    sdrplay_api_FailedVerification3   = 20,
+    sdrplay_api_FailedVerification4   = 21,
+    sdrplay_api_FailedVerification5   = 22,
+    sdrplay_api_FailedVerification6   = 23,
+    sdrplay_api_InvalidServiceVersion = 24
+} sdrplay_api_ErrT;
+
+typedef enum
+{
+    sdrplay_api_Update_None                        = 0x00000000,
+
+    // Reasons for master only mode 
+    sdrplay_api_Update_Dev_Fs                      = 0x00000001,
+    sdrplay_api_Update_Dev_Ppm                     = 0x00000002,
+    sdrplay_api_Update_Dev_SyncUpdate              = 0x00000004,
+    sdrplay_api_Update_Dev_ResetFlags              = 0x00000008,
+
+    sdrplay_api_Update_Rsp1a_BiasTControl          = 0x00000010,
+    sdrplay_api_Update_Rsp1a_RfNotchControl        = 0x00000020,
+    sdrplay_api_Update_Rsp1a_RfDabNotchControl     = 0x00000040,
+
+    sdrplay_api_Update_Rsp2_BiasTControl           = 0x00000080,
+    sdrplay_api_Update_Rsp2_AmPortSelect           = 0x00000100,
+    sdrplay_api_Update_Rsp2_AntennaControl         = 0x00000200,
+    sdrplay_api_Update_Rsp2_RfNotchControl         = 0x00000400,
+    sdrplay_api_Update_Rsp2_ExtRefControl          = 0x00000800,
+
+    sdrplay_api_Update_RspDuo_ExtRefControl        = 0x00001000,
+
+    sdrplay_api_Update_Master_Spare_1              = 0x00002000,
+    sdrplay_api_Update_Master_Spare_2              = 0x00004000,
+
+    // Reasons for master and slave mode
+    // Note: sdrplay_api_Update_Tuner_Gr MUST be the first value defined in this section!
+    sdrplay_api_Update_Tuner_Gr                    = 0x00008000,
+    sdrplay_api_Update_Tuner_GrLimits              = 0x00010000,
+    sdrplay_api_Update_Tuner_Frf                   = 0x00020000,
+    sdrplay_api_Update_Tuner_BwType                = 0x00040000,
+    sdrplay_api_Update_Tuner_IfType                = 0x00080000,
+    sdrplay_api_Update_Tuner_DcOffset              = 0x00100000,
+    sdrplay_api_Update_Tuner_LoMode                = 0x00200000,
+
+    sdrplay_api_Update_Ctrl_DCoffsetIQimbalance    = 0x00400000,
+    sdrplay_api_Update_Ctrl_Decimation             = 0x00800000,
+    sdrplay_api_Update_Ctrl_Agc                    = 0x01000000,
+    sdrplay_api_Update_Ctrl_AdsbMode               = 0x02000000,
+    sdrplay_api_Update_Ctrl_OverloadMsgAck         = 0x04000000,
+
+    sdrplay_api_Update_RspDuo_BiasTControl         = 0x08000000,
+    sdrplay_api_Update_RspDuo_AmPortSelect         = 0x10000000,
+    sdrplay_api_Update_RspDuo_Tuner1AmNotchControl = 0x20000000,
+    sdrplay_api_Update_RspDuo_RfNotchControl       = 0x40000000,
+    sdrplay_api_Update_RspDuo_RfDabNotchControl    = 0x80000000,
+} sdrplay_api_ReasonForUpdateT;
+
+typedef enum
+{
+    sdrplay_api_Update_Ext1_None                   = 0x00000000,
+
+    // Reasons for master only mode 
+    sdrplay_api_Update_RspDx_HdrEnable             = 0x00000001,
+    sdrplay_api_Update_RspDx_BiasTControl          = 0x00000002,
+    sdrplay_api_Update_RspDx_AntennaControl        = 0x00000004,
+    sdrplay_api_Update_RspDx_RfNotchControl        = 0x00000008,
+    sdrplay_api_Update_RspDx_RfDabNotchControl     = 0x00000010,
+    sdrplay_api_Update_RspDx_HdrBw                 = 0x00000020,
+
+    // Reasons for master and slave mode
+} sdrplay_api_ReasonForUpdateExtension1T;
+
+typedef enum
+{
+    sdrplay_api_DbgLvl_Disable       = 0,
+    sdrplay_api_DbgLvl_Verbose       = 1,
+    sdrplay_api_DbgLvl_Warning       = 2,
+    sdrplay_api_DbgLvl_Error         = 3,
+    sdrplay_api_DbgLvl_Message       = 4,
+} sdrplay_api_DbgLvl_t;
+
+// Device structure 
+typedef struct 
+{
+    char SerNo[SDRPLAY_MAX_SER_NO_LEN];
+    unsigned char hwVer;
+    sdrplay_api_TunerSelectT tuner;
+    sdrplay_api_RspDuoModeT rspDuoMode;
+    double rspDuoSampleFreq;
+    HANDLE dev;
+} sdrplay_api_DeviceT;
+
+// Device parameter structure
+typedef struct 
+{
+    sdrplay_api_DevParamsT       *devParams;
+    sdrplay_api_RxChannelParamsT *rxChannelA;
+    sdrplay_api_RxChannelParamsT *rxChannelB;
+} sdrplay_api_DeviceParamsT;
+
+// Extended error message structure
+typedef struct 
+{
+    char file[256];
+    char function[256];
+    int  line;
+    char message[1024];
+} sdrplay_api_ErrorInfoT;
+
+// Comman API function types
+typedef sdrplay_api_ErrT        (*sdrplay_api_Open_t)(void);    
+typedef sdrplay_api_ErrT        (*sdrplay_api_Close_t)(void);    
+typedef sdrplay_api_ErrT        (*sdrplay_api_ApiVersion_t)(float *apiVer);    
+typedef sdrplay_api_ErrT        (*sdrplay_api_LockDeviceApi_t)(void);    
+typedef sdrplay_api_ErrT        (*sdrplay_api_UnlockDeviceApi_t)(void);    
+typedef sdrplay_api_ErrT        (*sdrplay_api_GetDevices_t)(sdrplay_api_DeviceT *devices, unsigned int *numDevs, unsigned int maxDevs);    
+typedef sdrplay_api_ErrT        (*sdrplay_api_SelectDevice_t)(sdrplay_api_DeviceT *device);    
+typedef sdrplay_api_ErrT        (*sdrplay_api_ReleaseDevice_t)(sdrplay_api_DeviceT *device);    
+typedef const char*             (*sdrplay_api_GetErrorString_t)(sdrplay_api_ErrT err);
+typedef sdrplay_api_ErrorInfoT* (*sdrplay_api_GetLastError_t)(sdrplay_api_DeviceT *device);
+typedef sdrplay_api_ErrT        (*sdrplay_api_DisableHeartbeat_t)(void);
+
+// Device API function types
+typedef sdrplay_api_ErrT        (*sdrplay_api_DebugEnable_t)(HANDLE dev, sdrplay_api_DbgLvl_t dbgLvl); 
+typedef sdrplay_api_ErrT        (*sdrplay_api_GetDeviceParams_t)(HANDLE dev, sdrplay_api_DeviceParamsT **deviceParams); 
+typedef sdrplay_api_ErrT        (*sdrplay_api_Init_t)(HANDLE dev, sdrplay_api_CallbackFnsT *callbackFns, void *cbContext); 
+typedef sdrplay_api_ErrT        (*sdrplay_api_Uninit_t)(HANDLE dev);
+typedef sdrplay_api_ErrT        (*sdrplay_api_Update_t)(HANDLE dev, sdrplay_api_TunerSelectT tuner, sdrplay_api_ReasonForUpdateT reasonForUpdate, sdrplay_api_ReasonForUpdateExtension1T reasonForUpdateExt1);
+typedef sdrplay_api_ErrT        (*sdrplay_api_SwapRspDuoActiveTuner_t)(HANDLE dev, sdrplay_api_TunerSelectT *tuner, sdrplay_api_RspDuo_AmPortSelectT tuner1AmPortSel);
+typedef sdrplay_api_ErrT        (*sdrplay_api_SwapRspDuoDualTunerModeSampleRate_t)(double *currentSampleRate);
+typedef sdrplay_api_ErrT        (*sdrplay_api_SwapRspDuoMode_t)(sdrplay_api_DeviceT *currDevice, sdrplay_api_DeviceParamsT **deviceParams,
+                                                                sdrplay_api_RspDuoModeT rspDuoMode, double sampleRate, sdrplay_api_TunerSelectT tuner,
+                                                                sdrplay_api_Bw_MHzT bwType, sdrplay_api_If_kHzT ifType, sdrplay_api_RspDuo_AmPortSelectT tuner1AmPortSel);
+
+// API function definitions
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    // Comman API function definitions
+    sdrplay_api_ErrT        sdrplay_api_Open(void);
+    sdrplay_api_ErrT        sdrplay_api_Close(void);
+    sdrplay_api_ErrT        sdrplay_api_ApiVersion(float *apiVer);
+    sdrplay_api_ErrT        sdrplay_api_LockDeviceApi(void);
+    sdrplay_api_ErrT        sdrplay_api_UnlockDeviceApi(void);
+    sdrplay_api_ErrT        sdrplay_api_GetDevices(sdrplay_api_DeviceT *devices, unsigned int *numDevs, unsigned int maxDevs);
+    sdrplay_api_ErrT        sdrplay_api_SelectDevice(sdrplay_api_DeviceT *device);
+    sdrplay_api_ErrT        sdrplay_api_ReleaseDevice(sdrplay_api_DeviceT *device);
+    const char*             sdrplay_api_GetErrorString(sdrplay_api_ErrT err);
+    sdrplay_api_ErrorInfoT* sdrplay_api_GetLastError(sdrplay_api_DeviceT *device);
+    sdrplay_api_ErrT        sdrplay_api_DisableHeartbeat(void); // Must be called before sdrplay_api_SelectDevice()
+
+    // Device API function definitions
+    sdrplay_api_ErrT        sdrplay_api_DebugEnable(HANDLE dev, sdrplay_api_DbgLvl_t enable);
+    sdrplay_api_ErrT        sdrplay_api_GetDeviceParams(HANDLE dev, sdrplay_api_DeviceParamsT **deviceParams);
+    sdrplay_api_ErrT        sdrplay_api_Init(HANDLE dev, sdrplay_api_CallbackFnsT *callbackFns, void *cbContext);
+    sdrplay_api_ErrT        sdrplay_api_Uninit(HANDLE dev);
+    sdrplay_api_ErrT        sdrplay_api_Update(HANDLE dev, sdrplay_api_TunerSelectT tuner, sdrplay_api_ReasonForUpdateT reasonForUpdate, sdrplay_api_ReasonForUpdateExtension1T reasonForUpdateExt1);
+    sdrplay_api_ErrT        sdrplay_api_SwapRspDuoActiveTuner(HANDLE dev, sdrplay_api_TunerSelectT *currentTuner, sdrplay_api_RspDuo_AmPortSelectT tuner1AmPortSel);
+    sdrplay_api_ErrT        sdrplay_api_SwapRspDuoDualTunerModeSampleRate(HANDLE dev, double *currentSampleRate);
+    sdrplay_api_ErrT        sdrplay_api_SwapRspDuoMode(sdrplay_api_DeviceT *currDevice, sdrplay_api_DeviceParamsT **deviceParams,
+                                                                              sdrplay_api_RspDuoModeT rspDuoMode, double sampleRate, sdrplay_api_TunerSelectT tuner,
+                                                                              sdrplay_api_Bw_MHzT bwType, sdrplay_api_If_kHzT ifType, sdrplay_api_RspDuo_AmPortSelectT tuner1AmPortSel);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //SDRPLAY_API_H

artifacts/sdrplay-api-headers/v3_07/sdrplay_api_callback.h

@@ -0,0 +1,78 @@
+#ifndef SDRPLAY_API_CALLBACK_H
+#define SDRPLAY_API_CALLBACK_H
+
+// Event callback enums
+typedef enum
+{
+    sdrplay_api_Overload_Detected     = 0,
+    sdrplay_api_Overload_Corrected    = 1,
+} sdrplay_api_PowerOverloadCbEventIdT;
+
+typedef enum
+{
+    sdrplay_api_MasterInitialised      = 0,
+    sdrplay_api_SlaveAttached          = 1,
+    sdrplay_api_SlaveDetached          = 2,
+    sdrplay_api_SlaveInitialised       = 3,
+    sdrplay_api_SlaveUninitialised     = 4,
+    sdrplay_api_MasterDllDisappeared   = 5,
+    sdrplay_api_SlaveDllDisappeared    = 6,
+} sdrplay_api_RspDuoModeCbEventIdT;
+
+typedef enum
+{
+    sdrplay_api_GainChange            = 0,
+    sdrplay_api_PowerOverloadChange   = 1,
+    sdrplay_api_DeviceRemoved         = 2,
+    sdrplay_api_RspDuoModeChange      = 3,
+} sdrplay_api_EventT;
+
+// Event callback parameter structs
+typedef struct 
+{
+    unsigned int gRdB;
+    unsigned int lnaGRdB;
+    double currGain;
+} sdrplay_api_GainCbParamT;
+
+typedef struct 
+{
+    sdrplay_api_PowerOverloadCbEventIdT powerOverloadChangeType;
+} sdrplay_api_PowerOverloadCbParamT;
+
+typedef struct 
+{
+    sdrplay_api_RspDuoModeCbEventIdT modeChangeType;
+} sdrplay_api_RspDuoModeCbParamT;
+
+// Event parameters overlay
+typedef union
+{
+    sdrplay_api_GainCbParamT          gainParams;
+    sdrplay_api_PowerOverloadCbParamT powerOverloadParams;
+    sdrplay_api_RspDuoModeCbParamT    rspDuoModeParams;
+} sdrplay_api_EventParamsT;
+
+// Stream callback parameter structs
+typedef struct 
+{
+    unsigned int firstSampleNum;
+    int grChanged;
+    int rfChanged;
+    int fsChanged;
+    unsigned int numSamples;
+} sdrplay_api_StreamCbParamsT;
+
+// Callback function prototypes
+typedef void (*sdrplay_api_StreamCallback_t)(short *xi, short *xq, sdrplay_api_StreamCbParamsT *params, unsigned int numSamples, unsigned int reset, void *cbContext); 
+typedef void (*sdrplay_api_EventCallback_t)(sdrplay_api_EventT eventId, sdrplay_api_TunerSelectT tuner, sdrplay_api_EventParamsT *params, void *cbContext); 
+
+// Callback function struct
+typedef struct 
+{
+    sdrplay_api_StreamCallback_t StreamACbFn;
+    sdrplay_api_StreamCallback_t StreamBCbFn;
+    sdrplay_api_EventCallback_t  EventCbFn;
+} sdrplay_api_CallbackFnsT;
+
+#endif //SDRPLAY_API_CALLBACK_H

artifacts/sdrplay-api-headers/v3_07/sdrplay_api_control.h

@@ -0,0 +1,55 @@
+#ifndef SDRPLAY_API_CONTROL_H
+#define SDRPLAY_API_CONTROL_H
+
+// Control parameter enums
+typedef enum
+{
+    sdrplay_api_AGC_DISABLE  = 0,
+    sdrplay_api_AGC_100HZ    = 1,
+    sdrplay_api_AGC_50HZ     = 2,
+    sdrplay_api_AGC_5HZ      = 3,
+    sdrplay_api_AGC_CTRL_EN  = 4
+} sdrplay_api_AgcControlT;
+
+typedef enum
+{
+    sdrplay_api_ADSB_DECIMATION                  = 0,
+    sdrplay_api_ADSB_NO_DECIMATION_LOWPASS       = 1,
+    sdrplay_api_ADSB_NO_DECIMATION_BANDPASS_2MHZ = 2,
+    sdrplay_api_ADSB_NO_DECIMATION_BANDPASS_3MHZ = 3
+} sdrplay_api_AdsbModeT;
+
+// Control parameter structs
+typedef struct 
+{
+    unsigned char DCenable;          // default: 1
+    unsigned char IQenable;          // default: 1
+} sdrplay_api_DcOffsetT;
+
+typedef struct 
+{
+    unsigned char enable;            // default: 0
+    unsigned char decimationFactor;  // default: 1
+    unsigned char wideBandSignal;    // default: 0
+} sdrplay_api_DecimationT;
+
+typedef struct 
+{
+    sdrplay_api_AgcControlT enable;    // default: sdrplay_api_AGC_50HZ
+    int setPoint_dBfs;                 // default: -60
+    unsigned short attack_ms;          // default: 0
+    unsigned short decay_ms;           // default: 0
+    unsigned short decay_delay_ms;     // default: 0
+    unsigned short decay_threshold_dB; // default: 0
+    int syncUpdate;                    // default: 0
+} sdrplay_api_AgcT;
+
+typedef struct 
+{
+    sdrplay_api_DcOffsetT dcOffset;
+    sdrplay_api_DecimationT decimation;
+    sdrplay_api_AgcT agc;
+    sdrplay_api_AdsbModeT adsbMode;  //default: sdrplay_api_ADSB_DECIMATION
+} sdrplay_api_ControlParamsT;
+
+#endif //SDRPLAY_API_CONTROL_H

artifacts/sdrplay-api-headers/v3_07/sdrplay_api_dev.h

@@ -0,0 +1,51 @@
+#ifndef SDRPLAY_API_DEV_H
+#define SDRPLAY_API_DEV_H
+
+#include "sdrplay_api_rsp1a.h"
+#include "sdrplay_api_rsp2.h"
+#include "sdrplay_api_rspDuo.h"
+#include "sdrplay_api_rspDx.h"
+
+// Dev parameter enums
+typedef enum
+{
+    sdrplay_api_ISOCH = 0,
+    sdrplay_api_BULK  = 1
+} sdrplay_api_TransferModeT;
+
+// Dev parameter structs
+typedef struct 
+{
+    double fsHz;                        // default: 2000000.0
+    unsigned char syncUpdate;           // default: 0
+    unsigned char reCal;                // default: 0
+} sdrplay_api_FsFreqT;
+
+typedef struct 
+{
+    unsigned int sampleNum;             // default: 0
+    unsigned int period;                // default: 0
+} sdrplay_api_SyncUpdateT;
+
+typedef struct 
+{
+    unsigned char resetGainUpdate;      // default: 0
+    unsigned char resetRfUpdate;        // default: 0
+    unsigned char resetFsUpdate;        // default: 0
+} sdrplay_api_ResetFlagsT;   
+
+typedef struct 
+{
+    double ppm;                         // default: 0.0
+    sdrplay_api_FsFreqT fsFreq;
+    sdrplay_api_SyncUpdateT syncUpdate; 
+    sdrplay_api_ResetFlagsT resetFlags; 
+    sdrplay_api_TransferModeT mode;     // default: sdrplay_api_ISOCH
+    unsigned int samplesPerPkt;         // default: 0 (output param)
+    sdrplay_api_Rsp1aParamsT rsp1aParams;
+    sdrplay_api_Rsp2ParamsT rsp2Params;
+    sdrplay_api_RspDuoParamsT rspDuoParams;
+    sdrplay_api_RspDxParamsT rspDxParams;
+} sdrplay_api_DevParamsT;
+
+#endif //SDRPLAY_API_DEV_H

artifacts/sdrplay-api-headers/v3_07/sdrplay_api_rsp1a.h

@@ -0,0 +1,22 @@
+#ifndef SDRPLAY_API_RSP1A_H
+#define SDRPLAY_API_RSP1A_H
+
+#define RSPIA_NUM_LNA_STATES         10
+#define RSPIA_NUM_LNA_STATES_AM      7
+#define RSPIA_NUM_LNA_STATES_LBAND   9
+
+// RSP1A parameter enums
+
+// RSP1A parameter structs
+typedef struct 
+{
+    unsigned char rfNotchEnable;                              // default: 0
+    unsigned char rfDabNotchEnable;                           // default: 0
+} sdrplay_api_Rsp1aParamsT;
+
+typedef struct 
+{
+    unsigned char biasTEnable;                   // default: 0
+} sdrplay_api_Rsp1aTunerParamsT;
+
+#endif //SDRPLAY_API_RSP1A_H

artifacts/sdrplay-api-headers/v3_07/sdrplay_api_rsp2.h

@@ -0,0 +1,35 @@
+#ifndef SDRPLAY_API_RSP2_H
+#define SDRPLAY_API_RSP2_H
+
+#define RSPII_NUM_LNA_STATES         9
+#define RSPII_NUM_LNA_STATES_AMPORT  5
+#define RSPII_NUM_LNA_STATES_420MHZ  6
+
+// RSP2 parameter enums
+typedef enum
+{
+    sdrplay_api_Rsp2_ANTENNA_A = 5,
+    sdrplay_api_Rsp2_ANTENNA_B = 6,
+} sdrplay_api_Rsp2_AntennaSelectT;
+
+typedef enum
+{
+    sdrplay_api_Rsp2_AMPORT_1 = 1,
+    sdrplay_api_Rsp2_AMPORT_2 = 0,
+} sdrplay_api_Rsp2_AmPortSelectT;
+
+// RSP2 parameter structs
+typedef struct 
+{
+    unsigned char extRefOutputEn;                // default: 0
+} sdrplay_api_Rsp2ParamsT;
+
+typedef struct 
+{
+    unsigned char biasTEnable;                   // default: 0
+    sdrplay_api_Rsp2_AmPortSelectT amPortSel;    // default: sdrplay_api_Rsp2_AMPORT_2
+    sdrplay_api_Rsp2_AntennaSelectT antennaSel;  // default: sdrplay_api_Rsp2_ANTENNA_A
+    unsigned char rfNotchEnable;                 // default: 0
+} sdrplay_api_Rsp2TunerParamsT;
+
+#endif //SDRPLAY_API_RSP2_H

artifacts/sdrplay-api-headers/v3_07/sdrplay_api_rspDuo.h

@@ -0,0 +1,40 @@
+#ifndef SDRPLAY_API_RSPduo_H
+#define SDRPLAY_API_RSPduo_H
+
+#define RSPDUO_NUM_LNA_STATES         10
+#define RSPDUO_NUM_LNA_STATES_AMPORT  5
+#define RSPDUO_NUM_LNA_STATES_AM      7
+#define RSPDUO_NUM_LNA_STATES_LBAND   9
+
+// RSPduo parameter enums
+typedef enum
+{
+    sdrplay_api_RspDuoMode_Unknown      = 0,
+    sdrplay_api_RspDuoMode_Single_Tuner = 1,
+    sdrplay_api_RspDuoMode_Dual_Tuner   = 2,
+    sdrplay_api_RspDuoMode_Master       = 4,
+    sdrplay_api_RspDuoMode_Slave        = 8,
+} sdrplay_api_RspDuoModeT;
+
+typedef enum
+{
+    sdrplay_api_RspDuo_AMPORT_1 = 1,
+    sdrplay_api_RspDuo_AMPORT_2 = 0,
+} sdrplay_api_RspDuo_AmPortSelectT;
+
+// RSPduo parameter structs
+typedef struct 
+{
+    int extRefOutputEn;                             // default: 0
+} sdrplay_api_RspDuoParamsT;
+
+typedef struct 
+{
+    unsigned char biasTEnable;                      // default: 0
+    sdrplay_api_RspDuo_AmPortSelectT tuner1AmPortSel; // default: sdrplay_api_RspDuo_AMPORT_2
+    unsigned char tuner1AmNotchEnable;              // default: 0
+    unsigned char rfNotchEnable;                    // default: 0
+    unsigned char rfDabNotchEnable;                 // default: 0
+} sdrplay_api_RspDuoTunerParamsT;
+
+#endif //SDRPLAY_API_RSPduo_H

artifacts/sdrplay-api-headers/v3_07/sdrplay_api_rspDx.h

@@ -0,0 +1,45 @@
+#ifndef SDRPLAY_API_RSPDX_H
+#define SDRPLAY_API_RSPDX_H
+
+#include "sdrplay_api_tuner.h"
+
+#define RSPDX_NUM_LNA_STATES               28   // Number of LNA states in all bands (except where defined differently below)
+#define RSPDX_NUM_LNA_STATES_AMPORT2_0_12  19   // Number of LNA states when using AM Port 2 between 0 and 12MHz
+#define RSPDX_NUM_LNA_STATES_AMPORT2_12_60 20   // Number of LNA states when using AM Port 2 between 12 and 60MHz
+#define RSPDX_NUM_LNA_STATES_VHF_BAND3     27   // Number of LNA states in VHF and Band3
+#define RSPDX_NUM_LNA_STATES_420MHZ        21   // Number of LNA states in 420MHz band
+#define RSPDX_NUM_LNA_STATES_LBAND         19   // Number of LNA states in L-band
+#define RSPDX_NUM_LNA_STATES_DX            26   // Number of LNA states in DX path
+
+// RSPdx parameter enums
+typedef enum
+{
+    sdrplay_api_RspDx_ANTENNA_A = 0,
+    sdrplay_api_RspDx_ANTENNA_B = 1,
+    sdrplay_api_RspDx_ANTENNA_C = 2,
+} sdrplay_api_RspDx_AntennaSelectT;
+
+typedef enum
+{
+    sdrplay_api_RspDx_HDRMODE_BW_0_200  = 0,
+    sdrplay_api_RspDx_HDRMODE_BW_0_500  = 1,
+    sdrplay_api_RspDx_HDRMODE_BW_1_200  = 2,
+    sdrplay_api_RspDx_HDRMODE_BW_1_700  = 3,
+} sdrplay_api_RspDx_HdrModeBwT;
+
+// RSPdx parameter structs
+typedef struct 
+{
+    unsigned char hdrEnable;                            // default: 0
+    unsigned char biasTEnable;                          // default: 0
+    sdrplay_api_RspDx_AntennaSelectT antennaSel;        // default: sdrplay_api_RspDx_ANTENNA_A
+    unsigned char rfNotchEnable;                        // default: 0
+    unsigned char rfDabNotchEnable;                     // default: 0
+} sdrplay_api_RspDxParamsT;
+
+typedef struct 
+{
+    sdrplay_api_RspDx_HdrModeBwT hdrBw;                 // default: sdrplay_api_RspDx_HDRMODE_BW_1_700
+} sdrplay_api_RspDxTunerParamsT;
+
+#endif //SDRPLAY_API_RSPDX_H

artifacts/sdrplay-api-headers/v3_07/sdrplay_api_rx_channel.h

@@ -0,0 +1,21 @@
+#ifndef SDRPLAY_API_RX_CHANNEL_H
+#define SDRPLAY_API_RX_CHANNEL_H
+
+#include "sdrplay_api_tuner.h"
+#include "sdrplay_api_control.h"
+#include "sdrplay_api_rsp1a.h"
+#include "sdrplay_api_rsp2.h"
+#include "sdrplay_api_rspDuo.h"
+#include "sdrplay_api_rspDx.h"
+
+typedef struct 
+{
+    sdrplay_api_TunerParamsT        tunerParams;    
+    sdrplay_api_ControlParamsT      ctrlParams;     
+    sdrplay_api_Rsp1aTunerParamsT   rsp1aTunerParams; 
+    sdrplay_api_Rsp2TunerParamsT    rsp2TunerParams; 
+    sdrplay_api_RspDuoTunerParamsT  rspDuoTunerParams;    
+    sdrplay_api_RspDxTunerParamsT   rspDxTunerParams;    
+} sdrplay_api_RxChannelParamsT;
+
+#endif //SDRPLAY_API_RX_CHANNEL_H

artifacts/sdrplay-api-headers/v3_07/sdrplay_api_tuner.h

@@ -0,0 +1,93 @@
+#ifndef SDRPLAY_API_TUNER_H
+#define SDRPLAY_API_TUNER_H
+
+#define MAX_BB_GR                         (59)
+
+// Tuner parameter enums
+typedef enum
+{
+    sdrplay_api_BW_Undefined = 0,
+    sdrplay_api_BW_0_200     = 200,
+    sdrplay_api_BW_0_300     = 300,
+    sdrplay_api_BW_0_600     = 600,
+    sdrplay_api_BW_1_536     = 1536,
+    sdrplay_api_BW_5_000     = 5000,
+    sdrplay_api_BW_6_000     = 6000,
+    sdrplay_api_BW_7_000     = 7000,
+    sdrplay_api_BW_8_000     = 8000
+} sdrplay_api_Bw_MHzT;
+
+typedef enum
+{
+    sdrplay_api_IF_Undefined = -1,
+    sdrplay_api_IF_Zero      = 0,
+    sdrplay_api_IF_0_450     = 450,
+    sdrplay_api_IF_1_620     = 1620,
+    sdrplay_api_IF_2_048     = 2048
+} sdrplay_api_If_kHzT;
+
+typedef enum
+{
+    sdrplay_api_LO_Undefined = 0,
+    sdrplay_api_LO_Auto      = 1,
+    sdrplay_api_LO_120MHz    = 2,
+    sdrplay_api_LO_144MHz    = 3,
+    sdrplay_api_LO_168MHz    = 4
+} sdrplay_api_LoModeT;
+
+typedef enum
+{
+    sdrplay_api_EXTENDED_MIN_GR = 0,
+    sdrplay_api_NORMAL_MIN_GR   = 20
+} sdrplay_api_MinGainReductionT;
+
+typedef enum
+{
+    sdrplay_api_Tuner_Neither  = 0,
+    sdrplay_api_Tuner_A        = 1,
+    sdrplay_api_Tuner_B        = 2,
+    sdrplay_api_Tuner_Both     = 3,
+} sdrplay_api_TunerSelectT;
+
+// Tuner parameter structs
+typedef struct
+{
+    float curr;
+    float max;
+    float min;
+} sdrplay_api_GainValuesT;
+
+typedef struct 
+{
+    int gRdB;                            // default: 50
+    unsigned char LNAstate;              // default: 0
+    unsigned char syncUpdate;            // default: 0
+    sdrplay_api_MinGainReductionT minGr; // default: sdrplay_api_NORMAL_MIN_GR
+    sdrplay_api_GainValuesT gainVals;    // output parameter
+} sdrplay_api_GainT;
+
+typedef struct 
+{
+    double rfHz;                         // default: 200000000.0
+    unsigned char syncUpdate;            // default: 0
+} sdrplay_api_RfFreqT;
+
+typedef struct 
+{
+    unsigned char dcCal;                 // default: 3 (Periodic mode)
+    unsigned char speedUp;               // default: 0 (No speedup)
+    int trackTime;                       // default: 1    (=> time in uSec = (72 * 3 * trackTime) / 24e6       = 9uSec)
+    int refreshRateTime;                 // default: 2048 (=> time in uSec = (72 * 3 * refreshRateTime) / 24e6 = 18432uSec)
+} sdrplay_api_DcOffsetTunerT;
+
+typedef struct 
+{
+    sdrplay_api_Bw_MHzT bwType;          // default: sdrplay_api_BW_0_200
+    sdrplay_api_If_kHzT ifType;          // default: sdrplay_api_IF_Zero
+    sdrplay_api_LoModeT loMode;          // default: sdrplay_api_LO_Auto
+    sdrplay_api_GainT gain;
+    sdrplay_api_RfFreqT rfFreq;
+    sdrplay_api_DcOffsetTunerT dcOffsetTuner;
+} sdrplay_api_TunerParamsT;
+
+#endif //SDRPLAY_API_TUNER_H

artifacts/sdrplay-api-headers/v3_11/sdrplay_api.h

@@ -0,0 +1,230 @@
+#ifndef SDRPLAY_API_H
+#define SDRPLAY_API_H
+
+#include "sdrplay_api_dev.h"
+#include "sdrplay_api_rx_channel.h"
+#include "sdrplay_api_callback.h"
+
+//#if defined(_M_X64) || defined(_M_IX86) || defined(_M_ARM64)
+//#include "windows.h"
+//#elif defined (__GNUC__)
+typedef void *HANDLE;
+//#endif
+
+//#ifndef _SDRPLAY_DLL_QUALIFIER
+//#if !defined(STATIC_LIB) && (defined(_M_X64) || defined(_M_IX86) || defined(_M_ARM64))
+//#define _SDRPLAY_DLL_QUALIFIER __declspec(dllimport)
+//#elif defined(STATIC_LIB) || defined(__GNUC__)
+//#define _SDRPLAY_DLL_QUALIFIER
+//#endif
+//#endif  // _SDRPLAY_DLL_QUALIFIER
+
+// Application code should check that it is compiled against the same API version
+// sdrplay_api_ApiVersion() returns the API version 
+#define SDRPLAY_API_VERSION                   (float)(3.11)
+
+// API Constants
+#define SDRPLAY_MAX_DEVICES                   (16)
+#define SDRPLAY_MAX_TUNERS_PER_DEVICE         (2)
+
+#define SDRPLAY_MAX_SER_NO_LEN                (64)
+#define SDRPLAY_MAX_ROOT_NM_LEN               (32)
+
+#define SDRPLAY_RSP1_ID                       (1)
+#define SDRPLAY_RSP1A_ID                      (255)
+#define SDRPLAY_RSP2_ID                       (2)
+#define SDRPLAY_RSPduo_ID                     (3)
+#define SDRPLAY_RSPdx_ID                      (4)
+
+// Enum types
+typedef enum
+{
+    sdrplay_api_Success               = 0,
+    sdrplay_api_Fail                  = 1,
+    sdrplay_api_InvalidParam          = 2,
+    sdrplay_api_OutOfRange            = 3,
+    sdrplay_api_GainUpdateError       = 4,
+    sdrplay_api_RfUpdateError         = 5,
+    sdrplay_api_FsUpdateError         = 6,
+    sdrplay_api_HwError               = 7,
+    sdrplay_api_AliasingError         = 8,
+    sdrplay_api_AlreadyInitialised    = 9,
+    sdrplay_api_NotInitialised        = 10,
+    sdrplay_api_NotEnabled            = 11,
+    sdrplay_api_HwVerError            = 12,
+    sdrplay_api_OutOfMemError         = 13,
+    sdrplay_api_ServiceNotResponding  = 14,
+    sdrplay_api_StartPending          = 15,
+    sdrplay_api_StopPending           = 16,
+    sdrplay_api_InvalidMode           = 17,
+    sdrplay_api_FailedVerification1   = 18,
+    sdrplay_api_FailedVerification2   = 19,
+    sdrplay_api_FailedVerification3   = 20,
+    sdrplay_api_FailedVerification4   = 21,
+    sdrplay_api_FailedVerification5   = 22,
+    sdrplay_api_FailedVerification6   = 23,
+    sdrplay_api_InvalidServiceVersion = 24
+} sdrplay_api_ErrT;
+
+typedef enum
+{
+    sdrplay_api_Update_None                        = 0x00000000,
+
+    // Reasons for master only mode 
+    sdrplay_api_Update_Dev_Fs                      = 0x00000001,
+    sdrplay_api_Update_Dev_Ppm                     = 0x00000002,
+    sdrplay_api_Update_Dev_SyncUpdate              = 0x00000004,
+    sdrplay_api_Update_Dev_ResetFlags              = 0x00000008,
+
+    sdrplay_api_Update_Rsp1a_BiasTControl          = 0x00000010,
+    sdrplay_api_Update_Rsp1a_RfNotchControl        = 0x00000020,
+    sdrplay_api_Update_Rsp1a_RfDabNotchControl     = 0x00000040,
+
+    sdrplay_api_Update_Rsp2_BiasTControl           = 0x00000080,
+    sdrplay_api_Update_Rsp2_AmPortSelect           = 0x00000100,
+    sdrplay_api_Update_Rsp2_AntennaControl         = 0x00000200,
+    sdrplay_api_Update_Rsp2_RfNotchControl         = 0x00000400,
+    sdrplay_api_Update_Rsp2_ExtRefControl          = 0x00000800,
+
+    sdrplay_api_Update_RspDuo_ExtRefControl        = 0x00001000,
+
+    sdrplay_api_Update_Master_Spare_1              = 0x00002000,
+    sdrplay_api_Update_Master_Spare_2              = 0x00004000,
+
+    // Reasons for master and slave mode
+    // Note: sdrplay_api_Update_Tuner_Gr MUST be the first value defined in this section!
+    sdrplay_api_Update_Tuner_Gr                    = 0x00008000,
+    sdrplay_api_Update_Tuner_GrLimits              = 0x00010000,
+    sdrplay_api_Update_Tuner_Frf                   = 0x00020000,
+    sdrplay_api_Update_Tuner_BwType                = 0x00040000,
+    sdrplay_api_Update_Tuner_IfType                = 0x00080000,
+    sdrplay_api_Update_Tuner_DcOffset              = 0x00100000,
+    sdrplay_api_Update_Tuner_LoMode                = 0x00200000,
+
+    sdrplay_api_Update_Ctrl_DCoffsetIQimbalance    = 0x00400000,
+    sdrplay_api_Update_Ctrl_Decimation             = 0x00800000,
+    sdrplay_api_Update_Ctrl_Agc                    = 0x01000000,
+    sdrplay_api_Update_Ctrl_AdsbMode               = 0x02000000,
+    sdrplay_api_Update_Ctrl_OverloadMsgAck         = 0x04000000,
+
+    sdrplay_api_Update_RspDuo_BiasTControl         = 0x08000000,
+    sdrplay_api_Update_RspDuo_AmPortSelect         = 0x10000000,
+    sdrplay_api_Update_RspDuo_Tuner1AmNotchControl = 0x20000000,
+    sdrplay_api_Update_RspDuo_RfNotchControl       = 0x40000000,
+    sdrplay_api_Update_RspDuo_RfDabNotchControl    = 0x80000000,
+} sdrplay_api_ReasonForUpdateT;
+
+typedef enum
+{
+    sdrplay_api_Update_Ext1_None                   = 0x00000000,
+
+    // Reasons for master only mode 
+    sdrplay_api_Update_RspDx_HdrEnable             = 0x00000001,
+    sdrplay_api_Update_RspDx_BiasTControl          = 0x00000002,
+    sdrplay_api_Update_RspDx_AntennaControl        = 0x00000004,
+    sdrplay_api_Update_RspDx_RfNotchControl        = 0x00000008,
+    sdrplay_api_Update_RspDx_RfDabNotchControl     = 0x00000010,
+    sdrplay_api_Update_RspDx_HdrBw                 = 0x00000020,
+
+    // Reasons for master and slave mode
+} sdrplay_api_ReasonForUpdateExtension1T;
+
+typedef enum
+{
+    sdrplay_api_DbgLvl_Disable       = 0,
+    sdrplay_api_DbgLvl_Verbose       = 1,
+    sdrplay_api_DbgLvl_Warning       = 2,
+    sdrplay_api_DbgLvl_Error         = 3,
+    sdrplay_api_DbgLvl_Message       = 4,
+} sdrplay_api_DbgLvl_t;
+
+// Device structure 
+typedef struct 
+{
+    char SerNo[SDRPLAY_MAX_SER_NO_LEN];
+    unsigned char hwVer;
+    sdrplay_api_TunerSelectT tuner;
+    sdrplay_api_RspDuoModeT rspDuoMode;
+    unsigned char valid;
+    double rspDuoSampleFreq;
+    HANDLE dev;
+} sdrplay_api_DeviceT;
+
+// Device parameter structure
+typedef struct 
+{
+    sdrplay_api_DevParamsT       *devParams;
+    sdrplay_api_RxChannelParamsT *rxChannelA;
+    sdrplay_api_RxChannelParamsT *rxChannelB;
+} sdrplay_api_DeviceParamsT;
+
+// Extended error message structure
+typedef struct 
+{
+    char file[256];
+    char function[256];
+    int  line;
+    char message[1024];
+} sdrplay_api_ErrorInfoT;
+
+// Comman API function types
+typedef sdrplay_api_ErrT        (*sdrplay_api_Open_t)(void);    
+typedef sdrplay_api_ErrT        (*sdrplay_api_Close_t)(void);    
+typedef sdrplay_api_ErrT        (*sdrplay_api_ApiVersion_t)(float *apiVer);    
+typedef sdrplay_api_ErrT        (*sdrplay_api_LockDeviceApi_t)(void);    
+typedef sdrplay_api_ErrT        (*sdrplay_api_UnlockDeviceApi_t)(void);    
+typedef sdrplay_api_ErrT        (*sdrplay_api_GetDevices_t)(sdrplay_api_DeviceT *devices, unsigned int *numDevs, unsigned int maxDevs);    
+typedef sdrplay_api_ErrT        (*sdrplay_api_SelectDevice_t)(sdrplay_api_DeviceT *device);    
+typedef sdrplay_api_ErrT        (*sdrplay_api_ReleaseDevice_t)(sdrplay_api_DeviceT *device);    
+typedef const char*             (*sdrplay_api_GetErrorString_t)(sdrplay_api_ErrT err);
+typedef sdrplay_api_ErrorInfoT* (*sdrplay_api_GetLastError_t)(sdrplay_api_DeviceT *device);
+typedef sdrplay_api_ErrT        (*sdrplay_api_DisableHeartbeat_t)(void);
+
+// Device API function types
+typedef sdrplay_api_ErrT        (*sdrplay_api_DebugEnable_t)(HANDLE dev, sdrplay_api_DbgLvl_t dbgLvl); 
+typedef sdrplay_api_ErrT        (*sdrplay_api_GetDeviceParams_t)(HANDLE dev, sdrplay_api_DeviceParamsT **deviceParams); 
+typedef sdrplay_api_ErrT        (*sdrplay_api_Init_t)(HANDLE dev, sdrplay_api_CallbackFnsT *callbackFns, void *cbContext); 
+typedef sdrplay_api_ErrT        (*sdrplay_api_Uninit_t)(HANDLE dev);
+typedef sdrplay_api_ErrT        (*sdrplay_api_Update_t)(HANDLE dev, sdrplay_api_TunerSelectT tuner, sdrplay_api_ReasonForUpdateT reasonForUpdate, sdrplay_api_ReasonForUpdateExtension1T reasonForUpdateExt1);
+typedef sdrplay_api_ErrT        (*sdrplay_api_SwapRspDuoActiveTuner_t)(HANDLE dev, sdrplay_api_TunerSelectT *tuner, sdrplay_api_RspDuo_AmPortSelectT tuner1AmPortSel);
+typedef sdrplay_api_ErrT        (*sdrplay_api_SwapRspDuoDualTunerModeSampleRate_t)(double *currentSampleRate, double newSampleRate);
+typedef sdrplay_api_ErrT        (*sdrplay_api_SwapRspDuoMode_t)(sdrplay_api_DeviceT *currDevice, sdrplay_api_DeviceParamsT **deviceParams,
+                                                                sdrplay_api_RspDuoModeT rspDuoMode, double sampleRate, sdrplay_api_TunerSelectT tuner,
+                                                                sdrplay_api_Bw_MHzT bwType, sdrplay_api_If_kHzT ifType, sdrplay_api_RspDuo_AmPortSelectT tuner1AmPortSel);
+
+// API function definitions
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    // Comman API function definitions
+     sdrplay_api_ErrT        sdrplay_api_Open(void);
+     sdrplay_api_ErrT        sdrplay_api_Close(void);
+     sdrplay_api_ErrT        sdrplay_api_ApiVersion(float *apiVer);
+     sdrplay_api_ErrT        sdrplay_api_LockDeviceApi(void);
+     sdrplay_api_ErrT        sdrplay_api_UnlockDeviceApi(void);
+     sdrplay_api_ErrT        sdrplay_api_GetDevices(sdrplay_api_DeviceT *devices, unsigned int *numDevs, unsigned int maxDevs);
+     sdrplay_api_ErrT        sdrplay_api_SelectDevice(sdrplay_api_DeviceT *device);
+     sdrplay_api_ErrT        sdrplay_api_ReleaseDevice(sdrplay_api_DeviceT *device);
+     const char*             sdrplay_api_GetErrorString(sdrplay_api_ErrT err);
+     sdrplay_api_ErrorInfoT* sdrplay_api_GetLastError(sdrplay_api_DeviceT *device);
+     sdrplay_api_ErrT        sdrplay_api_DisableHeartbeat(void); // Must be called before sdrplay_api_SelectDevice()
+
+    // Device API function definitions
+     sdrplay_api_ErrT        sdrplay_api_DebugEnable(HANDLE dev, sdrplay_api_DbgLvl_t enable);
+     sdrplay_api_ErrT        sdrplay_api_GetDeviceParams(HANDLE dev, sdrplay_api_DeviceParamsT **deviceParams);
+     sdrplay_api_ErrT        sdrplay_api_Init(HANDLE dev, sdrplay_api_CallbackFnsT *callbackFns, void *cbContext);
+     sdrplay_api_ErrT        sdrplay_api_Uninit(HANDLE dev);
+     sdrplay_api_ErrT        sdrplay_api_Update(HANDLE dev, sdrplay_api_TunerSelectT tuner, sdrplay_api_ReasonForUpdateT reasonForUpdate, sdrplay_api_ReasonForUpdateExtension1T reasonForUpdateExt1);
+     sdrplay_api_ErrT        sdrplay_api_SwapRspDuoActiveTuner(HANDLE dev, sdrplay_api_TunerSelectT *currentTuner, sdrplay_api_RspDuo_AmPortSelectT tuner1AmPortSel);
+     sdrplay_api_ErrT        sdrplay_api_SwapRspDuoDualTunerModeSampleRate(HANDLE dev, double *currentSampleRate, double newSampleRate);
+     sdrplay_api_ErrT        sdrplay_api_SwapRspDuoMode(sdrplay_api_DeviceT *currDevice, sdrplay_api_DeviceParamsT **deviceParams,
+                                                                              sdrplay_api_RspDuoModeT rspDuoMode, double sampleRate, sdrplay_api_TunerSelectT tuner,
+                                                                              sdrplay_api_Bw_MHzT bwType, sdrplay_api_If_kHzT ifType, sdrplay_api_RspDuo_AmPortSelectT tuner1AmPortSel);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //SDRPLAY_API_H

artifacts/sdrplay-api-headers/v3_11/sdrplay_api_callback.h

@@ -0,0 +1,79 @@
+#ifndef SDRPLAY_API_CALLBACK_H
+#define SDRPLAY_API_CALLBACK_H
+
+// Event callback enums
+typedef enum
+{
+    sdrplay_api_Overload_Detected     = 0,
+    sdrplay_api_Overload_Corrected    = 1,
+} sdrplay_api_PowerOverloadCbEventIdT;
+
+typedef enum
+{
+    sdrplay_api_MasterInitialised      = 0,
+    sdrplay_api_SlaveAttached          = 1,
+    sdrplay_api_SlaveDetached          = 2,
+    sdrplay_api_SlaveInitialised       = 3,
+    sdrplay_api_SlaveUninitialised     = 4,
+    sdrplay_api_MasterDllDisappeared   = 5,
+    sdrplay_api_SlaveDllDisappeared    = 6,
+} sdrplay_api_RspDuoModeCbEventIdT;
+
+typedef enum
+{
+    sdrplay_api_GainChange            = 0,
+    sdrplay_api_PowerOverloadChange   = 1,
+    sdrplay_api_DeviceRemoved         = 2,
+    sdrplay_api_RspDuoModeChange      = 3,
+    sdrplay_api_DeviceFailure         = 4,
+} sdrplay_api_EventT;
+
+// Event callback parameter structs
+typedef struct 
+{
+    unsigned int gRdB;
+    unsigned int lnaGRdB;
+    double currGain;
+} sdrplay_api_GainCbParamT;
+
+typedef struct 
+{
+    sdrplay_api_PowerOverloadCbEventIdT powerOverloadChangeType;
+} sdrplay_api_PowerOverloadCbParamT;
+
+typedef struct 
+{
+    sdrplay_api_RspDuoModeCbEventIdT modeChangeType;
+} sdrplay_api_RspDuoModeCbParamT;
+
+// Event parameters overlay
+typedef union
+{
+    sdrplay_api_GainCbParamT          gainParams;
+    sdrplay_api_PowerOverloadCbParamT powerOverloadParams;
+    sdrplay_api_RspDuoModeCbParamT    rspDuoModeParams;
+} sdrplay_api_EventParamsT;
+
+// Stream callback parameter structs
+typedef struct 
+{
+    unsigned int firstSampleNum;
+    int grChanged;
+    int rfChanged;
+    int fsChanged;
+    unsigned int numSamples;
+} sdrplay_api_StreamCbParamsT;
+
+// Callback function prototypes
+typedef void (*sdrplay_api_StreamCallback_t)(short *xi, short *xq, sdrplay_api_StreamCbParamsT *params, unsigned int numSamples, unsigned int reset, void *cbContext); 
+typedef void (*sdrplay_api_EventCallback_t)(sdrplay_api_EventT eventId, sdrplay_api_TunerSelectT tuner, sdrplay_api_EventParamsT *params, void *cbContext); 
+
+// Callback function struct
+typedef struct 
+{
+    sdrplay_api_StreamCallback_t StreamACbFn;
+    sdrplay_api_StreamCallback_t StreamBCbFn;
+    sdrplay_api_EventCallback_t  EventCbFn;
+} sdrplay_api_CallbackFnsT;
+
+#endif //SDRPLAY_API_CALLBACK_H

artifacts/sdrplay-api-headers/v3_11/sdrplay_api_control.h

@@ -0,0 +1,55 @@
+#ifndef SDRPLAY_API_CONTROL_H
+#define SDRPLAY_API_CONTROL_H
+
+// Control parameter enums
+typedef enum
+{
+    sdrplay_api_AGC_DISABLE  = 0,
+    sdrplay_api_AGC_100HZ    = 1,
+    sdrplay_api_AGC_50HZ     = 2,
+    sdrplay_api_AGC_5HZ      = 3,
+    sdrplay_api_AGC_CTRL_EN  = 4
+} sdrplay_api_AgcControlT;
+
+typedef enum
+{
+    sdrplay_api_ADSB_DECIMATION                  = 0,
+    sdrplay_api_ADSB_NO_DECIMATION_LOWPASS       = 1,
+    sdrplay_api_ADSB_NO_DECIMATION_BANDPASS_2MHZ = 2,
+    sdrplay_api_ADSB_NO_DECIMATION_BANDPASS_3MHZ = 3
+} sdrplay_api_AdsbModeT;
+
+// Control parameter structs
+typedef struct 
+{
+    unsigned char DCenable;          // default: 1
+    unsigned char IQenable;          // default: 1
+} sdrplay_api_DcOffsetT;
+
+typedef struct 
+{
+    unsigned char enable;            // default: 0
+    unsigned char decimationFactor;  // default: 1
+    unsigned char wideBandSignal;    // default: 0
+} sdrplay_api_DecimationT;
+
+typedef struct 
+{
+    sdrplay_api_AgcControlT enable;    // default: sdrplay_api_AGC_50HZ
+    int setPoint_dBfs;                 // default: -60
+    unsigned short attack_ms;          // default: 0
+    unsigned short decay_ms;           // default: 0
+    unsigned short decay_delay_ms;     // default: 0
+    unsigned short decay_threshold_dB; // default: 0
+    int syncUpdate;                    // default: 0
+} sdrplay_api_AgcT;
+
+typedef struct 
+{
+    sdrplay_api_DcOffsetT dcOffset;
+    sdrplay_api_DecimationT decimation;
+    sdrplay_api_AgcT agc;
+    sdrplay_api_AdsbModeT adsbMode;  //default: sdrplay_api_ADSB_DECIMATION
+} sdrplay_api_ControlParamsT;
+
+#endif //SDRPLAY_API_CONTROL_H

artifacts/sdrplay-api-headers/v3_11/sdrplay_api_dev.h

@@ -0,0 +1,51 @@
+#ifndef SDRPLAY_API_DEV_H
+#define SDRPLAY_API_DEV_H
+
+#include "sdrplay_api_rsp1a.h"
+#include "sdrplay_api_rsp2.h"
+#include "sdrplay_api_rspDuo.h"
+#include "sdrplay_api_rspDx.h"
+
+// Dev parameter enums
+typedef enum
+{
+    sdrplay_api_ISOCH = 0,
+    sdrplay_api_BULK  = 1
+} sdrplay_api_TransferModeT;
+
+// Dev parameter structs
+typedef struct 
+{
+    double fsHz;                        // default: 2000000.0
+    unsigned char syncUpdate;           // default: 0
+    unsigned char reCal;                // default: 0
+} sdrplay_api_FsFreqT;
+
+typedef struct 
+{
+    unsigned int sampleNum;             // default: 0
+    unsigned int period;                // default: 0
+} sdrplay_api_SyncUpdateT;
+
+typedef struct 
+{
+    unsigned char resetGainUpdate;      // default: 0
+    unsigned char resetRfUpdate;        // default: 0
+    unsigned char resetFsUpdate;        // default: 0
+} sdrplay_api_ResetFlagsT;   
+
+typedef struct 
+{
+    double ppm;                         // default: 0.0
+    sdrplay_api_FsFreqT fsFreq;
+    sdrplay_api_SyncUpdateT syncUpdate; 
+    sdrplay_api_ResetFlagsT resetFlags; 
+    sdrplay_api_TransferModeT mode;     // default: sdrplay_api_ISOCH
+    unsigned int samplesPerPkt;         // default: 0 (output param)
+    sdrplay_api_Rsp1aParamsT rsp1aParams;
+    sdrplay_api_Rsp2ParamsT rsp2Params;
+    sdrplay_api_RspDuoParamsT rspDuoParams;
+    sdrplay_api_RspDxParamsT rspDxParams;
+} sdrplay_api_DevParamsT;
+
+#endif //SDRPLAY_API_DEV_H

artifacts/sdrplay-api-headers/v3_11/sdrplay_api_rsp1a.h

@@ -0,0 +1,22 @@
+#ifndef SDRPLAY_API_RSP1A_H
+#define SDRPLAY_API_RSP1A_H
+
+#define RSPIA_NUM_LNA_STATES         10
+#define RSPIA_NUM_LNA_STATES_AM      7
+#define RSPIA_NUM_LNA_STATES_LBAND   9
+
+// RSP1A parameter enums
+
+// RSP1A parameter structs
+typedef struct 
+{
+    unsigned char rfNotchEnable;                              // default: 0
+    unsigned char rfDabNotchEnable;                           // default: 0
+} sdrplay_api_Rsp1aParamsT;
+
+typedef struct 
+{
+    unsigned char biasTEnable;                   // default: 0
+} sdrplay_api_Rsp1aTunerParamsT;
+
+#endif //SDRPLAY_API_RSP1A_H

artifacts/sdrplay-api-headers/v3_11/sdrplay_api_rsp2.h

@@ -0,0 +1,35 @@
+#ifndef SDRPLAY_API_RSP2_H
+#define SDRPLAY_API_RSP2_H
+
+#define RSPII_NUM_LNA_STATES         9
+#define RSPII_NUM_LNA_STATES_AMPORT  5
+#define RSPII_NUM_LNA_STATES_420MHZ  6
+
+// RSP2 parameter enums
+typedef enum
+{
+    sdrplay_api_Rsp2_ANTENNA_A = 5,
+    sdrplay_api_Rsp2_ANTENNA_B = 6,
+} sdrplay_api_Rsp2_AntennaSelectT;
+
+typedef enum
+{
+    sdrplay_api_Rsp2_AMPORT_1 = 1,
+    sdrplay_api_Rsp2_AMPORT_2 = 0,
+} sdrplay_api_Rsp2_AmPortSelectT;
+
+// RSP2 parameter structs
+typedef struct 
+{
+    unsigned char extRefOutputEn;                // default: 0
+} sdrplay_api_Rsp2ParamsT;
+
+typedef struct 
+{
+    unsigned char biasTEnable;                   // default: 0
+    sdrplay_api_Rsp2_AmPortSelectT amPortSel;    // default: sdrplay_api_Rsp2_AMPORT_2
+    sdrplay_api_Rsp2_AntennaSelectT antennaSel;  // default: sdrplay_api_Rsp2_ANTENNA_A
+    unsigned char rfNotchEnable;                 // default: 0
+} sdrplay_api_Rsp2TunerParamsT;
+
+#endif //SDRPLAY_API_RSP2_H

artifacts/sdrplay-api-headers/v3_11/sdrplay_api_rspDuo.h

@@ -0,0 +1,40 @@
+#ifndef SDRPLAY_API_RSPduo_H
+#define SDRPLAY_API_RSPduo_H
+
+#define RSPDUO_NUM_LNA_STATES         10
+#define RSPDUO_NUM_LNA_STATES_AMPORT  5
+#define RSPDUO_NUM_LNA_STATES_AM      7
+#define RSPDUO_NUM_LNA_STATES_LBAND   9
+
+// RSPduo parameter enums
+typedef enum
+{
+    sdrplay_api_RspDuoMode_Unknown      = 0,
+    sdrplay_api_RspDuoMode_Single_Tuner = 1,
+    sdrplay_api_RspDuoMode_Dual_Tuner   = 2,
+    sdrplay_api_RspDuoMode_Master       = 4,
+    sdrplay_api_RspDuoMode_Slave        = 8,
+} sdrplay_api_RspDuoModeT;
+
+typedef enum
+{
+    sdrplay_api_RspDuo_AMPORT_1 = 1,
+    sdrplay_api_RspDuo_AMPORT_2 = 0,
+} sdrplay_api_RspDuo_AmPortSelectT;
+
+// RSPduo parameter structs
+typedef struct 
+{
+    int extRefOutputEn;                             // default: 0
+} sdrplay_api_RspDuoParamsT;
+
+typedef struct 
+{
+    unsigned char biasTEnable;                      // default: 0
+    sdrplay_api_RspDuo_AmPortSelectT tuner1AmPortSel; // default: sdrplay_api_RspDuo_AMPORT_2
+    unsigned char tuner1AmNotchEnable;              // default: 0
+    unsigned char rfNotchEnable;                    // default: 0
+    unsigned char rfDabNotchEnable;                 // default: 0
+} sdrplay_api_RspDuoTunerParamsT;
+
+#endif //SDRPLAY_API_RSPduo_H

artifacts/sdrplay-api-headers/v3_11/sdrplay_api_rspDx.h

@@ -0,0 +1,46 @@
+#ifndef SDRPLAY_API_RSPDX_H
+#define SDRPLAY_API_RSPDX_H
+
+#include "sdrplay_api_tuner.h"
+
+#define RSPDX_NUM_LNA_STATES               28   // Number of LNA states in all bands (except where defined differently below)
+#define RSPDX_NUM_LNA_STATES_AMPORT2_0_12  19   // Number of LNA states when using AM Port 2 between 0 and 12MHz
+#define RSPDX_NUM_LNA_STATES_AMPORT2_12_50 20   // Number of LNA states when using AM Port 2 between 12 and 50MHz
+#define RSPDX_NUM_LNA_STATES_AMPORT2_50_60 25   // Number of LNA states when using AM Port 2 between 50 and 60MHz
+#define RSPDX_NUM_LNA_STATES_VHF_BAND3     27   // Number of LNA states in VHF and Band3
+#define RSPDX_NUM_LNA_STATES_420MHZ        21   // Number of LNA states in 420MHz band
+#define RSPDX_NUM_LNA_STATES_LBAND         19   // Number of LNA states in L-band
+#define RSPDX_NUM_LNA_STATES_DX            22   // Number of LNA states in DX path
+
+// RSPdx parameter enums
+typedef enum
+{
+    sdrplay_api_RspDx_ANTENNA_A = 0,
+    sdrplay_api_RspDx_ANTENNA_B = 1,
+    sdrplay_api_RspDx_ANTENNA_C = 2,
+} sdrplay_api_RspDx_AntennaSelectT;
+
+typedef enum
+{
+    sdrplay_api_RspDx_HDRMODE_BW_0_200  = 0,
+    sdrplay_api_RspDx_HDRMODE_BW_0_500  = 1,
+    sdrplay_api_RspDx_HDRMODE_BW_1_200  = 2,
+    sdrplay_api_RspDx_HDRMODE_BW_1_700  = 3,
+} sdrplay_api_RspDx_HdrModeBwT;
+
+// RSPdx parameter structs
+typedef struct 
+{
+    unsigned char hdrEnable;                            // default: 0
+    unsigned char biasTEnable;                          // default: 0
+    sdrplay_api_RspDx_AntennaSelectT antennaSel;        // default: sdrplay_api_RspDx_ANTENNA_A
+    unsigned char rfNotchEnable;                        // default: 0
+    unsigned char rfDabNotchEnable;                     // default: 0
+} sdrplay_api_RspDxParamsT;
+
+typedef struct 
+{
+    sdrplay_api_RspDx_HdrModeBwT hdrBw;                 // default: sdrplay_api_RspDx_HDRMODE_BW_1_700
+} sdrplay_api_RspDxTunerParamsT;
+
+#endif //SDRPLAY_API_RSPDX_H

artifacts/sdrplay-api-headers/v3_11/sdrplay_api_rx_channel.h

@@ -0,0 +1,21 @@
+#ifndef SDRPLAY_API_RX_CHANNEL_H
+#define SDRPLAY_API_RX_CHANNEL_H
+
+#include "sdrplay_api_tuner.h"
+#include "sdrplay_api_control.h"
+#include "sdrplay_api_rsp1a.h"
+#include "sdrplay_api_rsp2.h"
+#include "sdrplay_api_rspDuo.h"
+#include "sdrplay_api_rspDx.h"
+
+typedef struct 
+{
+    sdrplay_api_TunerParamsT        tunerParams;    
+    sdrplay_api_ControlParamsT      ctrlParams;     
+    sdrplay_api_Rsp1aTunerParamsT   rsp1aTunerParams; 
+    sdrplay_api_Rsp2TunerParamsT    rsp2TunerParams; 
+    sdrplay_api_RspDuoTunerParamsT  rspDuoTunerParams;    
+    sdrplay_api_RspDxTunerParamsT   rspDxTunerParams;    
+} sdrplay_api_RxChannelParamsT;
+
+#endif //SDRPLAY_API_RX_CHANNEL_H

artifacts/sdrplay-api-headers/v3_11/sdrplay_api_tuner.h

@@ -0,0 +1,93 @@
+#ifndef SDRPLAY_API_TUNER_H
+#define SDRPLAY_API_TUNER_H
+
+#define MAX_BB_GR                         (59)
+
+// Tuner parameter enums
+typedef enum
+{
+    sdrplay_api_BW_Undefined = 0,
+    sdrplay_api_BW_0_200     = 200,
+    sdrplay_api_BW_0_300     = 300,
+    sdrplay_api_BW_0_600     = 600,
+    sdrplay_api_BW_1_536     = 1536,
+    sdrplay_api_BW_5_000     = 5000,
+    sdrplay_api_BW_6_000     = 6000,
+    sdrplay_api_BW_7_000     = 7000,
+    sdrplay_api_BW_8_000     = 8000
+} sdrplay_api_Bw_MHzT;
+
+typedef enum
+{
+    sdrplay_api_IF_Undefined = -1,
+    sdrplay_api_IF_Zero      = 0,
+    sdrplay_api_IF_0_450     = 450,
+    sdrplay_api_IF_1_620     = 1620,
+    sdrplay_api_IF_2_048     = 2048
+} sdrplay_api_If_kHzT;
+
+typedef enum
+{
+    sdrplay_api_LO_Undefined = 0,
+    sdrplay_api_LO_Auto      = 1,
+    sdrplay_api_LO_120MHz    = 2,
+    sdrplay_api_LO_144MHz    = 3,
+    sdrplay_api_LO_168MHz    = 4
+} sdrplay_api_LoModeT;
+
+typedef enum
+{
+    sdrplay_api_EXTENDED_MIN_GR = 0,
+    sdrplay_api_NORMAL_MIN_GR   = 20
+} sdrplay_api_MinGainReductionT;
+
+typedef enum
+{
+    sdrplay_api_Tuner_Neither  = 0,
+    sdrplay_api_Tuner_A        = 1,
+    sdrplay_api_Tuner_B        = 2,
+    sdrplay_api_Tuner_Both     = 3,
+} sdrplay_api_TunerSelectT;
+
+// Tuner parameter structs
+typedef struct
+{
+    float curr;
+    float max;
+    float min;
+} sdrplay_api_GainValuesT;
+
+typedef struct 
+{
+    int gRdB;                            // default: 50
+    unsigned char LNAstate;              // default: 0
+    unsigned char syncUpdate;            // default: 0
+    sdrplay_api_MinGainReductionT minGr; // default: sdrplay_api_NORMAL_MIN_GR
+    sdrplay_api_GainValuesT gainVals;    // output parameter
+} sdrplay_api_GainT;
+
+typedef struct 
+{
+    double rfHz;                         // default: 200000000.0
+    unsigned char syncUpdate;            // default: 0
+} sdrplay_api_RfFreqT;
+
+typedef struct 
+{
+    unsigned char dcCal;                 // default: 3 (Periodic mode)
+    unsigned char speedUp;               // default: 0 (No speedup)
+    int trackTime;                       // default: 1    (=> time in uSec = (72 * 3 * trackTime) / 24e6       = 9uSec)
+    int refreshRateTime;                 // default: 2048 (=> time in uSec = (72 * 3 * refreshRateTime) / 24e6 = 18432uSec)
+} sdrplay_api_DcOffsetTunerT;
+
+typedef struct 
+{
+    sdrplay_api_Bw_MHzT bwType;          // default: sdrplay_api_BW_0_200
+    sdrplay_api_If_kHzT ifType;          // default: sdrplay_api_IF_Zero
+    sdrplay_api_LoModeT loMode;          // default: sdrplay_api_LO_Auto
+    sdrplay_api_GainT gain;
+    sdrplay_api_RfFreqT rfFreq;
+    sdrplay_api_DcOffsetTunerT dcOffsetTuner;
+} sdrplay_api_TunerParamsT;
+
+#endif //SDRPLAY_API_TUNER_H

build.gradle

@@ -1,6 +1,8 @@
+import java.text.SimpleDateFormat
+
 /*
  * *****************************************************************************
- * Copyright (C) 2014-2022 Dennis Sheirer
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,6 +18,29 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>
  * ****************************************************************************
  */
+
+/**
+ * Instructions for building/compiling the sdrtrunk application.
+ *
+ * Prerequisites:
+ * Install and configure an OpenJDK version 19+ that includes the JavaFX modules (e.g. Bellsoft Liberica JDK)
+ * - Optional: install and configure Gradle 7.6+
+ *
+ * Scenario 1: run the application via gradle command line from the source code root directory:
+ * command: ./gradlew run
+ *
+ * Scenario 2: create an application release for the current operating system
+ * command: ./gradlew runtimeZipCurrent
+ * Note: release image is located in the /build/image/ directory
+ *
+ * Scenario 3: create releases for Linux and OSX operating systems using downloaded JDKs
+ * command: ./gradlew runtimeZipOthers
+ * Note: release images are located in the /build/image/ directory
+ *
+ * Scenario 4: create release for Windows operating system using downloaded JDK
+ * command: ./gradlew runtimeZipWindows
+ * Note: release image is located in the /build/image/ directory
+ */
 plugins {
     id 'application'
     id 'java'
@@ -28,8 +53,14 @@ repositories {
     maven { url "https://jitpack.io" }
 }
 
-version = '0.5.0'
-sourceCompatibility = '17'
+version = '0.6.0-alpha5'
+
+//Java 19 is required for this version of the Project Panama preview/incubator feature
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(19)
+    }
+}
 
 sourceSets {
     main.java.srcDirs 'src/main'
@@ -43,10 +74,10 @@ test {
 dependencies {
 
     // JUnit Tests
-    testImplementation 'junit:junit:4.12'
-    testImplementation 'org.assertj:assertj-core:3.8.0'
-    testImplementation("org.junit.jupiter:junit-jupiter-api:5.7.0")
-    testImplementation 'org.mockito:mockito-core:3.+'
+    testImplementation 'junit:junit:4.13.2'
+    testImplementation 'org.assertj:assertj-core:3.23.1'
+    testImplementation('org.junit.jupiter:junit-jupiter-api:5.9.0')
+    testImplementation 'org.mockito:mockito-core:4.8.0'
 
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
 
@@ -56,33 +87,33 @@ dependencies {
     implementation 'com.github.nwaldispuehl:java-lame:v3.98.4'
 
     //mavenCentral/jcenter imports
-    implementation 'ch.qos.logback:logback-classic:1.2.3'
-    implementation 'ch.qos.logback:logback-core:1.2.3'
-    implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-xml:2.13.2'
-    implementation 'com.fazecast:jSerialComm:2.5.0'
+    implementation 'ch.qos.logback:logback-classic:1.4.5'
+    implementation 'ch.qos.logback:logback-core:1.4.5'
+    implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-xml:2.14.0'
+    implementation 'com.fazecast:jSerialComm:2.9.3'
     implementation 'com.github.jiconfont:jiconfont-font_awesome:4.7.0.1'
     implementation 'com.github.jiconfont:jiconfont-javafx:1.0.0'
     implementation 'com.github.jiconfont:jiconfont-swing:1.0.1'
     implementation 'com.github.wendykierp:JTransforms:3.1'
-    implementation 'com.google.code.gson:gson:2.8.6'
-    implementation 'com.google.guava:guava:27.0.1-jre'
+    implementation 'com.google.code.gson:gson:2.10'
+    implementation 'com.google.guava:guava:31.1-jre'
     implementation 'com.jidesoft:jide-oss:3.6.18'
-    implementation 'com.miglayout:miglayout-swing:5.2'
+    implementation 'com.miglayout:miglayout-swing:11.0'
     implementation 'com.mpatric:mp3agic:0.9.1'
-    implementation 'commons-io:commons-io:2.7'
+    implementation 'commons-io:commons-io:2.11.0'
     implementation 'eu.hansolo:charts:1.0.5'
-    implementation 'io.github.dsheirer:radio-reference-api:15.1.8'
+    implementation 'io.github.dsheirer:radio-reference-api:15.1.9'
     implementation 'javax.usb:usb-api:1.0.2'
-    implementation 'net.coderazzi:tablefilter-swing:5.4.0'
-    implementation 'org.apache.commons:commons-compress:1.20'
-    implementation 'org.apache.commons:commons-lang3:3.8.1'
+    implementation 'net.coderazzi:tablefilter-swing:5.5.4'
+    implementation 'org.apache.commons:commons-compress:1.21'
+    implementation 'org.apache.commons:commons-lang3:3.12.0'
     implementation 'org.apache.commons:commons-math3:3.6.1'
     implementation 'org.apache.commons:commons-csv:1.9.0'
-    implementation 'org.apache.mina:mina-core:2.1.3'
-    implementation 'org.apache.mina:mina-http:2.1.3'
-    implementation 'org.controlsfx:controlsfx:11.1.0'
-    implementation 'org.rauschig:jarchivelib:1.0.0'
-    implementation 'org.slf4j:slf4j-api:1.7.25'
+    implementation 'org.apache.mina:mina-core:2.2.1'
+    implementation 'org.apache.mina:mina-http:2.2.1'
+    implementation 'org.controlsfx:controlsfx:11.1.2'
+    implementation 'org.rauschig:jarchivelib:1.2.0'
+    implementation 'org.slf4j:slf4j-api:2.0.5'
     implementation 'org.usb4java:libusb4java:1.3.0'
     implementation 'org.usb4java:usb4java:1.3.0'
     implementation 'org.usb4java:usb4java-javax:1.3.0'
@@ -90,19 +121,46 @@ dependencies {
     implementation 'pl.edu.icm:JLargeArrays:1.6'
 }
 
+def os = org.gradle.nativeplatform.platform.internal.DefaultNativePlatform.currentOperatingSystem
+
 /**
- * This is needed for the JDK17 vector API ... until it moves out of incubation
+ * This is needed for the JDK19 panama and vector API ... until it moves out of incubation or preview
  */
 tasks.withType(JavaCompile) {
+    options.compilerArgs.add("--enable-preview") //Panama Foreign Function/Memory is preview in JDK 19
     options.compilerArgs.add("--add-modules=jdk.incubator.vector") //Needed while Panama Vector API remains in incubator
 }
 
+/**
+ * JVM Arguments for running the application on Windows.
+ */
+def jvmArgsWindows =
+        ['--add-exports=javafx.base/com.sun.javafx.event=ALL-UNNAMED', //Needed for controls-fx.jar
+         '--add-exports=java.desktop/com.sun.java.swing.plaf.windows=ALL-UNNAMED', //windows users for JIDE
+         '--add-modules=jdk.incubator.vector',   //Needed while Project Panama API is still in incubator
+         '--enable-preview', //Project Panama Vector & Foreign Function APIs remain in incubator
+         '--enable-native-access=ALL-UNNAMED',
+         '-Djava.library.path=c:\\Program Files\\SDRplay\\API\\x64'] //Allows Project Panama Foreign Function access to system library
+
+/**
+ * JVM Arguments for running the application on Linux.
+ */
+def jvmArgsLinux =
+        ['--add-exports=javafx.base/com.sun.javafx.event=ALL-UNNAMED', //Needed for controls-fx.jar
+         '--add-modules=jdk.incubator.vector',   //Needed while Project Panama API is still in incubator
+         '--enable-preview', //Project Panama Vector & Foreign Function APIs remain in incubator
+         '--enable-native-access=ALL-UNNAMED',
+         '-Djava.library.path=/usr/local/lib'] //Allows Project Panama Foreign Function access to system library
+
 application {
     mainClassName = "io.github.dsheirer.gui.SDRTrunk"
-    applicationDefaultJvmArgs =
-        ['--add-exports=javafx.base/com.sun.javafx.event=ALL-UNNAMED', //Needed for controls-fx.jar
-         '--add-modules=jdk.incubator.vector',   //Needed while Panama Vector API remains in incubator
-         '--add-exports=java.desktop/com.sun.java.swing.plaf.windows=ALL-UNNAMED'] //Windows Swing - jide-oss library
+
+    if(os.isWindows()) {
+        applicationDefaultJvmArgs = jvmArgsWindows
+    }
+    else {
+        applicationDefaultJvmArgs = jvmArgsLinux
+    }
 }
 
 jar {
@@ -111,7 +169,7 @@ jar {
                 'Implementation-Title'  : 'sdrtrunk project',
                 'Implementation-Version' : archiveVersion,
                 'Created-By'            : "Gradle ${gradle.gradleVersion}",
-                'Build-Timestamp'       : new java.text.SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ").format(new Date()),
+                'Build-Timestamp'       : new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ").format(new Date()),
                 'Build-JDK'             : "${System.properties['java.version']} (${System.properties['java.vendor']} ${System.properties['java.vm.version']}",
                 'Build-OS'              : "${System.properties['os.name']} (${System.properties['os.arch']} ${System.properties['os.version']}"
         )
@@ -139,88 +197,158 @@ String targetWindowsX86_64 = 'windows-x86_64-v' + version
  * author's development environment, but can be changed to your environment if you want to use this build pattern.
  */
 String jdk_base = '/home/denny/java_jdks/'
-String jdk_linux_aarch64 = jdk_base + 'linux-arm64/jdk-18.0.1-full'
-String jdk_linux_x86_64 = jdk_base + 'linux-x64/jdk-18.0.1-full'
-String jdk_osx_x86_64 = jdk_base + 'osx-x64/jdk-18.0.1-full.jdk'
-String jdk_osx_aarch64 = jdk_base + 'osx-arm64/jdk-18.0.1-full.jdk'
-String jdk_windows_x86_64 = jdk_base + 'windows-x64/jdk-18.0.1-full'
-
-boolean hasTargetJdks = file(jdk_linux_x86_64).exists() || file(jdk_linux_aarch64).exists() ||
-        file(jdk_osx_x86_64).exists() || file(jdk_osx_aarch64).exists() || file(jdk_windows_x86_64).exists()
+String jdk_linux_aarch64 = jdk_base + 'linux-arm64/jdk-19.0.1-full'
+String jdk_linux_x86_64 = jdk_base + 'linux-x64/jdk-19.0.1-full'
+String jdk_osx_x86_64 = jdk_base + 'osx-x64/jdk-19.0.1-full.jdk'
+String jdk_osx_aarch64 = jdk_base + 'osx-arm64/jdk-19.0.1-full.jdk'
+String jdk_windows_x86_64 = jdk_base + 'windows-x64/jdk-19.0.1-full'
 
 /**
- * Auto-download target JDKs.  Defaults to false, or the user can override via the gradle command line by
- * including this option: '-PdownloadJdks=true'
+ * Download URLs to download the JDK as part of the gradle build packaging process
  */
-boolean downloadJdks = project.hasProperty('downloadJdks') ? project.getProperty('downloadJdks') : false
+def jdk_download_base = "https://download.bell-sw.com/java/19.0.1+11/bellsoft-jdk19.0.1+11-"
+def jdk_download_suffix = "-full.tar.gz"
+def jdk_download_linux_aarch64 = jdk_download_base + "linux-aarch64" + jdk_download_suffix
+def jdk_download_linux_x86_64 = jdk_download_base + "linux-amd64" + jdk_download_suffix
+def jdk_download_osx_x86_64 = jdk_download_base + "macos-aarch64" + jdk_download_suffix
+def jdk_download_osx_aarch64 = jdk_download_base + "macos-amd64" + jdk_download_suffix
+def jdk_download_windows_x86_64 = jdk_download_base + "windows-amd64-full.zip"
 
 /**
- * Beryx Runtime plugin for creating OS and CPU targeted build(s) of the software.
- *
- * Option 1: Create a single target build using the locally installed JDK, or optionally create target builds for
- * all OS and CPU targets when pre-downloaded target JDKs are available (see 'jdk_*' properties above).
- *
- *    >: gradle runtimeZip
- *
- * Option 2: Create all OS and CPU target builds by automatically downloading all JDKs needed to build the target images
- *
- *    >: gradle runtimeZip -PdownloadJdks=true
+ * Configures the runtime zip task with additional options/settings.
+ * @param rt task to configure
+ * @param jvmArgs to use (windows or linux)
+ * @return configured task.
  */
-runtime {
-    //Build by automatically downloading JDKs for the OS and CPU targets
-    if(downloadJdks) {
-        println("Building all runtime images")
-        println("The [ > jre: ] build phase downloads several target JDKs and this may take a while ... please wait")
-        targetPlatform(targetLinuxAarch64) {
-            jdkHome = jdkDownload("https://download.bell-sw.com/java/18.0.1+12/bellsoft-jdk18.0.1+12-linux-aarch64-full.tar.gz")
-        }
-        targetPlatform(targetLinuxX86_64) {
-            jdkHome = jdkDownload("https://download.bell-sw.com/java/18.0.1+12/bellsoft-jdk18.0.1+12-linux-amd64-full.tar.gz")
-        }
-        targetPlatform(targetOsxAarch64) {
-            jdkHome = jdkDownload("https://download.bell-sw.com/java/18.0.1+12/bellsoft-jdk18.0.1+12-macos-aarch64-full.tar.gz")
-        }
-        targetPlatform(targetOsxX86_64) {
-            jdkHome = jdkDownload("https://download.bell-sw.com/java/18.0.1+12/bellsoft-jdk18.0.1+12-macos-amd64-full.tar.gz")
-        }
-        targetPlatform(targetWindowsX86_64) {
-            jdkHome = jdkDownload("https://download.bell-sw.com/java/18.0.1+12/bellsoft-jdk18.0.1+12-windows-amd64-full.zip")
-        }
-    }
-    //Build using pre-downloaded JDKs
-    else if(hasTargetJdks) {
-        println("Building all runtime images using pre-downloaded JDKs")
-        if(file(jdk_linux_aarch64).exists()) {
-            targetPlatform(targetLinuxAarch64, jdk_linux_aarch64)
-        }
-        if(file(jdk_linux_x86_64).exists()) {
-            targetPlatform(targetLinuxX86_64, jdk_linux_x86_64)
-        }
-        if(file(jdk_osx_aarch64).exists()) {
-            targetPlatform(targetOsxAarch64, jdk_osx_aarch64)
-        }
-        if(file(jdk_osx_x86_64).exists()) {
-            targetPlatform(targetOsxX86_64, jdk_osx_x86_64)
-        }
-        if(file(jdk_windows_x86_64).exists()) {
-            targetPlatform(targetWindowsX86_64, jdk_windows_x86_64)
-        }
-    }
-    //Build using locally installed JDK only
-    else {
-        println("Building a single runtime image using locally installed JDK")
-    }
+def configure(org.beryx.runtime.RuntimeZipTask rt, List<String> jvmArgs) {
+    //Use the correct set of JVM arguments
+    rt.extension.launcherData.get().jvmArgs = jvmArgs
 
     //Additional modules to include with auto-detected modules.
-    modules = ['jdk.crypto.ec'] //jdk.crypto.ec needed for HTTPS connections (broadcastify calls & map tile server)
+    //jdk.crypto.ec - needed for HTTPS connections (broadcastify calls & map tile server)
+    //jdk.incubator.vector - needed for Project Panama foreign function and vector apis
+    //jdk.accessibility is used with assistive technologies like screen readers
+    rt.extension.addModules('jdk.crypto.ec', 'jdk.incubator.vector', 'jdk.accessibility')
 
     //Use auto-detected modules and 'add' any specified modules.
-    additive = true
+    rt.extension.additive.set(true)
 
     //Recommended options for reducing/shrinking runtime target image size
-    options = ['--strip-debug', '--compress', '2', '--no-header-files', '--no-man-pages']
+    rt.extension.addOptions('--strip-debug', '--compress', '2', '--no-header-files', '--no-man-pages')
 
     //Runtime images have auto appended version in image zip name.  Override to include version in single target image.
-    imageZip = (hasTargetJdks | downloadJdks) ? file("$buildDir/image/sdr-trunk.zip") :
-            file("$buildDir/image/sdr-trunk-" + version + ".zip")
+    rt.extension.imageZip.set(file("$buildDir/image/sdr-trunk.zip"))
 }
+
+/**
+ * Creates a release package for the current operating system.
+ *
+ * Note: you cannot create both Windows and Linux releases at the same time due to limitations of the Runtime plugin
+ *
+ * Usage: gradle runtimeZipCurrent
+ * Usage: gradlew runtimeZipCurrent   (windows - using gradlew)
+ * Usage: ./gradlew runtimeZipCurrent   (linux - using gradlew)
+ */
+tasks.register('runtimeZipCurrent', org.beryx.runtime.RuntimeZipTask) {rt ->
+    def arch = System.properties.getProperty("os.arch")
+    def javaHome = org.gradle.internal.jvm.Jvm.current().getJavaHome().toString()
+
+    if(os.isWindows()) {
+        rt.extension.targetPlatform(targetWindowsX86_64, javaHome)
+        configure(rt, jvmArgsWindows)
+    }
+    else if(os.isLinux())
+    {
+        if(arch.equals("amd64")) {
+            rt.extension.targetPlatform(targetLinuxX86_64, javaHome)
+        }
+        else if(arch.equals("aarch64")) {
+            rt.extension.targetPlatform(targetLinuxAarch64, javaHome)
+        }
+        configure(rt, jvmArgsLinux)
+    }
+    else if(os.isMacOsX())
+    {
+        if(arch.equals("amd64")) {
+            rt.extension.targetPlatform(targetOsxX86_64, javaHome)
+        }
+        else if(arch.equals("aarch64")) {
+            rt.extension.targetPlatform(targetOsxAarch64, javaHome)
+        }
+        configure(rt, jvmArgsLinux)
+    }
+}
+
+
+/**
+ * Creates a Windows release package.
+ *
+ * Note: you cannot create both Windows and Linux releases at the same time due to limitations of the Runtime plugin
+ *
+ * Usage: gradle runtimeZipWindows
+ * Usage: gradlew runtimeZipWindows   (windows - using gradlew)
+ * Usage: ./gradlew runtimeZipWindows   (linux - using gradlew)
+ */
+tasks.register('runtimeZipWindows', org.beryx.runtime.RuntimeZipTask) {rt ->
+    if(file(jdk_windows_x86_64).exists()) {
+        rt.extension.targetPlatform(targetWindowsX86_64, jdk_windows_x86_64, [])
+    }
+    else {
+        rt.extension.targetPlatform(targetWindowsX86_64) {
+            jdkHome = jdkDownload(jdk_download_windows_x86_64)
+        }
+    }
+
+    configure(rt, jvmArgsWindows)
+}
+
+/**
+ * Creates Linux & OSX release packages.
+ *
+ * Note: you cannot create both Windows and Linux releases at the same time due to limitations of the Runtime plugin
+ *
+ * Usage: gradle runtimeZipOthers
+ * Usage: gradlew runtimeZipOthers   (windows - using gradlew)
+ * Usage: ./gradlew runtimeZipOthers   (linux - using gradlew)
+ */
+tasks.register('runtimeZipOthers', org.beryx.runtime.RuntimeZipTask) {rt ->
+    //Linux aarch64
+    if(file(jdk_linux_aarch64).exists()) {
+        rt.extension.targetPlatform(targetLinuxAarch64, jdk_linux_aarch64, [])
+    }
+    else {
+        rt.extension.targetPlatform(targetLinuxAarch64) {
+            jdkHome = jdkDownload(jdk_download_linux_aarch64)
+        }
+    }
+    //Linux x86-64
+    if(file(jdk_linux_x86_64).exists()) {
+        rt.extension.targetPlatform(targetLinuxX86_64, jdk_linux_x86_64, [])
+    }
+    else {
+        rt.extension.targetPlatform(targetLinuxX86_64) {
+            jdkHome = jdkDownload(jdk_download_linux_x86_64)
+        }
+    }
+    //OSX aarch64
+    if(file(jdk_osx_aarch64).exists()) {
+        rt.extension.targetPlatform(targetOsxAarch64, jdk_osx_aarch64, [])
+    }
+    else {
+        rt.extension.targetPlatform(targetOsxAarch64) {
+            jdkHome = jdkDownload(jdk_download_osx_aarch64)
+        }
+    }
+    //Linux x86-64
+    if(file(jdk_osx_x86_64).exists()) {
+        rt.extension.targetPlatform(targetOsxX86_64, jdk_osx_x86_64, [])
+    }
+    else {
+        rt.extension.targetPlatform(targetOsxX86_64) {
+            jdkHome = jdkDownload(jdk_download_osx_x86_64)
+        }
+    }
+
+    configure(rt, jvmArgsLinux);
+}
+

gradle/wrapper/gradle-wrapper.properties

@@ -19,6 +19,7 @@
 
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.6-bin.zip
+networkTimeout=10000
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -1,94 +1,132 @@
-#!/usr/bin/env sh
+#!/bin/sh
 
 #
-# Copyright 2015 the original author or authors.
+# ******************************************************************************
+# Copyright (C) 2014-2022 Dennis Sheirer
 #
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
 #
-#      https://www.apache.org/licenses/LICENSE-2.0
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>
+# *****************************************************************************
 #
 
 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
 # Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
 
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
 warn () {
     echo "$*"
-}
+} >&2
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
+
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -97,7 +135,7 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
+    JAVACMD=java
     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
@@ -105,79 +143,105 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=`expr $i + 1`
-    done
-    case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045 
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045 
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
 fi
 
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=`save "$@"`
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
 
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
 
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -14,7 +14,7 @@
 @rem limitations under the License.
 @rem
 
-@if "%DEBUG%" == "" @echo off
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -25,10 +25,14 @@
 if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
 
@@ -37,7 +41,7 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if %ERRORLEVEL% equ 0 goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -51,7 +55,7 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
@@ -61,38 +65,26 @@ echo location of your Java installation.
 
 goto fail
 
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
 :execute
 @rem Setup the command line
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
+
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 0 goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal

src/main/java/io/github/dsheirer/audio/AbstractAudioModule.java

@@ -1,7 +1,6 @@
 /*
- * ******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2018 Dennis Sheirer
+ * *****************************************************************************
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,7 +14,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>
- * *****************************************************************************
+ * ****************************************************************************
  */
 
 package io.github.dsheirer.audio;
@@ -106,7 +105,7 @@ public abstract class AbstractAudioModule extends Module implements IAudioSegmen
      * Gets the current audio segment, or creates a new audio segment as necessary and broadcasts it to any registered
      * listener(s).
      */
-    protected AudioSegment getAudioSegment()
+    public AudioSegment getAudioSegment()
     {
         synchronized(this)
         {
@@ -135,7 +134,7 @@ public abstract class AbstractAudioModule extends Module implements IAudioSegmen
         }
     }
 
-    protected void addAudio(float[] audioBuffer)
+    public void addAudio(float[] audioBuffer)
     {
         AudioSegment audioSegment = getAudioSegment();
 

src/main/java/io/github/dsheirer/audio/AudioSegment.java

@@ -1,18 +1,21 @@
-/*******************************************************************************
- * sdr-trunk
- * Copyright (C) 2014-2020 Dennis Sheirer
+/*
+ * *****************************************************************************
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
- * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public
- * License as published by  the Free Software Foundation, either version 3 of the License, or  (at your option) any
- * later version.
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- * This program is distributed in the hope that it will be useful,  but WITHOUT ANY WARRANTY; without even the implied
- * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License  along with this program.
- * If not, see <http://www.gnu.org/licenses/>
- *
- ******************************************************************************/
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * ****************************************************************************
+ */
 
 package io.github.dsheirer.audio;
 
@@ -26,15 +29,6 @@ import io.github.dsheirer.identifier.IdentifierUpdateNotification;
 import io.github.dsheirer.identifier.MutableIdentifierCollection;
 import io.github.dsheirer.sample.Broadcaster;
 import io.github.dsheirer.sample.Listener;
-import javafx.beans.property.BooleanProperty;
-import javafx.beans.property.IntegerProperty;
-import javafx.beans.property.SimpleBooleanProperty;
-import javafx.beans.property.SimpleIntegerProperty;
-import javafx.collections.FXCollections;
-import javafx.collections.ObservableSet;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
@@ -43,6 +37,14 @@ import java.util.List;
 import java.util.Set;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.atomic.AtomicInteger;
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableSet;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * Audio segment containing all related metadata and a dynamic collection of audio packets.  An audio segment can be
@@ -138,6 +140,15 @@ public class AudioSegment implements Listener<IdentifierUpdateNotification>
         return mComplete;
     }
 
+    /**
+     * Indicates if this audio segment is completed.
+     * @return true if completed.
+     */
+    public boolean isComplete()
+    {
+        return mComplete.get();
+    }
+
     /**
      * Duplicate call audio property.  This flag is set to true whenever a duplicate call detection function detects
      * an audio segment is a duplicate.

src/main/java/io/github/dsheirer/audio/broadcast/AudioStreamingBroadcaster.java

@@ -18,24 +18,22 @@
  */
 package io.github.dsheirer.audio.broadcast;
 
+import io.github.dsheirer.audio.convert.AudioFrames;
 import io.github.dsheirer.audio.convert.ISilenceGenerator;
 import io.github.dsheirer.audio.convert.InputAudioFormat;
+import io.github.dsheirer.audio.convert.MP3FrameTools;
 import io.github.dsheirer.audio.convert.MP3Setting;
 import io.github.dsheirer.identifier.IdentifierCollection;
 import io.github.dsheirer.util.ThreadPool;
-import org.apache.commons.math3.util.FastMath;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.nio.file.Files;
-import java.util.List;
 import java.util.Queue;
 import java.util.concurrent.LinkedTransferQueue;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public abstract class AudioStreamingBroadcaster<T extends BroadcastConfiguration> extends AbstractAudioBroadcaster<T>
 {
@@ -48,6 +46,7 @@ public abstract class AudioStreamingBroadcaster<T extends BroadcastConfiguration
     private Queue<AudioRecording> mAudioRecordingQueue = new LinkedTransferQueue<>();
     private ISilenceGenerator mSilenceGenerator;
 
+    private BroadcastFormat mBroadcastFormat;
     private long mDelay;
     private long mMaximumRecordingAge;
     private AtomicBoolean mStreaming = new AtomicBoolean();
@@ -56,6 +55,8 @@ public abstract class AudioStreamingBroadcaster<T extends BroadcastConfiguration
     protected int mInlineInterval;
     protected int mInlineRemaining = -1;
 
+    private int mTimeOverrun = 0;
+
     /**
      * AudioBroadcaster for streaming audio recordings to a remote streaming audio server.  Audio recordings are
      * generated by an internal StreamManager that converts an inbound stream of AudioPackets into a recording of the
@@ -80,10 +81,11 @@ public abstract class AudioStreamingBroadcaster<T extends BroadcastConfiguration
     public AudioStreamingBroadcaster(T broadcastConfiguration, InputAudioFormat inputAudioFormat, MP3Setting mp3Setting)
     {
         super(broadcastConfiguration);
+        mBroadcastFormat = broadcastConfiguration.getBroadcastFormat();
         mDelay = getBroadcastConfiguration().getDelay();
         mMaximumRecordingAge = getBroadcastConfiguration().getMaximumRecordingAge();
         mSilenceGenerator = BroadcastFactory.getSilenceGenerator(broadcastConfiguration.getBroadcastFormat(),
-                inputAudioFormat, mp3Setting);
+        inputAudioFormat, mp3Setting);
     }
 
     public void dispose()
@@ -249,7 +251,6 @@ public abstract class AudioStreamingBroadcaster<T extends BroadcastConfiguration
     public boolean canConnect()
     {
         BroadcastState state = getBroadcastState();
-
         return state != BroadcastState.CONNECTED && !state.isErrorState();
     }
 
@@ -270,10 +271,8 @@ public abstract class AudioStreamingBroadcaster<T extends BroadcastConfiguration
     public class RecordingQueueProcessor implements Runnable
     {
         private AtomicBoolean mProcessing = new AtomicBoolean();
-        private ByteArrayInputStream mInputStream;
+        private AudioFrames mInputFrames;
         private IdentifierCollection mInputIdentifierCollection;
-        private long mFinalSilencePadding = 0;
-        private int mBytesToStreamPerInterval = 0;
 
         @Override
         public void run()
@@ -282,48 +281,35 @@ public abstract class AudioStreamingBroadcaster<T extends BroadcastConfiguration
             {
                 try
                 {
-                    if(mInputStream == null || mInputStream.available() <= 0)
+                    int timeSent = 0;
+
+                    if(mInputFrames == null || !mInputFrames.hasNextFrame())
                     {
                         nextRecording();
                     }
 
-                    if(mInputStream != null)
+                    if(mInputFrames != null && mInputFrames.hasNextFrame())
                     {
-                        int length = FastMath.min(mBytesToStreamPerInterval, mInputStream.available());
-
-                        byte[] audio = new byte[length];
-
-                        try
+                        while(mInputFrames.hasNextFrame() && timeSent < PROCESSOR_RUN_INTERVAL_MS)
                         {
-                            int read = mInputStream.read(audio);
-                            broadcastAudio(audio, mInputIdentifierCollection);
-                        }
-                        catch(IOException ioe)
-                        {
-                            mLog.error("Error reading from in-memory audio recording input stream", ioe);
-                        }
-
-                        //If this is the final frame fragment then append silence padding to fill the final interval segment
-                        if(length < mBytesToStreamPerInterval && mFinalSilencePadding > 0)
-                        {
-                            List<byte[]> finalSilence = mSilenceGenerator.generate(mFinalSilencePadding);
-
-                            for(byte[] silence: finalSilence)
-                            {
-                                broadcastAudio(silence, null);
-                            }
-
-                            mFinalSilencePadding = 0;
+                            mInputFrames.nextFrame();
+                            broadcastAudio(mInputFrames.getCurrentFrame(), mInputIdentifierCollection);
+                            timeSent += mInputFrames.getCurrentFrameDuration();
                         }
                     }
-                    else
+
+                    if((mInputFrames == null || !mInputFrames.hasNextFrame()) && timeSent < PROCESSOR_RUN_INTERVAL_MS)
                     {
-                        List<byte[]> silenceFrames = mSilenceGenerator.generate(PROCESSOR_RUN_INTERVAL_MS);
-                        for(byte[] silence: silenceFrames)
+                        AudioFrames silenceFrames = mSilenceGenerator.generate(PROCESSOR_RUN_INTERVAL_MS - mTimeOverrun - timeSent);
+                        while(silenceFrames.hasNextFrame())
                         {
-                            broadcastAudio(silence, null);
+                            silenceFrames.nextFrame();
+                            broadcastAudio(silenceFrames.getCurrentFrame(), null);
+                            timeSent += silenceFrames.getCurrentFrameDuration();
                         }
                     }
+
+                    mTimeOverrun += timeSent - PROCESSOR_RUN_INTERVAL_MS;
                 }
                 catch(Throwable t)
                 {
@@ -341,7 +327,7 @@ public abstract class AudioStreamingBroadcaster<T extends BroadcastConfiguration
         {
             boolean metadataUpdateRequired = false;
 
-            if(mInputStream != null)
+            if(mInputFrames != null)
             {
                 mStreamedAudioCount++;
                 broadcast(new BroadcastEvent(AudioStreamingBroadcaster.this,
@@ -349,7 +335,7 @@ public abstract class AudioStreamingBroadcaster<T extends BroadcastConfiguration
                 metadataUpdateRequired = true;
             }
 
-            mInputStream = null;
+            mInputFrames = null;
             mInputIdentifierCollection = null;
 
             //Peek at the next recording but don't remove it from the queue yet, so we can inspect the start time for
@@ -380,20 +366,15 @@ public abstract class AudioStreamingBroadcaster<T extends BroadcastConfiguration
 
                         if(audio.length > 0)
                         {
-                            //Calculate how many bytes we'll send with each processor run interval
-                            double intervals = (double)nextRecording.getRecordingLength() / (double)PROCESSOR_RUN_INTERVAL_MS;
-                            mBytesToStreamPerInterval = (int)((double)audio.length / intervals);
-
-                            mInputStream = new ByteArrayInputStream(audio);
-                            mInputIdentifierCollection = nextRecording.getIdentifierCollection();
-
-                            mFinalSilencePadding = PROCESSOR_RUN_INTERVAL_MS -
-                                (nextRecording.getRecordingLength() % PROCESSOR_RUN_INTERVAL_MS);
-
-                            while(mFinalSilencePadding >= PROCESSOR_RUN_INTERVAL_MS)
+                            switch(mBroadcastFormat)
                             {
-                                mFinalSilencePadding -= PROCESSOR_RUN_INTERVAL_MS;
+                                case MP3:
+                                    mInputFrames = MP3FrameTools.split(audio);
+                                    break;
+                                default:
+                                    throw new IllegalArgumentException("Unsupported broadcast format [" + mBroadcastFormat + "]");
                             }
+                            mInputIdentifierCollection = nextRecording.getIdentifierCollection();
 
                             if(connected())
                             {
@@ -409,7 +390,7 @@ public abstract class AudioStreamingBroadcaster<T extends BroadcastConfiguration
                     mLog.error("Stream [" + getBroadcastConfiguration().getName() + "] error reading temporary audio " +
                         "stream recording [" + nextRecording.getPath().toString() + "] - skipping recording - ", ioe);
 
-                    mInputStream = null;
+                    mInputFrames = null;
                     mInputIdentifierCollection = null;
                     metadataUpdateRequired = false;
                 }

src/main/java/io/github/dsheirer/audio/broadcast/BroadcastModel.java

@@ -26,13 +26,6 @@ import io.github.dsheirer.properties.SystemProperties;
 import io.github.dsheirer.sample.Broadcaster;
 import io.github.dsheirer.sample.Listener;
 import io.github.dsheirer.util.ThreadPool;
-import javafx.collections.FXCollections;
-import javafx.collections.ObservableList;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import javax.swing.*;
-import javax.swing.table.AbstractTableModel;
 import java.io.IOException;
 import java.nio.file.DirectoryStream;
 import java.nio.file.Files;
@@ -48,6 +41,12 @@ import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.swing.table.AbstractTableModel;
 
 public class BroadcastModel extends AbstractTableModel implements Listener<AudioRecording>
 {
@@ -58,7 +57,7 @@ public class BroadcastModel extends AbstractTableModel implements Listener<Audio
 
     private static final String UNIQUE_NAME_REGEX = "(.*)\\((\\d*)\\)";
 
-    public static final int COLUMN_SERVER_ICON = 0;
+    public static final int COLUMN_BROADCAST_SERVER_TYPE = 0;
     public static final int COLUMN_STREAM_NAME = 1;
     public static final int COLUMN_BROADCASTER_STATUS = 2;
     public static final int COLUMN_BROADCASTER_QUEUE_SIZE = 3;
@@ -67,7 +66,7 @@ public class BroadcastModel extends AbstractTableModel implements Listener<Audio
     public static final int COLUMN_BROADCASTER_ERROR_COUNT = 6;
 
     public static final String[] COLUMN_NAMES = new String[]
-        {"Streaming", "Name", "Status", "Queued", "Streamed/Uploaded", "Aged Off", "Upload Error"};
+        {"Stream Type", "Name", "Status", "Queued", "Streamed/Uploaded", "Aged Off", "Upload Error"};
 
     private ObservableList<ConfiguredBroadcast> mConfiguredBroadcasts =
         FXCollections.observableArrayList(ConfiguredBroadcast.extractor());
@@ -575,15 +574,8 @@ public class BroadcastModel extends AbstractTableModel implements Listener<Audio
                 {
                     switch(columnIndex)
                     {
-                        case COLUMN_SERVER_ICON:
-                            String iconPath = configuredBroadcast.getBroadcastConfiguration()
-                                .getBroadcastServerType().getIconPath();
-
-                            if(iconPath != null && mIconModel != null)
-                            {
-                                return mIconModel.getScaledIcon(iconPath, 14);
-                            }
-                            break;
+                        case COLUMN_BROADCAST_SERVER_TYPE:
+                            return configuredBroadcast.getBroadcastServerType();
                         case COLUMN_STREAM_NAME:
                             return configuredBroadcast.getBroadcastConfiguration().getName();
                         case COLUMN_BROADCASTER_STATUS:
@@ -653,8 +645,8 @@ public class BroadcastModel extends AbstractTableModel implements Listener<Audio
             case COLUMN_BROADCASTER_STREAMED_COUNT:
             case COLUMN_BROADCASTER_ERROR_COUNT:
                 return Integer.class;
-            case COLUMN_SERVER_ICON:
-                return ImageIcon.class;
+            case COLUMN_BROADCAST_SERVER_TYPE:
+                return BroadcastServerType.class;
             case COLUMN_STREAM_NAME:
             default:
                 return String.class;

src/main/java/io/github/dsheirer/audio/broadcast/BroadcastServerType.java

@@ -1,6 +1,6 @@
-/*******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2016 Dennis Sheirer
+/*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -14,8 +14,8 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>
- *
- ******************************************************************************/
+ * ****************************************************************************
+ */
 package io.github.dsheirer.audio.broadcast;
 
 public enum BroadcastServerType
@@ -23,17 +23,17 @@ public enum BroadcastServerType
     /**
      * Broadcastify feeds (ie streaming) service
      */
-    BROADCASTIFY("Broadcastify Feed", "/images/broadcastify.png"), //Icecast Server 2.3.2
+    BROADCASTIFY("Broadcastify Feed", "images/broadcastify.png"), //Icecast Server 2.3.2
 
     /**
      * Broadcastify calls - completed audio recording push service
      */
-    BROADCASTIFY_CALL("Broadcastify Call", "/images/broadcastify.png"),
+    BROADCASTIFY_CALL("Broadcastify Call", "images/broadcastify.png"),
 
-    ICECAST_HTTP("Icecast 2 (v2.4+)", "/images/icecast.png"),
-    ICECAST_TCP("Icecast (v2.3)", "/images/icecast.png"),
-    SHOUTCAST_V1("Shoutcast v1.x", "/images/shoutcast.png"),
-    SHOUTCAST_V2("Shoutcast v2.x", "/images/shoutcast.png"),
+    ICECAST_HTTP("Icecast 2 (v2.4+)", "images/icecast.png"),
+    ICECAST_TCP("Icecast (v2.3)", "images/icecast.png"),
+    SHOUTCAST_V1("Shoutcast v1.x", "images/shoutcast.png"),
+    SHOUTCAST_V2("Shoutcast v2.x", "images/shoutcast.png"),
     UNKNOWN("Unknown", null);
 
     private String mLabel;

src/main/java/io/github/dsheirer/audio/broadcast/BroadcastState.java

@@ -1,6 +1,6 @@
-/*******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2016 Dennis Sheirer
+/*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -14,8 +14,8 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>
- *
- ******************************************************************************/
+ * ****************************************************************************
+ */
 package io.github.dsheirer.audio.broadcast;
 
 public enum BroadcastState
@@ -103,10 +103,10 @@ public enum BroadcastState
     private String mLabel;
     private boolean mErrorState;
 
-    private BroadcastState(String label, boolean connected)
+    BroadcastState(String label, boolean errorState)
     {
         mLabel = label;
-        mErrorState = connected;
+        mErrorState = errorState;
     }
 
     public String toString()

src/main/java/io/github/dsheirer/audio/broadcast/BroadcastStatusPanel.java

@@ -1,7 +1,6 @@
 /*
- * ******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2019 Dennis Sheirer
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,23 +14,29 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>
- * *****************************************************************************
+ * ****************************************************************************
  */
 package io.github.dsheirer.audio.broadcast;
 
+import io.github.dsheirer.icon.Icon;
+import io.github.dsheirer.icon.IconModel;
 import io.github.dsheirer.preference.UserPreferences;
 import io.github.dsheirer.preference.swing.JTableColumnWidthMonitor;
+import java.awt.Color;
+import java.awt.Component;
 import net.miginfocom.swing.MigLayout;
 
+import javax.swing.ImageIcon;
 import javax.swing.JLabel;
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
 import javax.swing.JTable;
 import javax.swing.SwingConstants;
 import javax.swing.table.DefaultTableCellRenderer;
-import java.awt.Color;
-import java.awt.Component;
 
+/**
+ * Table of broadcast streams and statuses.
+ */
 public class BroadcastStatusPanel extends JPanel
 {
     private JTable mTable;
@@ -41,6 +46,12 @@ public class BroadcastStatusPanel extends JPanel
     private UserPreferences mUserPreferences;
     private String mPreferenceKey;
 
+    /**
+     * Constructs an instance
+     * @param broadcastModel to access the streams
+     * @param userPreferences for configuring the panel
+     * @param preferenceKey to store column preferences for this panel.
+     */
     public BroadcastStatusPanel(BroadcastModel broadcastModel, UserPreferences userPreferences, String preferenceKey)
     {
         mBroadcastModel = broadcastModel;
@@ -65,6 +76,7 @@ public class BroadcastStatusPanel extends JPanel
         renderer.setHorizontalAlignment(SwingConstants.CENTER);
 
         mTable.getColumnModel().getColumn(BroadcastModel.COLUMN_BROADCASTER_STATUS).setCellRenderer(new StatusCellRenderer());
+        mTable.getColumnModel().getColumn(BroadcastModel.COLUMN_BROADCAST_SERVER_TYPE).setCellRenderer(new ServerTypeRenderer());
         mColumnWidthMonitor = new JTableColumnWidthMonitor(mUserPreferences, mTable, mPreferenceKey);
 
         mScrollPane = new JScrollPane(mTable);
@@ -72,6 +84,37 @@ public class BroadcastStatusPanel extends JPanel
         add(mScrollPane);
     }
 
+    public class ServerTypeRenderer extends DefaultTableCellRenderer
+    {
+        public ServerTypeRenderer()
+        {
+            setOpaque(true);
+            setHorizontalAlignment(SwingConstants.CENTER);
+        }
+
+        @Override
+        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column)
+        {
+            JLabel component = (JLabel)super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
+
+            if(value instanceof BroadcastServerType broadcastServerType)
+            {
+                component.setText(broadcastServerType.toString());
+                Icon icon = new Icon("empty", broadcastServerType.getIconPath());
+                ImageIcon imageIcon = icon.getIcon();
+                ImageIcon scaledIcon = IconModel.getScaledIcon(imageIcon, 13);
+                component.setIcon(scaledIcon);
+            }
+            else
+            {
+                component.setText(null);
+                component.setIcon(null);
+            }
+
+            return component;
+        }
+    }
+
     /**
      * Custom cell renderer for the broadcast state column.
      */

src/main/java/io/github/dsheirer/audio/broadcast/icecast/IcecastHTTPAudioBroadcaster.java

@@ -20,13 +20,20 @@ package io.github.dsheirer.audio.broadcast.icecast;
 
 import io.github.dsheirer.alias.AliasModel;
 import io.github.dsheirer.audio.broadcast.BroadcastState;
-import io.github.dsheirer.audio.broadcast.icecast.IcecastMetadata;
 import io.github.dsheirer.audio.convert.InputAudioFormat;
 import io.github.dsheirer.audio.convert.MP3AudioConverter;
 import io.github.dsheirer.audio.convert.MP3Setting;
 import io.github.dsheirer.identifier.IdentifierCollection;
 import io.github.dsheirer.properties.SystemProperties;
 import io.github.dsheirer.util.ThreadPool;
+import java.net.ConnectException;
+import java.net.InetSocketAddress;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 import org.apache.mina.core.RuntimeIoException;
 import org.apache.mina.core.buffer.IoBuffer;
 import org.apache.mina.core.future.ConnectFuture;
@@ -42,13 +49,6 @@ import org.apache.mina.transport.socket.nio.NioSocketConnector;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.net.ConnectException;
-import java.net.InetSocketAddress;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.concurrent.atomic.AtomicBoolean;
-
 public class IcecastHTTPAudioBroadcaster extends IcecastAudioBroadcaster
 {
     private static final Logger mLog = LoggerFactory.getLogger(IcecastHTTPAudioBroadcaster.class);
@@ -143,8 +143,9 @@ public class IcecastHTTPAudioBroadcaster extends IcecastAudioBroadcaster
                 mSocketConnector = new NioSocketConnector();
                 mSocketConnector.setConnectTimeoutCheckInterval(10000);
 
-//                mSocketConnector.getFilterChain().addLast("logger",
-//                    new LoggingFilter(IcecastHTTPAudioBroadcaster.class));
+//                LoggingFilter loggingFilter = new LoggingFilter(IcecastHTTPAudioBroadcaster.class);
+//                loggingFilter.setMessageReceivedLogLevel(LogLevel.DEBUG);
+//                mSocketConnector.getFilterChain().addLast("logger", loggingFilter);
 
                 mSocketConnector.getFilterChain().addLast("codec", new HttpClientCodec());
                 mSocketConnector.setHandler(new IcecastHTTPIOHandler());
@@ -315,10 +316,49 @@ public class IcecastHTTPAudioBroadcaster extends IcecastAudioBroadcaster
                  * intercept the out of bounds exception and then inspect the message hex dump to see if it's an
                  * OK response and then play like everything is well and good.
                  */
-                if(cause instanceof ArrayIndexOutOfBoundsException &&
-                    ((ProtocolDecoderException)throwable).getHexdump().startsWith(HTTP_1_0_OK_HEX_DUMP))
+                if(cause instanceof ArrayIndexOutOfBoundsException)
                 {
-                    setBroadcastState(BroadcastState.CONNECTED);
+                    String hexDump = ((ProtocolDecoderException)throwable).getHexdump();
+
+                    if(hexDump.startsWith(HTTP_1_0_OK_HEX_DUMP))
+                    {
+                        setBroadcastState(BroadcastState.CONNECTED);
+                    }
+                    else
+                    {
+                        HttpDumpMessage message = new HttpDumpMessage(hexDump);
+
+                        if(message.hasHttpResponseCode())
+                        {
+                            switch(message.getHttpResponseCode())
+                            {
+                                case 403: //Forbidden
+                                    if(message.toString().contains("Mountpoint in use"))
+                                    {
+                                        mLog.error("Stream [" + getStreamName() + "] - unable to connect - mountpoint in use");
+                                        setBroadcastState(BroadcastState.MOUNT_POINT_IN_USE);
+                                        disconnect();
+                                    }
+                                    else
+                                    {
+                                        mLog.error("String [" + getStreamName() + "] - HTTP protocol decoder error - message:\n\n" + message);
+                                        setBroadcastState(BroadcastState.DISCONNECTED);
+                                        disconnect();
+                                    }
+                                    break;
+                                default:
+                                    mLog.error("String [" + getStreamName() + "] - HTTP protocol decoder error - message:\n\n" + message);
+                                    setBroadcastState(BroadcastState.DISCONNECTED);
+                                    disconnect();
+                            }
+                        }
+                        else
+                        {
+                            mLog.error("HTTP protocol decoder error - message:\n\n" + message);
+                            setBroadcastState(BroadcastState.DISCONNECTED);
+                            disconnect();
+                        }
+                    }
                 }
                 else
                 {
@@ -374,4 +414,97 @@ public class IcecastHTTPAudioBroadcaster extends IcecastAudioBroadcaster
             }
         }
     }
+
+    /**
+     * Class for parsing HTTP response messages from Icecast 2.4.2+
+     */
+    public class HttpDumpMessage
+    {
+        private String mHexDump;
+        private String mMessage;
+        private int mHttpResponseCode = -1;
+
+        public HttpDumpMessage(String hexDump)
+        {
+            mHexDump = hexDump;
+
+            String[] split = mHexDump.split(" ");
+            byte[] bytes = new byte[split.length];
+
+            int pointer = 0;
+            for(String a : split)
+            {
+                try
+                {
+                    int value = Integer.parseInt(a, 16);
+                    bytes[pointer++] = (byte) (value & 0xFF);
+                }
+                catch(Exception e)
+                {
+                    pointer++;
+                }
+            }
+
+            mMessage = new String(bytes);
+
+            Pattern pattern = Pattern.compile("HTTP/1.0 (\\d{3})");
+            Matcher m = pattern.matcher(mMessage);
+
+            if(m.find())
+            {
+                try
+                {
+                    mHttpResponseCode = Integer.parseInt(m.group(1));
+                }
+                catch(Exception e)
+                {
+                    mLog.error("Unable to parse HTTP response code that was matched from message: " + m.group(1));
+                }
+            }
+        }
+
+        /**
+         * Indicates if an HTTP response code was parsed from the message
+         * @return true if it was parsed.
+         */
+        public boolean hasHttpResponseCode()
+        {
+            return mHttpResponseCode != -1;
+        }
+
+        /**
+         * Response code parsed from the hexdump message
+         * @return value.
+         */
+        public int getHttpResponseCode()
+        {
+            return mHttpResponseCode;
+        }
+
+        @Override
+        public String toString()
+        {
+            return mMessage;
+        }
+    }
+
+    public static void main(String[] args)
+    {
+        String text = "HTTP/1.0 403 Forbidden";
+
+        Pattern pattern = Pattern.compile("HTTP/1.0 (\\d{3})");
+
+        Matcher m = pattern.matcher(text);
+
+        if(m.find())
+        {
+            mLog.info("Matching Group Count: " + m.groupCount());
+            mLog.info("Match 0: " + m.group(0));
+            mLog.info("Match 1: " + m.group(1));
+        }
+        else
+        {
+            mLog.info("No Match");
+        }
+    }
 }

src/main/java/io/github/dsheirer/audio/broadcast/icecast/IcecastTCPAudioBroadcaster.java

@@ -21,13 +21,19 @@ package io.github.dsheirer.audio.broadcast.icecast;
 import io.github.dsheirer.alias.AliasModel;
 import io.github.dsheirer.audio.broadcast.BroadcastState;
 import io.github.dsheirer.audio.broadcast.icecast.codec.IcecastCodecFactory;
-import io.github.dsheirer.audio.broadcast.icecast.IcecastMetadata;
 import io.github.dsheirer.audio.convert.InputAudioFormat;
 import io.github.dsheirer.audio.convert.MP3AudioConverter;
 import io.github.dsheirer.audio.convert.MP3Setting;
 import io.github.dsheirer.identifier.IdentifierCollection;
 import io.github.dsheirer.properties.SystemProperties;
 import io.github.dsheirer.util.ThreadPool;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.SocketException;
+import java.nio.channels.UnresolvedAddressException;
+import java.util.Arrays;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import org.apache.mina.core.RuntimeIoException;
 import org.apache.mina.core.future.ConnectFuture;
 import org.apache.mina.core.service.IoHandlerAdapter;
@@ -37,14 +43,6 @@ import org.apache.mina.transport.socket.nio.NioSocketConnector;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.io.IOException;
-import java.net.InetSocketAddress;
-import java.net.SocketException;
-import java.nio.channels.UnresolvedAddressException;
-import java.util.Arrays;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-
 public class IcecastTCPAudioBroadcaster extends IcecastAudioBroadcaster
 {
     private final static Logger mLog = LoggerFactory.getLogger(IcecastTCPAudioBroadcaster.class);
@@ -215,7 +213,13 @@ public class IcecastTCPAudioBroadcaster extends IcecastAudioBroadcaster
         }
         else
         {
-            setBroadcastState(BroadcastState.DISCONNECTED);
+            //Only set broadcast state to disconnected if it's not already in an error state, to prevent a restart.  We
+            //want to preserve the error state that got us here, so the user can see it.
+            if(!getBroadcastState().isErrorState())
+            {
+                setBroadcastState(BroadcastState.DISCONNECTED);
+            }
+
             mLastConnectionAttempt = System.currentTimeMillis();
         }
     }

src/main/java/io/github/dsheirer/audio/codec/mbe/JmbeAudioModule.java

@@ -1,23 +1,20 @@
 /*
+ * *****************************************************************************
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
- *  * ******************************************************************************
- *  * Copyright (C) 2014-2019 Dennis Sheirer
- *  *
- *  * This program is free software: you can redistribute it and/or modify
- *  * it under the terms of the GNU General Public License as published by
- *  * the Free Software Foundation, either version 3 of the License, or
- *  * (at your option) any later version.
- *  *
- *  * This program is distributed in the hope that it will be useful,
- *  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  * GNU General Public License for more details.
- *  *
- *  * You should have received a copy of the GNU General Public License
- *  * along with this program.  If not, see <http://www.gnu.org/licenses/>
- *  * *****************************************************************************
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * ****************************************************************************
  */
 
 package io.github.dsheirer.audio.codec.mbe;
@@ -32,11 +29,6 @@ import io.github.dsheirer.message.IMessageListener;
 import io.github.dsheirer.preference.PreferenceType;
 import io.github.dsheirer.preference.UserPreferences;
 import io.github.dsheirer.sample.Listener;
-import jmbe.iface.IAudioCodec;
-import jmbe.iface.IAudioCodecLibrary;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import java.lang.reflect.InvocationTargetException;
 import java.net.MalformedURLException;
 import java.net.URL;
@@ -44,15 +36,20 @@ import java.net.URLClassLoader;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
+import jmbe.iface.IAudioCodec;
+import jmbe.iface.IAudioCodecLibrary;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public abstract class JmbeAudioModule extends AbstractAudioModule implements Listener<IMessage>, IMessageListener,
     ISquelchStateListener
 {
     private static final Logger mLog = LoggerFactory.getLogger(JmbeAudioModule.class);
     private static final String JMBE_AUDIO_LIBRARY = "JMBE";
-    private static List<String> mLibraryLoadStatusLogged = new ArrayList<>();
+    private static final List<String> mLibraryLoadStatusLogged = new ArrayList<>();
     private IAudioCodec mAudioCodec;
-    private UserPreferences mUserPreferences;
+    private final UserPreferences mUserPreferences;
+    private static Class sLoadedJmbeAudioConverterClass;
 
     public JmbeAudioModule(UserPreferences userPreferences, AliasList aliasList, int timeslot)
     {
@@ -70,7 +67,7 @@ public abstract class JmbeAudioModule extends AbstractAudioModule implements Lis
         mAudioCodec = null;
     }
 
-    protected IAudioCodec getAudioCodec()
+    public IAudioCodec getAudioCodec()
     {
         return mAudioCodec;
     }
@@ -110,38 +107,67 @@ public abstract class JmbeAudioModule extends AbstractAudioModule implements Lis
     protected abstract String getCodecName();
 
     /**
-     * Loads audio frame processing chain.  Constructs an imbe targetdataline
-     * to receive the raw imbe frames.  Adds an IMBE to 8k PCM format conversion
-     * stream wrapper.  Finally, adds an upsampling (8k to 48k) stream wrapper.
+     * Loads JMBE audio converter library class and then instantiates new converter instances from the loaded class.
      */
     protected void loadConverter()
     {
         IAudioCodec audioConverter = null;
 
-        Path path = mUserPreferences.getJmbeLibraryPreference().getPathJmbeLibrary();
-
-        if(path != null)
+        if(sLoadedJmbeAudioConverterClass == null)
         {
-            try
+            Path path = mUserPreferences.getJmbeLibraryPreference().getPathJmbeLibrary();
+
+            if(path != null)
             {
                 if(!mLibraryLoadStatusLogged.contains(JMBE_AUDIO_LIBRARY))
                 {
-                    mLog.info("Loading JMBE library from [" + path.toString() + "]");
+                    mLog.info("Loading JMBE library from [" + path + "]");
                 }
 
-                URLClassLoader childClassLoader = new URLClassLoader(new URL[]{path.toUri().toURL()},
-                    this.getClass().getClassLoader());
-
-                Class classToLoad = Class.forName("jmbe.JMBEAudioLibrary", true, childClassLoader);
-
-                Object instance = classToLoad.getDeclaredConstructor().newInstance();
-
-                if(instance instanceof IAudioCodecLibrary)
+                try
                 {
-                    IAudioCodecLibrary library = (IAudioCodecLibrary)instance;
+                    URLClassLoader childClassLoader = new URLClassLoader(new URL[]{path.toUri().toURL()},
+                            this.getClass().getClassLoader());
 
+                    sLoadedJmbeAudioConverterClass = Class.forName("jmbe.JMBEAudioLibrary", true, childClassLoader);
+                }
+                catch(IllegalArgumentException iae)
+                {
+                    if(!mLibraryLoadStatusLogged.contains(JMBE_AUDIO_LIBRARY + getCodecName()))
+                    {
+                        mLog.error("Couldn't load JMBE audio conversion library - " + iae.getMessage());
+                        mLibraryLoadStatusLogged.add(JMBE_AUDIO_LIBRARY + getCodecName());
+                    }
+                }
+                catch(MalformedURLException mue)
+                {
+                    if(!mLibraryLoadStatusLogged.contains(JMBE_AUDIO_LIBRARY))
+                    {
+                        mLog.error("Couldn't load JMBE audio conversion library from path [" + path + "]");
+                        mLibraryLoadStatusLogged.add(JMBE_AUDIO_LIBRARY);
+                    }
+                }
+                catch(ClassNotFoundException e1)
+                {
+                    if(!mLibraryLoadStatusLogged.contains(JMBE_AUDIO_LIBRARY))
+                    {
+                        mLog.error("Couldn't load JMBE audio conversion library - class not found");
+                        mLibraryLoadStatusLogged.add(JMBE_AUDIO_LIBRARY);
+                    }
+                }
+            }
+        }
+
+        if(sLoadedJmbeAudioConverterClass != null)
+        {
+            try
+            {
+                Object instance = sLoadedJmbeAudioConverterClass.getDeclaredConstructor().newInstance();
+
+                if(instance instanceof IAudioCodecLibrary library)
+                {
                     if((library.getMajorVersion() == 1 && library.getMinorVersion() >= 0 &&
-                        library.getBuildVersion() >= 0) || library.getMajorVersion() >= 1)
+                            library.getBuildVersion() >= 0) || library.getMajorVersion() >= 1)
                     {
                         audioConverter = library.getAudioConverter(getCodecName());
 
@@ -169,38 +195,6 @@ public abstract class JmbeAudioModule extends AbstractAudioModule implements Lis
                     }
                 }
             }
-            catch(IllegalArgumentException iae)
-            {
-                if(!mLibraryLoadStatusLogged.contains(JMBE_AUDIO_LIBRARY + getCodecName()))
-                {
-                    mLog.error("Couldn't load JMBE audio conversion library - " + iae.getMessage());
-                    mLibraryLoadStatusLogged.add(JMBE_AUDIO_LIBRARY + getCodecName());
-                }
-            }
-            catch(NoSuchMethodException nsme)
-            {
-                if(!mLibraryLoadStatusLogged.contains(JMBE_AUDIO_LIBRARY))
-                {
-                    mLog.error("Couldn't load JMBE audio conversion library - no such method exception");
-                    mLibraryLoadStatusLogged.add(JMBE_AUDIO_LIBRARY);
-                }
-            }
-            catch(MalformedURLException mue)
-            {
-                if(!mLibraryLoadStatusLogged.contains(JMBE_AUDIO_LIBRARY))
-                {
-                    mLog.error("Couldn't load JMBE audio conversion library from path [" + path + "]");
-                    mLibraryLoadStatusLogged.add(JMBE_AUDIO_LIBRARY);
-                }
-            }
-            catch(ClassNotFoundException e1)
-            {
-                if(!mLibraryLoadStatusLogged.contains(JMBE_AUDIO_LIBRARY))
-                {
-                    mLog.error("Couldn't load JMBE audio conversion library - class not found");
-                    mLibraryLoadStatusLogged.add(JMBE_AUDIO_LIBRARY);
-                }
-            }
             catch(InvocationTargetException ite)
             {
                 if(!mLibraryLoadStatusLogged.contains(JMBE_AUDIO_LIBRARY))
@@ -225,6 +219,14 @@ public abstract class JmbeAudioModule extends AbstractAudioModule implements Lis
                     mLibraryLoadStatusLogged.add(JMBE_AUDIO_LIBRARY);
                 }
             }
+            catch(NoSuchMethodException nsme)
+            {
+                if(!mLibraryLoadStatusLogged.contains(JMBE_AUDIO_LIBRARY))
+                {
+                    mLog.error("Couldn't load JMBE audio conversion library - no such method exception");
+                    mLibraryLoadStatusLogged.add(JMBE_AUDIO_LIBRARY);
+                }
+            }
         }
         else
         {
@@ -235,13 +237,6 @@ public abstract class JmbeAudioModule extends AbstractAudioModule implements Lis
             }
         }
 
-        if(audioConverter != null)
-        {
-            mAudioCodec = audioConverter;
-        }
-        else
-        {
-            mAudioCodec = null;
-        }
+        mAudioCodec = audioConverter;
     }
 }

src/main/java/io/github/dsheirer/audio/codec/mbe/MBECallSequenceConverter.java

@@ -1,27 +1,46 @@
 /*
+ * *****************************************************************************
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
- *  * ******************************************************************************
- *  * Copyright (C) 2014-2019 Dennis Sheirer
- *  *
- *  * This program is free software: you can redistribute it and/or modify
- *  * it under the terms of the GNU General Public License as published by
- *  * the Free Software Foundation, either version 3 of the License, or
- *  * (at your option) any later version.
- *  *
- *  * This program is distributed in the hope that it will be useful,
- *  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  * GNU General Public License for more details.
- *  *
- *  * You should have received a copy of the GNU General Public License
- *  * along with this program.  If not, see <http://www.gnu.org/licenses/>
- *  * *****************************************************************************
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * ****************************************************************************
  */
 
 package io.github.dsheirer.audio.codec.mbe;
 
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.github.dsheirer.alias.AliasList;
+import io.github.dsheirer.audio.AudioSegment;
+import io.github.dsheirer.identifier.IdentifierUpdateNotification;
+import io.github.dsheirer.module.decode.p25.audio.P25P1AudioModule;
+import io.github.dsheirer.module.decode.p25.audio.P25P1CallSequenceRecorder;
+import io.github.dsheirer.module.decode.p25.audio.VoiceFrame;
+import io.github.dsheirer.module.decode.p25.identifier.radio.APCO25RadioIdentifier;
+import io.github.dsheirer.module.decode.p25.identifier.talkgroup.APCO25Talkgroup;
+import io.github.dsheirer.preference.UserPreferences;
+import io.github.dsheirer.record.AudioSegmentRecorder;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collection;
+import jmbe.iface.IAudioCodec;
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.filefilter.DirectoryFileFilter;
+import org.apache.commons.io.filefilter.SuffixFileFilter;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -32,79 +51,130 @@ public class MBECallSequenceConverter
 {
     private final static Logger mLog = LoggerFactory.getLogger(MBECallSequenceConverter.class);
 
-//    public static void convert(Path input, Path output) throws IOException
-//    {
-//        InputStream inputStream = Files.newInputStream(input);
-//        ObjectMapper mapper = new ObjectMapper();
-//        MBECallSequence sequence = mapper.readValue(inputStream, MBECallSequence.class);
-//        convert(sequence, output);
-//    }
-//
-//    public static void convert(MBECallSequence callSequence, Path outputPath)
-//    {
-//        if(callSequence == null || callSequence.isEncrypted())
-//        {
-//            throw new IllegalArgumentException("Cannot decode null or encrypted call sequence");
-//        }
-//
-//        if(callSequence != null && !callSequence.isEncrypted())
-//        {
-//            ThumbDv.AudioProtocol protocol = ThumbDv.AudioProtocol.P25_PHASE2;
-//
-//            AudioPacketWaveRecorder recorder = new AudioPacketWaveRecorder(outputPath);
-//            recorder.start();
-//
-//            long delayMillis = 0;
-//
-//            try(ThumbDv thumbDv = new ThumbDv(protocol, recorder))
-//            {
-//                thumbDv.start();
-//                for(VoiceFrame voiceFrame: callSequence.getVoiceFrames())
-//                {
-//                    mLog.debug("Frame [" + voiceFrame.getFrame() + "] + Hex [" + AmbeResponse.toHex(voiceFrame.getFrameBytes()) + "]");
-//                    thumbDv.decode(voiceFrame.getFrameBytes());
-//                    delayMillis += 30;
-//                }
-//
-//                if(delayMillis > 0)
-//                {
-//                    delayMillis += 1000;
-//                    try
-//                    {
-//                        Thread.sleep(delayMillis);
-//                    }
-//                    catch(InterruptedException ie)
-//                    {
-//
-//                    }
-//                }
-//            }
-//            catch(IOException ioe)
-//            {
-//                mLog.error("Error", ioe);
-//            }
-//
-//            recorder.stop(Paths.get(outputPath.toString().replace(".tmp", ".wav")), new WaveMetadata());
-//        }
-//    }
-//
-//    public static void main(String[] args)
-//    {
-//        String mbe = "/home/denny/SDRTrunk/recordings/20190331085324_154250000_3_TS0_65084_6591007.mbe";
-//        String mbe = "/home/denny/SDRTrunk/recordings/20190331085324_154250000_2_TS1_65035.mbe";
-//
-//        Path input = Paths.get(mbe);
-//        Path output = Paths.get(mbe.replace(".mbe", ".tmp"));
-//
-//        mLog.info("Converting: " + mbe);
-//
-//        try
-//        {
-//            MBECallSequenceConverter.convert(input, output);
-//        }
-//        catch(IOException ioe)
-//        {
-//            mLog.error("Error", ioe);
-//        }
-//    }
+    /**
+     * Converts the input MBE file to PCM audio and writes to the output wave file.
+     * @param input path to the MBE file.
+     * @param output path to write the WAVE recording.
+     * @throws IOException if there is an error.
+     */
+    public static void convert(Path input, Path output) throws IOException
+    {
+        InputStream inputStream = Files.newInputStream(input);
+        ObjectMapper mapper = new ObjectMapper();
+        MBECallSequence sequence = mapper.readValue(inputStream, MBECallSequence.class);
+        convert(sequence, output);
+    }
+
+    public static void convert(MBECallSequence callSequence, Path outputPath)
+    {
+        if(callSequence == null || callSequence.isEncrypted())
+        {
+            throw new IllegalArgumentException("Cannot decode null or encrypted call sequence");
+        }
+
+        if(callSequence != null)
+        {
+            if(callSequence.getProtocol().equals(P25P1CallSequenceRecorder.PROTOCOL))
+            {
+                P25P1AudioModule audioModule = new P25P1AudioModule(new UserPreferences(), new AliasList("mbe generator"));
+                audioModule.setRecordAudio(true);
+                audioModule.start();
+
+                if(callSequence.getFromIdentifier() != null)
+                {
+                    int from = 0;
+
+                    try
+                    {
+                        from = Integer.parseInt(callSequence.getFromIdentifier());
+                        audioModule.getIdentifierUpdateListener().receive(new IdentifierUpdateNotification(APCO25RadioIdentifier.createFrom(from),
+                                IdentifierUpdateNotification.Operation.ADD, 0));
+                    }
+                    catch(Exception e)
+                    {
+                        mLog.error("Error parsing from identifier from value [" + callSequence.getFromIdentifier());
+                    }
+                }
+
+                if(callSequence.getToIdentifier() != null)
+                {
+                    int to = 0;
+
+                    try
+                    {
+                        to = Integer.parseInt(callSequence.getToIdentifier());
+                        audioModule.getIdentifierUpdateListener().receive(new IdentifierUpdateNotification(APCO25Talkgroup.create(to),
+                                IdentifierUpdateNotification.Operation.ADD, 0));
+                    }
+                    catch(Exception e)
+                    {
+                        mLog.error("Error parsing from identifier from value [" + callSequence.getFromIdentifier());
+                    }
+                }
+
+                IAudioCodec codec = audioModule.getAudioCodec();
+
+                for(VoiceFrame voiceFrame: callSequence.getVoiceFrames())
+                {
+                    byte[] frameBytes = voiceFrame.getFrameBytes();
+                    float[] audio = codec.getAudio(frameBytes);
+                    audioModule.addAudio(audio);
+                }
+
+                AudioSegment audioSegment = audioModule.getAudioSegment();
+
+                try
+                {
+                    AudioSegmentRecorder.recordWAVE(audioSegment, outputPath);
+                }
+                catch(IOException ioe)
+                {
+                    mLog.error("Error writing audio segment, ioe");
+                }
+
+                audioModule.stop();
+            }
+        }
+    }
+
+    public static void main(String[] args)
+    {
+        boolean all = true;
+
+        String path = "/home/denny/SDRTrunk/recordings";
+        Path input = Paths.get(path);
+
+        if(all)
+        {
+            Collection<File> mbeFiles = FileUtils.listFiles(input.toFile(), new SuffixFileFilter(".mbe"), DirectoryFileFilter.DIRECTORY);
+
+            for(File inputFile: mbeFiles)
+            {
+                Path output = Paths.get(inputFile.getAbsolutePath().replace(".mbe", ".wav"));
+                mLog.info("Converting: " + inputFile);
+                try
+                {
+                    MBECallSequenceConverter.convert(inputFile.toPath(), output);
+                }
+                catch(IOException ioe)
+                {
+                    mLog.error("Error", ioe);
+                }
+            }
+        }
+        else
+        {
+            Path output = Paths.get(path.replace(".mbe", ".wav"));
+            mLog.info("Converting: " + path);
+
+            try
+            {
+                MBECallSequenceConverter.convert(input, output);
+            }
+            catch(IOException ioe)
+            {
+                mLog.error("Error", ioe);
+            }
+        }
+    }
 }

src/main/java/io/github/dsheirer/audio/convert/AudioFrames.java

@@ -0,0 +1,133 @@
+/*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 Dennis Sheirer
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * ****************************************************************************
+ */
+package io.github.dsheirer.audio.convert;
+
+import java.util.List;
+import org.apache.commons.math3.util.FastMath;
+
+public abstract class AudioFrames
+{
+    protected final int audioDuration;
+    protected final List<byte[]> audioFrames;
+    protected int mCurrentFrame = -1;
+
+    /**
+     * Create new AudioFrame
+     * @param audioDuration total duration in milliseconds
+     * @param audioFrames series of audio frames, split on frame boundaries
+     */
+    public AudioFrames(int audioDuration, List<byte[]> audioFrames)
+    {
+        this.audioDuration = audioDuration;
+        this.audioFrames = audioFrames;
+    }
+
+    /**
+     * Get total duration of frames
+     * @return total duration in milliseconds
+     */
+    public int getDuration()
+    {
+        return audioDuration;
+    }
+
+    /**
+     * Get all frames
+     * @return list of byte arrays, with each element representing a single frame of audio
+     */
+    public List<byte[]> getFrames()
+    {
+        return audioFrames;
+    }
+
+    /**
+     * Get current frame
+     * @return byte array with the current frame of audio
+     */
+    public byte[] getCurrentFrame()
+    {
+        return audioFrames.get(mCurrentFrame);
+    }
+
+    /**
+     * Get current frame duration
+     * @return frame duration in milliseconds
+     */
+    public abstract int getCurrentFrameDuration();
+
+    /**
+     * Indicates if there is a frame before the current one
+     * @return true if the frame exists, otherwise false
+     */
+    public boolean hasPrevFrame()
+    {
+        int prevFrame = mCurrentFrame - 1;
+        return prevFrame >= 0 && prevFrame < audioFrames.size();
+    }
+
+    /**
+     * Indicates if there is a frame after the current one
+     * @return true if the frame exists, otherwise false
+     */
+    public boolean hasNextFrame()
+    {
+        int nextFrame = mCurrentFrame + 1;
+        return nextFrame >= 0 && nextFrame < audioFrames.size();
+    }
+
+    /**
+     * Seek to the previous frame
+     */
+    public void prevFrame()
+    {
+        mCurrentFrame -= 1;
+    }
+
+    /**
+     * Seek to the next frame
+     */
+    public void nextFrame()
+    {
+        mCurrentFrame += 1;
+    }
+
+    /**
+     * Restart from beginning
+     * Must call nextFrame() to get first frame
+     */
+    public void restart()
+    {
+        mCurrentFrame = -1;
+    }
+
+    /**
+     * Seek by the specified time
+     * @param duration_ms time in milliseconds, positive or negative
+     */
+    public void seek(int duration_ms)
+    {
+        int step = duration_ms < 0 ? -1 : 1;
+        int actual_ms = 0;
+        while(FastMath.abs(actual_ms) < FastMath.abs(duration_ms))
+        {
+            mCurrentFrame += step;
+            actual_ms += getCurrentFrameDuration();
+        }
+    }
+}

src/main/java/io/github/dsheirer/audio/convert/ISilenceGenerator.java

@@ -22,5 +22,5 @@ import java.util.List;
 
 public interface ISilenceGenerator
 {
-    List<byte[]> generate(long duration);
+    AudioFrames generate(long duration);
 }

src/main/java/io/github/dsheirer/audio/convert/InputAudioFormat.java

@@ -20,6 +20,7 @@
 package io.github.dsheirer.audio.convert;
 
 import io.github.dsheirer.audio.AudioFormats;
+import java.util.EnumSet;
 
 import javax.sound.sampled.AudioFormat;
 
@@ -29,8 +30,8 @@ import javax.sound.sampled.AudioFormat;
 public enum InputAudioFormat
 {
     SR_8000(AudioFormats.PCM_SIGNED_8000_HZ_16_BIT_MONO, "16-Bit 8000 Hz (no resample)"),
-    SR_16000(AudioFormats.PCM_SIGNED_16000_HZ_16_BIT_MONO, "16-Bit 16000 Hz"),
-    SR_22050(AudioFormats.PCM_SIGNED_22050_HZ_16_BIT_MONO, "16-Bit 22050 Hz (default)"),
+    SR_16000(AudioFormats.PCM_SIGNED_16000_HZ_16_BIT_MONO, "16-Bit 16000 Hz (default)"),
+    SR_22050(AudioFormats.PCM_SIGNED_22050_HZ_16_BIT_MONO, "16-Bit 22050 Hz"),
     SR_44100(AudioFormats.PCM_SIGNED_44100_HZ_16_BIT_MONO, "16-Bit 44100 Hz"),
 
     SR_32_8000(AudioFormats.PCM_SIGNED_8000_HZ_32_BIT_MONO, "32-Bit 8000 Hz (no resample)"),
@@ -41,6 +42,17 @@ public enum InputAudioFormat
     private AudioFormat mAudioFormat;
     private String mLabel;
 
+    /**
+     * Set that includes sample rates of 8 or 16 kHz
+     */
+    public static final EnumSet<InputAudioFormat> SAMPLE_RATES_8_16 = EnumSet.of(SR_8000, SR_32_8000, SR_16000, SR_32_16000);
+
+    /**
+     * Set that includes sample rates of 8, 16, or 22 kHz
+     */
+    public static final EnumSet<InputAudioFormat> SAMPLE_RATES_8_16_22 = EnumSet.of(SR_8000, SR_32_8000, SR_16000,
+            SR_32_16000, SR_22050, SR_32_22050);
+
     /**
      * Constructs an instance
      * @param audioFormat for the specified sample rate
@@ -56,7 +68,7 @@ public enum InputAudioFormat
      */
     public static InputAudioFormat getDefault()
     {
-        return SR_22050;
+        return SR_16000;
     }
 
     /**

src/main/java/io/github/dsheirer/audio/convert/MP3AudioConverter.java

@@ -60,8 +60,17 @@ public class MP3AudioConverter implements IAudioConverter
         mEncoder = LameFactory.getLameEncoder(inputAudioFormat, setting);
         mNormalizeAudio = normalizeAudio;
 
+        //Ensure input audio sample rate is supported for the MP3 setting and update as necessary - should never happen.
+        if((mInputAudioFormat.getSampleRate() - mEncoder.getEffectiveSampleRate()) > 1.0)
+        {
+            mInputAudioFormat = InputAudioFormat.getDefault();
+            mLog.warn("MP3 setting [" + setting + "] does not support requested input audio sample rate [" +
+                    inputAudioFormat + "] - using default sample rate [" + mInputAudioFormat + "]");
+            mEncoder = LameFactory.getLameEncoder(inputAudioFormat, setting);
+        }
+
         //Resampling is only required if desired input sample rate is not system default of 8kHz
-        if(inputAudioFormat != InputAudioFormat.SR_8000 && inputAudioFormat != InputAudioFormat.SR_32_8000)
+        if(mInputAudioFormat != InputAudioFormat.SR_8000 && mInputAudioFormat != InputAudioFormat.SR_32_8000)
         {
             mResampler = LameFactory.getResampler(inputAudioFormat);
         }

src/main/java/io/github/dsheirer/audio/convert/MP3AudioFrames.java

@@ -0,0 +1,46 @@
+/*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 Dennis Sheirer
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * ****************************************************************************
+ */
+
+package io.github.dsheirer.audio.convert;
+
+import java.util.List;
+
+public class MP3AudioFrames extends AudioFrames
+{
+
+    /**
+     * Create new MP3AudioFrame
+     * @param audioDuration total duration in milliseconds
+     * @param audioFrames series of audio frames, split on frame boundaries
+     */
+    public MP3AudioFrames(int audioDuration, List<byte[]> audioFrames)
+    {
+        super(audioDuration, audioFrames);
+    }
+
+    /**
+     * Get current frame duration
+     * @return frame duration in milliseconds
+     */
+    public int getCurrentFrameDuration()
+    {
+        return MP3Header.getFrameDuration(getCurrentFrame(), 0);
+    }
+
+}

src/main/java/io/github/dsheirer/audio/convert/MP3FrameInspector.java

@@ -55,6 +55,7 @@ public class MP3FrameInspector
         }
     }
 
+    /* TODO: Rework for MP3SilenceGenerator returning IAudioFrames
     public static void main(String[] args)
     {
         mLog.info("Starting ...");
@@ -66,4 +67,5 @@ public class MP3FrameInspector
 
         mLog.info("Finished");
     }
+    */
 }

src/main/java/io/github/dsheirer/audio/convert/MP3FrameTools.java

@@ -0,0 +1,59 @@
+/*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 Dennis Sheirer
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * ****************************************************************************
+ */
+package io.github.dsheirer.audio.convert;
+
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.List;
+import org.apache.commons.math3.util.FastMath;
+
+public class MP3FrameTools {
+
+    private MP3FrameTools() {}
+
+    /**
+     * Split MP3 audio at frame boundaries
+     * @param input byte array of audio
+     * @return list of byte arrays containing audio frames
+     */
+    public static MP3AudioFrames split(byte[] input)
+    {
+        List<byte[]> mp3Frames = new ArrayList<>();
+        int audioDuration = 0;
+
+        int offset = 0;
+        while(offset < input.length)
+        {
+            if(MP3Header.hasSync(input, offset))
+            {
+                int framelen = MP3Header.getFrameLength(input, offset);
+                mp3Frames.add(Arrays.copyOfRange(input, offset, offset + FastMath.min(framelen, input.length - offset)));
+                audioDuration += MP3Header.getFrameDuration(input, offset);
+                offset += framelen;
+            }
+            else
+            {
+                offset += 1;
+            }
+        }
+
+        return new MP3AudioFrames(audioDuration, mp3Frames);
+    }
+
+}

src/main/java/io/github/dsheirer/audio/convert/MP3Header.java

@@ -19,6 +19,10 @@
 
 package io.github.dsheirer.audio.convert;
 
+import io.github.dsheirer.audio.convert.MPEGLayer;
+import io.github.dsheirer.audio.convert.MPEGVersion;
+import org.apache.commons.math3.util.FastMath;
+
 /**
  * Utility class for inspecting/parsing MP3 frames
  */
@@ -88,6 +92,71 @@ public class MP3Header
         return ChannelMode.fromValue((frame[offset + 3] & 0xC0) >> 6);
     }
 
+    /**
+     * Indicates if the frame has padding
+     * @param frame
+     * @param offset
+     * @return boolean
+     */
+    public static boolean isPadded(byte[] frame, int offset)
+    {
+        return (frame[offset + 2] & 0x02) == 0x02;
+    }
+
+    /**
+     * Get the number of bytes in the frame
+     * @param frame
+     * @param offset
+     * @return frame length in bytes
+     */
+    public static int getFrameLength(byte[] frame, int offset)
+    {
+        return (getFrameSamples(frame, offset) / 8) * (getBitRate(frame, offset) * 1000) / getSampleRate(frame, offset) + (isPadded(frame, offset) ? 1 : 0);
+    }
+
+    /**
+     * Get the number of samples in the frame
+     * @param frame
+     * @param offset
+     * @return length of frame in samples
+     */
+    public static int getFrameSamples(byte[] frame, int offset)
+    {
+        switch(getMPEGVersion(frame, offset))
+        {
+            case V_1:
+                switch(getMPEGLayer(frame, offset))
+                {
+                    case LAYER1: return 384;
+                    case LAYER2: return 1152;
+                    case LAYER3: return 1152;
+                    default:
+                }
+            case V_2:
+            case V_2_5:
+                switch(getMPEGLayer(frame, offset))
+                {
+                    case LAYER1: return 384;
+                    case LAYER2: return 1152;
+                    case LAYER3: return 576;
+                    default:
+                }
+            default:
+        }
+        return 0;
+    }
+
+    /**
+     * Get the frame duration in milliseconds
+     * @param frame
+     * @param offset
+     * @return duration in milliseconds
+     */
+    public static int getFrameDuration(byte[] frame, int offset)
+    {
+        return (int)FastMath.round((double)getFrameSamples(frame, offset) / (double)getSampleRate(frame, offset) * 1000);
+    }
+
     /**
      * Inspects the frame bytes and provides details about the header.
      */

src/main/java/io/github/dsheirer/audio/convert/MP3Setting.java

@@ -19,6 +19,8 @@
 
 package io.github.dsheirer.audio.convert;
 
+import java.util.Arrays;
+import java.util.List;
 import net.sourceforge.lame.mp3.Lame;
 
 /**
@@ -79,6 +81,30 @@ public enum MP3Setting
         return mSetting;
     }
 
+    /**
+     * Input audio formats that are supported by the MP3Setting value.
+     * @return list of supported input audio sample rates.
+     */
+    public List<InputAudioFormat> getSupportedSampleRates()
+    {
+        switch(this)
+        {
+            case CBR_16:
+            {
+                return InputAudioFormat.SAMPLE_RATES_8_16.stream().toList();
+            }
+            case CBR_32:
+            case VBR_7:
+            {
+                return InputAudioFormat.SAMPLE_RATES_8_16_22.stream().toList();
+            }
+            default:
+            {
+                return Arrays.stream(InputAudioFormat.values()).toList();
+            }
+        }
+    }
+
     @Override
     public String toString()
     {

src/main/java/io/github/dsheirer/audio/convert/MP3SilenceGenerator.java

@@ -19,19 +19,20 @@
 package io.github.dsheirer.audio.convert;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.apache.commons.math3.util.FastMath;
 
 public class MP3SilenceGenerator implements ISilenceGenerator
 {
     private final static Logger mLog = LoggerFactory.getLogger(MP3SilenceGenerator.class);
-    public static final int MP3_BIT_RATE = 16;
-    public static final boolean CONSTANT_BIT_RATE = false;
 
     private MP3AudioConverter mMP3AudioConverter;
     private InputAudioFormat mInputAudioFormat;
-    private byte[] mPreviousPartialFrameData;
+    private byte[] mSilenceFrame;
+    private int mSilenceFrameDuration;
 
     /**
      * Generates MP3 audio silence frames
@@ -40,19 +41,17 @@ public class MP3SilenceGenerator implements ISilenceGenerator
     {
         mInputAudioFormat = inputAudioFormat;
         mMP3AudioConverter = new MP3AudioConverter(inputAudioFormat, setting, false);
+        generate_frame();
     }
 
     /**
-     * Generates silence frames
-     * @param duration_ms in milliseconds
+     * Generates a single silence frame
      * @return
      */
-    public List<byte[]> generate(long duration_ms)
+    private void generate_frame()
     {
-        double duration_secs = (double)duration_ms / 1000.0;
-
         //We generate silence at 8000 kHz, because it gets resampled by the silence generator to the target rate
-        int length = (int)(duration_secs * InputAudioFormat.SR_8000.getSampleRate());
+        int length = (int)(InputAudioFormat.SR_8000.getSampleRate());
 
         List<float[]> silenceBuffers = new ArrayList<>();
 
@@ -64,7 +63,40 @@ public class MP3SilenceGenerator implements ISilenceGenerator
             added += chunk;
         }
 
-        return mMP3AudioConverter.convert(silenceBuffers);
+        List<byte[]> mp3Audio =  mMP3AudioConverter.convert(silenceBuffers);
+        byte[] silence = new byte[0];
+        for(byte[] mp3Chunk: mp3Audio)
+        {
+            silence = merge(silence, mp3Chunk);
+        }
+
+        MP3AudioFrames mp3Frames = MP3FrameTools.split(silence);
+        if(mp3Frames.hasNextFrame())
+        {
+            mp3Frames.nextFrame();
+            mSilenceFrame = mp3Frames.getCurrentFrame();
+            mSilenceFrameDuration = mp3Frames.getCurrentFrameDuration();
+        }
+
+    }
+
+    /**
+     * Generates silence frames
+     * @param duration_ms in milliseconds
+     * @return
+     */
+    public MP3AudioFrames generate(long duration_ms)
+    {
+        List<byte[]> silenceFrames = new ArrayList<>();
+        int silenceDuration = 0;
+
+        while(silenceDuration < duration_ms)
+        {
+            silenceFrames.add(mSilenceFrame);
+            silenceDuration += mSilenceFrameDuration;
+        }
+
+        return new MP3AudioFrames(silenceDuration, silenceFrames);
     }
 
     private static byte[] merge(byte[] a, byte[] b)
@@ -89,6 +121,7 @@ public class MP3SilenceGenerator implements ISilenceGenerator
         return c;
     }
 
+    /* TODO: Rework for MP3SilenceGenerator returning IAudioFrames
     public static void main(String[] args)
     {
         mLog.debug("Starting ...");
@@ -113,4 +146,5 @@ public class MP3SilenceGenerator implements ISilenceGenerator
 
         mLog.debug("Finished");
     }
+    */
 }

src/main/java/io/github/dsheirer/audio/playback/AudioOutput.java

@@ -1,30 +1,27 @@
 /*
+ * *****************************************************************************
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
- *  * ******************************************************************************
- *  * Copyright (C) 2014-2020 Dennis Sheirer
- *  *
- *  * This program is free software: you can redistribute it and/or modify
- *  * it under the terms of the GNU General Public License as published by
- *  * the Free Software Foundation, either version 3 of the License, or
- *  * (at your option) any later version.
- *  *
- *  * This program is distributed in the hope that it will be useful,
- *  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  * GNU General Public License for more details.
- *  *
- *  * You should have received a copy of the GNU General Public License
- *  * along with this program.  If not, see <http://www.gnu.org/licenses/>
- *  * *****************************************************************************
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * ****************************************************************************
  */
 package io.github.dsheirer.audio.playback;
 
 import com.google.common.eventbus.Subscribe;
-import io.github.dsheirer.alias.id.priority.Priority;
 import io.github.dsheirer.audio.AudioEvent;
 import io.github.dsheirer.audio.AudioSegment;
+import io.github.dsheirer.controller.NamingThreadFactory;
 import io.github.dsheirer.eventbus.MyEventBus;
 import io.github.dsheirer.identifier.IdentifierCollection;
 import io.github.dsheirer.identifier.IdentifierUpdateNotification;
@@ -33,11 +30,13 @@ import io.github.dsheirer.preference.UserPreferences;
 import io.github.dsheirer.sample.Broadcaster;
 import io.github.dsheirer.sample.Listener;
 import io.github.dsheirer.source.mixer.MixerChannel;
-import io.github.dsheirer.util.ThreadPool;
-import javafx.beans.property.BooleanProperty;
-import javafx.beans.property.IntegerProperty;
-import javafx.beans.property.SimpleBooleanProperty;
-import javafx.beans.property.SimpleIntegerProperty;
+import java.nio.ByteBuffer;
+import java.util.concurrent.Executors;
+import java.util.concurrent.LinkedTransferQueue;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -51,10 +50,6 @@ import javax.sound.sampled.LineListener;
 import javax.sound.sampled.LineUnavailableException;
 import javax.sound.sampled.Mixer;
 import javax.sound.sampled.SourceDataLine;
-import java.nio.ByteBuffer;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.locks.ReentrantLock;
 
 /**
  * Audio output/playback channel for a single audio mixer channel.  Providers support for playback of audio segments
@@ -67,7 +62,6 @@ public abstract class AudioOutput implements LineListener, Listener<IdentifierUp
     private int mBufferStopThreshold;
     private Listener<IdentifierCollection> mIdentifierCollectionListener;
     private Broadcaster<AudioEvent> mAudioEventBroadcaster = new Broadcaster<>();
-    private ScheduledFuture<?> mProcessorFuture;
     private SourceDataLine mOutput;
     private Mixer mMixer;
     private MixerChannel mMixerChannel;
@@ -76,17 +70,17 @@ public abstract class AudioOutput implements LineListener, Listener<IdentifierUp
     private AudioEvent mAudioStartEvent;
     private AudioEvent mAudioStopEvent;
     private boolean mCanProcessAudio = false;
+    private LinkedTransferQueue<AudioSegment> mAudioSegmentQueue = new LinkedTransferQueue<>();
     private AudioSegment mCurrentAudioSegment;
-    private AudioSegment mNextAudioSegment;
-    private ReentrantLock mLock = new ReentrantLock();
     private int mCurrentBufferIndex = 0;
     private UserPreferences mUserPreferences;
-    private BooleanProperty mEmptyProperty = new SimpleBooleanProperty(true);
-    private IntegerProperty mAudioPriority = new SimpleIntegerProperty(Priority.DEFAULT_PRIORITY);
     private ByteBuffer mAudioSegmentStartTone;
-    private ByteBuffer mAudioSegmentPreemptTone;
     private ByteBuffer mAudioSegmentDropTone;
     private boolean mRunning = false;
+    private ScheduledExecutorService mScheduledExecutorService;
+    private ScheduledFuture<?> mProcessorFuture;
+    private long mOutputLastTimestamp = 0;
+    private static final long STALE_PLAYBACK_THRESHOLD_MS = 500;
 
     /**
      * Single audio channel playback with automatic starting and stopping of the
@@ -107,6 +101,8 @@ public abstract class AudioOutput implements LineListener, Listener<IdentifierUp
     {
         mMixer = mixer;
         mMixerChannel = mixerChannel;
+        mScheduledExecutorService = Executors.newSingleThreadScheduledExecutor(new NamingThreadFactory(
+                "sdrtrunk audio output " + mixerChannel.name()));
         mUserPreferences = userPreferences;
 
         try
@@ -150,7 +146,7 @@ public abstract class AudioOutput implements LineListener, Listener<IdentifierUp
                     }
 
 					//Run the queue processor task every 100 milliseconds or 10 times a second
-                    mProcessorFuture = ThreadPool.SCHEDULED.scheduleAtFixedRate(new AudioSegmentProcessor(),
+                    mProcessorFuture = mScheduledExecutorService.scheduleAtFixedRate(new AudioSegmentProcessor(),
                         0, 100, TimeUnit.MILLISECONDS);
                 }
 
@@ -172,26 +168,17 @@ public abstract class AudioOutput implements LineListener, Listener<IdentifierUp
     }
 
     /**
-     * Boolean property that indicates if this audio output has an audio segment queued or in process of playback.
+     * Indicates if this audio output doesn't currently have any audio segments queued for playback.
+     * @return true if empty
      */
-    public BooleanProperty emptyProperty()
+    public boolean isEmpty()
     {
-        return mEmptyProperty;
+        return mAudioSegmentQueue.isEmpty();
     }
 
     /**
-     * Audio playback priority of the current audio segment or default audio priority if nothing is currently loaded.
-     */
-    public IntegerProperty audioPriorityProperty()
-    {
-        return mAudioPriority;
-    }
-
-    /**
-     * Schedules the audio segment for playback.
-     *
-     * Note: if a segment is currently playing and another audio segment is already queued for playback, invoking
-     * this method will overwrite the queued segment with the argument.
+     * Schedules the audio segment for playback.  The audio segment user count should already be incremented by the
+     * calling entity.
      *
      * @param audioSegment to schedule for playback.
      */
@@ -199,23 +186,8 @@ public abstract class AudioOutput implements LineListener, Listener<IdentifierUp
     {
         if(audioSegment != null)
         {
-            mLock.lock();
-
-            if(mNextAudioSegment != null)
-            {
-                mNextAudioSegment.decrementConsumerCount();
-                mNextAudioSegment = null;
-            }
-
-            try
-            {
-                mNextAudioSegment = audioSegment;
-                mEmptyProperty.set(false);
-            }
-            finally
-            {
-                mLock.unlock();
-            }
+            //Audio segment use count has already been incremented by the external caller.
+            mAudioSegmentQueue.add(audioSegment);
         }
     }
 
@@ -262,7 +234,6 @@ public abstract class AudioOutput implements LineListener, Listener<IdentifierUp
     private void updateToneInsertionAudioClips()
     {
         mAudioSegmentStartTone = null;
-        mAudioSegmentPreemptTone = null;
         mAudioSegmentDropTone = null;
 
         float[] start = mUserPreferences.getPlaybackPreference().getStartTone();
@@ -272,13 +243,6 @@ public abstract class AudioOutput implements LineListener, Listener<IdentifierUp
             mAudioSegmentStartTone = convert(start);
         }
 
-        float[] preempt = mUserPreferences.getPlaybackPreference().getPreemptTone();
-
-        if(preempt != null)
-        {
-            mAudioSegmentPreemptTone = convert(preempt);
-        }
-
         float[] drop = mUserPreferences.getPlaybackPreference().getDropTone();
 
         if(drop != null)
@@ -287,48 +251,6 @@ public abstract class AudioOutput implements LineListener, Listener<IdentifierUp
         }
     }
 
-    /**
-     * Disposes of a processed audio segment and notifies the originator that processing of the segment is complete
-     * by decrementing the consumer count.
-     * @param audioSegment to dispose
-     */
-    private void dispose(AudioSegment audioSegment)
-    {
-        mAudioPriority.unbind();
-
-        if(audioSegment != null)
-        {
-            audioSegment.decrementConsumerCount();
-            audioSegment.removeIdentifierUpdateNotificationListener(this);
-        }
-    }
-
-    /**
-     * Generates a tone indicating that a new audio segment is starting
-     */
-    private ByteBuffer getAudioSegmentStartTone()
-    {
-        return mAudioSegmentStartTone;
-    }
-
-    /**
-     * Generates a tone indicating that the current audio segment playback has been preempted for a higher priority
-     * audio segment that is now starting.
-     */
-    private ByteBuffer getAudioSegmentPreemptionTone()
-    {
-        return mAudioSegmentPreemptTone;
-    }
-
-    /**
-     * Generates a tone indicating that the current audio segment playback has been dropped because the audio segment
-     * has been flagged as Do Not Monitor after playback has started.
-     */
-    private ByteBuffer getAudioSegmentDropTone()
-    {
-        return mAudioSegmentDropTone;
-    }
-
     /**
      * Writes the audio buffer data to the source data line.  If the data line is not currently playing, write as
      * much of the buffer to the data line as will fit, start the dataline, and then finish writing the residual
@@ -355,6 +277,7 @@ public abstract class AudioOutput implements LineListener, Listener<IdentifierUp
 
                 //Top off the buffer and check if we can start it
                 wrote += mOutput.write(buffer.array(), 0, toWrite);
+                mOutputLastTimestamp = System.currentTimeMillis();
 
                 checkStart();
             }
@@ -363,147 +286,135 @@ public abstract class AudioOutput implements LineListener, Listener<IdentifierUp
             {
                 //This will block until the buffer is fully written to the data line
                 mOutput.write(buffer.array(), wrote, buffer.array().length - wrote);
+                mOutputLastTimestamp = System.currentTimeMillis();
             }
         }
     }
 
+    /**
+     * Dispose of the currently assigned audio segment.
+     */
+    private void disposeCurrentAudioSegment()
+    {
+        if(mCurrentAudioSegment != null)
+        {
+            mCurrentAudioSegment.decrementConsumerCount();
+            mCurrentAudioSegment.removeIdentifierUpdateNotificationListener(this);
+            mCurrentAudioSegment = null;
+        }
+    }
+
+    /**
+     * Loads the next audio segment from the queue.
+     */
+    private void loadNextAudioSegment()
+    {
+        AudioSegment audioSegment = mAudioSegmentQueue.poll();
+
+        boolean verificationInProgress = (audioSegment != null);
+
+        while(verificationInProgress)
+        {
+            if(audioSegment != null)
+            {
+                //Throw away the audio segment if it has been flagged as do not monitor or is duplicate
+                if(isThrowaway(audioSegment))
+                {
+                    audioSegment.decrementConsumerCount();
+                    audioSegment = mAudioSegmentQueue.poll();
+                }
+                else
+                {
+                    verificationInProgress = false;
+                }
+            }
+            else
+            {
+                verificationInProgress = false;
+            }
+        }
+
+        mCurrentAudioSegment = audioSegment;
+
+        if(audioSegment != null)
+        {
+            mCurrentAudioSegment.addIdentifierUpdateNotificationListener(this);
+            broadcast(mCurrentAudioSegment.getIdentifierCollection());
+
+            //If we played any amount of the previous audio segment then play the audio segment start.  We check this
+            //to avoid repeatedly playing an audio segment start tone on the rare occasion that we have empty segments.
+            if(mCurrentBufferIndex > 0)
+            {
+                playAudio(mAudioSegmentStartTone);
+            }
+        }
+
+        mCurrentBufferIndex = 0;
+    }
+
+    /**
+     * Indicates if the audio segment should be thrown away because it is marked as duplicate or do-not-monitor.
+     * @param audioSegment to evaluate
+     * @return true if the audio should be thrown away.
+     */
+    private boolean isThrowaway(AudioSegment audioSegment)
+    {
+        return audioSegment != null &&
+               (audioSegment.isDoNotMonitor() ||
+               (audioSegment.isDuplicate() && mUserPreferences.getDuplicateCallDetectionPreference()
+                        .isDuplicatePlaybackSuppressionEnabled()));
+    }
+
     /**
      * Manage audio segment playback and process audio segment buffers.  This method is designed to be called
-     * by a threaded processor repeatedly to playback the current audio segment and check for and start a newly
-     * assigned audio segment.  It also handles starting and stopping the playback source data line to avoid audio
+     * by a threaded processor repeatedly to playback the current audio segment and check for and start newly
+     * added audio segments.  It also handles starting and stopping the playback source data line to avoid audio
      * discontinuities due to buffer underruns.
      */
     private void processAudio()
     {
-        if(mNextAudioSegment != null)
+        if(mCurrentAudioSegment == null)
         {
-            mLock.lock();
-
-            try
-            {
-                //Remove an assigned segment that's subsequently flagged as duplicate or do not monitor before playback
-                if(mNextAudioSegment.isDoNotMonitor() || (mNextAudioSegment.isDuplicate() &&
-                    mUserPreferences.getDuplicateCallDetectionPreference().isDuplicatePlaybackSuppressionEnabled()))
-                {
-                    mNextAudioSegment = null;
-
-                    if(mCurrentAudioSegment == null)
-                    {
-                        mEmptyProperty.set(true);
-                    }
-                }
-                //For linked audio segments, allow the linked segment to complete first before assigning the next
-                else if(mNextAudioSegment.isLinked())
-                {
-                    if(mCurrentAudioSegment == null)
-                    {
-                        mCurrentAudioSegment = mNextAudioSegment;
-                        mNextAudioSegment = null;
-                        mCurrentBufferIndex = 0;
-
-                        if(mCurrentAudioSegment != null)
-                        {
-                            mAudioPriority.bind(mCurrentAudioSegment.monitorPriorityProperty());
-                            mCurrentAudioSegment.addIdentifierUpdateNotificationListener(this);
-                            broadcast(mCurrentAudioSegment.getIdentifierCollection());
-                        }
-                        else
-                        {
-                            mAudioPriority.setValue(Priority.DEFAULT_PRIORITY);
-                        }
-                    }
-                }
-                else
-                {
-                    //Insert audio segment start or audio priority preemption bonk tone
-                    if(mCurrentAudioSegment == null)
-                    {
-                        playAudio(getAudioSegmentStartTone());
-                    }
-                    else if(mCurrentBufferIndex > 0 &&
-                        (!mCurrentAudioSegment.completeProperty().get() ||
-                            mCurrentBufferIndex < mCurrentAudioSegment.getAudioBufferCount()))
-                    {
-                        playAudio(getAudioSegmentPreemptionTone());
-                    }
-                    else
-                    {
-                        playAudio(getAudioSegmentStartTone());
-                    }
-
-                    //Close current audio segment
-                    dispose(mCurrentAudioSegment);
-                    mCurrentAudioSegment = mNextAudioSegment;
-                    mNextAudioSegment = null;
-                    mCurrentBufferIndex = 0;
-
-                    if(mCurrentAudioSegment != null)
-                    {
-                        mAudioPriority.bind(mCurrentAudioSegment.monitorPriorityProperty());
-                        mCurrentAudioSegment.addIdentifierUpdateNotificationListener(this);
-                        broadcast(mCurrentAudioSegment.getIdentifierCollection());
-                    }
-                    else
-                    {
-                        mAudioPriority.setValue(Priority.DEFAULT_PRIORITY);
-                    }
-                }
-            }
-            finally
-            {
-                mLock.unlock();
-            }
+            loadNextAudioSegment();
         }
 
-        if(mCurrentAudioSegment != null)
+        //Reevaluate current audio segment to see if the status has changed for duplicate or do-not-monitor.
+        if(isThrowaway(mCurrentAudioSegment))
         {
-            //Check for completed audio segment or a segment flagged as duplicate or Do Not Monitor
-            if(mCurrentAudioSegment.isDoNotMonitor() ||
-               (mCurrentAudioSegment.isDuplicate() &&
-                mUserPreferences.getDuplicateCallDetectionPreference().isDuplicatePlaybackSuppressionEnabled()) ||
-                (mCurrentAudioSegment.completeProperty().get() && mCurrentBufferIndex >= mCurrentAudioSegment.getAudioBufferCount()))
+            if(mCurrentBufferIndex > 0)
             {
-                if(mCurrentAudioSegment.isDoNotMonitor())
-                {
-                    playAudio(getAudioSegmentDropTone());
-                }
-
-                dispose(mCurrentAudioSegment);
-                mCurrentAudioSegment = null;
-
-                mLock.lock();
-
-                try
-                {
-                    if(mNextAudioSegment == null)
-                    {
-                        mEmptyProperty.set(true);
-                    }
-                }
-                finally
-                {
-                    mLock.unlock();
-                }
-
-                return;
+                playAudio(mAudioSegmentDropTone);
             }
 
-            //Process any new buffers that have been added to the audio segment.  If a next audio segment gets assigned
-            //while processing, exit the loop so that we can evaluate the next for higher priority preempt.  If the next
-            //segment is a linked segment, ignore it so that we can close out the current segment.
-            while(mCurrentAudioSegment != null && (mNextAudioSegment == null || mNextAudioSegment.isLinked()) &&
-                   mCurrentBufferIndex < mCurrentAudioSegment.getAudioBufferCount() &&
-                   !mCurrentAudioSegment.isDoNotMonitor() && !(mCurrentAudioSegment.isDuplicate() &&
-                mUserPreferences.getDuplicateCallDetectionPreference().isDuplicatePlaybackSuppressionEnabled()))
+            disposeCurrentAudioSegment();
+            loadNextAudioSegment();
+        }
+
+        while(mCurrentAudioSegment != null && mCurrentBufferIndex < mCurrentAudioSegment.getAudioBufferCount())
+        {
+            try
             {
                 float[] audioBuffer = mCurrentAudioSegment.getAudioBuffers().get(mCurrentBufferIndex++);
 
                 if(audioBuffer != null)
                 {
                     ByteBuffer audio = convert(audioBuffer);
+                    //This call blocks until all audio bytes are dumped into the data line.
                     playAudio(audio);
                 }
             }
+            catch(Exception e)
+            {
+                mLog.error("Error while processing audio for [" + mMixerChannel.name() + "]", e);
+            }
+        }
+
+        //Check for completed and fully-played audio segment -- load next audio segment
+        if(mCurrentAudioSegment != null &&
+           mCurrentAudioSegment.isComplete() &&
+           (mCurrentBufferIndex >= mCurrentAudioSegment.getAudioBufferCount()))
+        {
+            disposeCurrentAudioSegment();
         }
 
         checkStop();
@@ -523,25 +434,7 @@ public abstract class AudioOutput implements LineListener, Listener<IdentifierUp
         }
 
         mProcessorFuture = null;
-
-        mLock.lock();
-
-        try
-        {
-            if(mNextAudioSegment != null)
-            {
-                mNextAudioSegment.decrementConsumerCount();
-                mNextAudioSegment = null;
-            }
-        }
-        finally
-        {
-            mLock.unlock();
-        }
-
-        dispose(mCurrentAudioSegment);
-        mCurrentAudioSegment = null;
-
+        disposeCurrentAudioSegment();
         mAudioEventBroadcaster.clear();
         mIdentifierCollectionListener = null;
 
@@ -650,14 +543,28 @@ public abstract class AudioOutput implements LineListener, Listener<IdentifierUp
         if(mRunning)
         {
             //If the output buffer falls below the threshold then drain the output and stop playback
-            if(mOutput.isRunning() && mOutput.available() >= mBufferStopThreshold)
+            if(mOutput.isRunning())
             {
-                mOutput.drain();
-                mOutput.stop();
-                mRunning = false;
+                if(mOutput.available() >= mBufferStopThreshold)
+                {
+                    mOutput.drain();
+                    mOutput.stop();
+                    mRunning = false;
+                }
+                //Detect when we have a partially filled output that will neither start nor stop and the last write
+                //timestamp was more than the staleness threshold (500 ms) -- stop the output and discard stale contents
+                else if(mOutput.available() < mBufferStopThreshold &&
+                        mOutput.available() > mBufferStartThreshold &&
+                        (System.currentTimeMillis() - mOutputLastTimestamp >= STALE_PLAYBACK_THRESHOLD_MS))
+                {
+                    mOutput.stop();
+                    //Discard the stale buffer contents.
+                    mOutput.flush();
+                    mRunning = false;
+                }
             }
             //If output playback stopped on its own because the buffer emptied, then cleanup
-            else if(!mOutput.isRunning())
+            else
             {
                 mRunning = false;
             }
@@ -735,16 +642,33 @@ public abstract class AudioOutput implements LineListener, Listener<IdentifierUp
      */
     public class AudioSegmentProcessor implements Runnable
     {
+        private AtomicBoolean mProcessing = new AtomicBoolean();
+
         @Override
         public void run()
         {
-            try
+            if(mProcessing.compareAndSet(false, true))
             {
-                processAudio();
-            }
-            catch(Throwable t)
-            {
-                mLog.error("Error while processing audio buffers", t);
+                try
+                {
+                    //TODO: Debug hooks - remove after testing
+                    if(mMixerChannel.name().equals("LEFT"))
+                    {
+                        int a = 0;
+                    }
+                    else if(mMixerChannel.name().equals("RIGHT"))
+                    {
+                        int a = 0;
+                    }
+
+                    processAudio();
+                }
+                catch(Throwable t)
+                {
+                    mLog.error("Error while processing audio buffers", t);
+                }
+
+                mProcessing.set(false);
             }
         }
     }

src/main/java/io/github/dsheirer/audio/playback/AudioPlaybackManager.java

@@ -1,7 +1,6 @@
 /*
- * ******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2018 Dennis Sheirer
+ * *****************************************************************************
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,7 +14,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>
- * *****************************************************************************
+ * ****************************************************************************
  */
 package io.github.dsheirer.audio.playback;
 
@@ -24,6 +23,7 @@ import io.github.dsheirer.audio.AudioEvent;
 import io.github.dsheirer.audio.AudioException;
 import io.github.dsheirer.audio.AudioSegment;
 import io.github.dsheirer.audio.IAudioController;
+import io.github.dsheirer.controller.NamingThreadFactory;
 import io.github.dsheirer.eventbus.MyEventBus;
 import io.github.dsheirer.preference.PreferenceType;
 import io.github.dsheirer.preference.UserPreferences;
@@ -31,17 +31,18 @@ import io.github.dsheirer.sample.Broadcaster;
 import io.github.dsheirer.sample.Listener;
 import io.github.dsheirer.source.mixer.MixerChannel;
 import io.github.dsheirer.source.mixer.MixerChannelConfiguration;
-import io.github.dsheirer.util.ThreadPool;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
+import java.util.concurrent.Executors;
 import java.util.concurrent.LinkedTransferQueue;
+import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * Manages scheduling and playback of audio segments to the local users audio system.
@@ -50,8 +51,6 @@ public class AudioPlaybackManager implements Listener<AudioSegment>, IAudioContr
 {
     private static final Logger mLog = LoggerFactory.getLogger(AudioPlaybackManager.class);
 
-    public static final String AUDIO_CHANNELS_PROPERTY = "audio.manager.channels";
-    public static final String AUDIO_MIXER_PROPERTY = "audio.manager.mixer";
     public static final AudioEvent CONFIGURATION_CHANGE_STARTED =
         new AudioEvent(AudioEvent.Type.AUDIO_CONFIGURATION_CHANGE_STARTED, null);
     public static final AudioEvent CONFIGURATION_CHANGE_COMPLETE =
@@ -64,6 +63,8 @@ public class AudioPlaybackManager implements Listener<AudioSegment>, IAudioContr
     private List<AudioSegment> mAudioSegments = new ArrayList<>();
     private List<AudioSegment> mPendingAudioSegments = new ArrayList<>();
     private LinkedTransferQueue<AudioSegment> mNewAudioSegmentQueue = new LinkedTransferQueue<>();
+    private ScheduledExecutorService mScheduledExecutorService =
+            Executors.newSingleThreadScheduledExecutor(new NamingThreadFactory("sdrtrunk audio manager"));
 
     /**
      * Constructs an instance.
@@ -202,29 +203,13 @@ public class AudioPlaybackManager implements Listener<AudioSegment>, IAudioContr
             //Sort audio segments by playback priority and assign to empty audio outputs
             if(!mAudioSegments.isEmpty())
             {
+                //TODO: change this to take audio segment start time into account also
                 mAudioSegments.sort(Comparator.comparingInt(o -> o.monitorPriorityProperty().get()));
 
                 //Assign empty audio outputs first
                 for(AudioOutput audioOutput: mAudioOutputs)
                 {
-                    if(audioOutput.emptyProperty().get())
-                    {
-                        audioOutput.play(mAudioSegments.remove(0));
-
-                        if(mAudioSegments.isEmpty())
-                        {
-                            return;
-                        }
-                    }
-                }
-            }
-
-            //Preempt ongoing audio segment playback when higher priority audio segments are available
-            if(!mAudioSegments.isEmpty())
-            {
-                for(AudioOutput audioOutput: mAudioOutputs)
-                {
-                    if(mAudioSegments.get(0).monitorPriorityProperty().get() < audioOutput.audioPriorityProperty().get())
+                    if(audioOutput.isEmpty())
                     {
                         audioOutput.play(mAudioSegments.remove(0));
 
@@ -284,7 +269,7 @@ public class AudioPlaybackManager implements Listener<AudioSegment>, IAudioContr
                 }
                 catch(AudioException ae)
                 {
-                    mLog.error("Error changing audio output to [" + configuration.toString() + "]", ae);
+                    mLog.error("Error changing audio output to [" + configuration + "]", ae);
                 }
             }
         }
@@ -332,7 +317,7 @@ public class AudioPlaybackManager implements Listener<AudioSegment>, IAudioContr
                     throw new AudioException("Unsupported mixer channel configuration: " + entry.getMixerChannel());
             }
 
-            mProcessingTask = ThreadPool.SCHEDULED.scheduleAtFixedRate(new AudioSegmentProcessor(),
+            mProcessingTask = mScheduledExecutorService.scheduleAtFixedRate(new AudioSegmentProcessor(),
                 0, 100, TimeUnit.MILLISECONDS);
             mControllerBroadcaster.broadcast(CONFIGURATION_CHANGE_COMPLETE);
             mMixerChannelConfiguration = entry;
@@ -343,7 +328,7 @@ public class AudioPlaybackManager implements Listener<AudioSegment>, IAudioContr
      * Current audio playback mixer channel configuration setting.
      */
     @Override
-    public MixerChannelConfiguration getMixerChannelConfiguration() throws AudioException
+    public MixerChannelConfiguration getMixerChannelConfiguration()
     {
         return mMixerChannelConfiguration;
     }
@@ -384,16 +369,23 @@ public class AudioPlaybackManager implements Listener<AudioSegment>, IAudioContr
      */
     public class AudioSegmentProcessor implements Runnable
     {
+        private AtomicBoolean mProcessing = new AtomicBoolean();
+
         @Override
         public void run()
         {
-            try
+            if(mProcessing.compareAndSet(false, true))
             {
-                processAudioSegments();
-            }
-            catch(Throwable t)
-            {
-                mLog.error("Encountered error while processing audio segments", t);
+                try
+                {
+                    processAudioSegments();
+                }
+                catch(Throwable t)
+                {
+                    mLog.error("Encountered error while processing audio segments", t);
+                }
+
+                mProcessing.set(false);
             }
         }
     }

src/main/java/io/github/dsheirer/bits/BinaryMessage.java

@@ -1,35 +1,40 @@
 /*
+ * *****************************************************************************
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
- *  * ******************************************************************************
- *  * Copyright (C) 2014-2019 Dennis Sheirer
- *  *
- *  * This program is free software: you can redistribute it and/or modify
- *  * it under the terms of the GNU General Public License as published by
- *  * the Free Software Foundation, either version 3 of the License, or
- *  * (at your option) any later version.
- *  *
- *  * This program is distributed in the hope that it will be useful,
- *  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  * GNU General Public License for more details.
- *  *
- *  * You should have received a copy of the GNU General Public License
- *  * along with this program.  If not, see <http://www.gnu.org/licenses/>
- *  * *****************************************************************************
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * ****************************************************************************
  */
 package io.github.dsheirer.bits;
 
 import io.github.dsheirer.edac.CRC;
+import java.io.UnsupportedEncodingException;
+import java.util.BitSet;
 import org.apache.commons.lang3.Validate;
 import org.apache.commons.math3.util.FastMath;
-
-import java.util.BitSet;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class BinaryMessage extends BitSet
 {
     private static final long serialVersionUID = 1L;
+    private static final Logger LOGGER = LoggerFactory.getLogger(BinaryMessage.class);
+    private static final int[] CHARACTER_7_BIT = new int[]{0, 1, 2, 3, 4, 5, 6};
+    private static final int[] CHARACTER_8_BIT = new int[]{0, 1, 2, 3, 4, 5, 6, 7};
+    private static final String UTF_8 = "UTF-8";
+    private static final String GB2312 = "GB2312";
+
 
     /**
      * Logical (ie constructed) size of this bitset, despite the actual size of
@@ -1038,6 +1043,51 @@ public class BinaryMessage extends BitSet
         return buffer;
     }
 
+    /**
+     * Loads the hexadecimal text into a binary message
+     * @param hex text to load from
+     * @return loaded binary message
+     */
+    public static BinaryMessage loadHex(String hex)
+    {
+        if(!hex.matches("[0-9A-F]*"))
+        {
+            throw new IllegalArgumentException("Message must contain only 0-9 and A-F hexadecimal characters");
+        }
+
+        int length = hex.length() / 2;
+
+        if(length * 2 < hex.length())
+        {
+            length++;
+        }
+
+        BinaryMessage buffer = new BinaryMessage(length * 8);
+
+        int bufferOffset = 0;
+        for(int x = 0; x < hex.length(); x += 2)
+        {
+            int endIndex = x + 2;
+            if(endIndex > hex.length())
+            {
+                endIndex--;
+            }
+
+            String rawHex = hex.substring(x, endIndex);
+
+            if(rawHex.length() == 1)
+            {
+                rawHex = rawHex + "0";
+            }
+
+            int value = Integer.parseInt(rawHex, 16);
+            buffer.setByte(bufferOffset, (byte)(value & 0xFF));
+            bufferOffset += 8;
+        }
+
+        return buffer;
+    }
+
     /**
      * Left rotates the bits between start and end indices, number of places.
      */
@@ -1133,19 +1183,121 @@ public class BinaryMessage extends BitSet
         this.xor(mask);
     }
 
-    public static void main(String[] args)
+    /**
+     * Parse ISO-7 bit characters from the message starting at the offset.
+     * @param offset where to start parsing.
+     * @param characterCount number of characters to parse
+     * @return parsed message.
+     */
+    public String parseISO7(int offset, int characterCount)
     {
-        BinaryMessage message = new BinaryMessage(10);
-        message.set(1);
-        message.set(4);
-        message.set(5);
-        message.set(8);
-        message.set(9);
+        byte[] bytes = new byte[characterCount];
 
-        System.out.println("Hex: " + message.toHexString() + " Size:" + message.size());
-        for(int x = 0; x < 10; x++)
+        for(int x = 0; x < characterCount; x++)
         {
-            System.out.println(x + ": " + message.getHex(x, x + 10));
+            bytes[x] = getByte(CHARACTER_7_BIT, x * 7 + offset);
         }
+
+        return new String(bytes);
+    }
+
+    /**
+     * Parse ISO-8 bit characters from the message starting at the offset.
+     * @param offset where to start parsing.
+     * @param characterCount number of characters to parse
+     * @return parsed message.
+     */
+    public String parseISO8(int offset, int characterCount)
+    {
+        byte[] bytes = new byte[characterCount];
+
+        for(int x = 0; x < characterCount; x++)
+        {
+            bytes[x] = getByte(CHARACTER_8_BIT, x * 8 + offset);
+        }
+
+        return new String(bytes);
+    }
+
+    /**
+     * Parse UTF-8 characters from the message starting at the offset.
+     * @param offset where to start parsing.
+     * @param characterCount number of characters to parse
+     * @return parsed message.
+     * @throws UnsupportedEncodingException if UTF-8 encoding is not supported.
+     */
+    public String parseUTF8(int offset, int characterCount) throws UnsupportedEncodingException
+    {
+        byte[] bytes = new byte[characterCount];
+
+        for(int x = 0; x < characterCount; x++)
+        {
+            bytes[x] = getByte(CHARACTER_8_BIT, x * 8 + offset);
+        }
+
+        return new String(bytes, UTF_8);
+    }
+
+    /**
+     * Parse GB2312 Simplified Chinese Characters from the message starting at the offset.
+     * @param offset where to start parsing.
+     * @param characterCount number of characters to parse
+     * @return parsed message.
+     * @throws UnsupportedEncodingException if GB2312 encoding is not supported.
+     */
+    public String parseGB2312(int offset, int characterCount) throws UnsupportedEncodingException
+    {
+        int length = characterCount * 2;
+        byte[] bytes = new byte[length];
+
+        for(int x = 0; x < length; x++)
+        {
+            bytes[x] = getByte(CHARACTER_8_BIT, x * 8 + offset);
+        }
+
+        return new String(bytes, GB2312);
+    }
+
+    /**
+     * Parse 16-bit unicode characters from the message starting at the offset.
+     * @param offset where to start parsing.
+     * @param characterCount number of characters to parse
+     * @return parsed message.
+     */
+    public String parseUnicode(int offset, int characterCount)
+    {
+        int length = characterCount * 2;
+        byte[] bytes = new byte[length];
+
+        for(int x = 0; x < length; x++)
+        {
+            bytes[x] = getByte(CHARACTER_8_BIT, x * 8 + offset);
+        }
+
+        return new String(bytes);
+    }
+
+    /**
+     * Parse 4-bit Binary Coded Decimal (BCD) characters from the message starting at the offset.
+     * @param offset where to start parsing.
+     * @param characterCount number of characters to parse
+     * @return parsed message.
+     */
+    public String parseBCD4(int offset, int characterCount)
+    {
+        StringBuilder sb = new StringBuilder();
+
+        int count = 0;
+
+        while(count < characterCount)
+        {
+            int nibble = getNibble(offset);
+            //This will parse digits 0-9 and anything higher will parse as hexadecimal A-F
+            sb.append(Integer.toHexString(nibble).toUpperCase());
+            offset += 4;
+            count++;
+        }
+
+        return sb.toString();
     }
 }

src/main/java/io/github/dsheirer/buffer/AbstractNativeBuffer.java

@@ -0,0 +1,70 @@
+/*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 Dennis Sheirer
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * ****************************************************************************
+ */
+
+package io.github.dsheirer.buffer;
+
+/**
+ * Base native buffer class.
+ */
+public abstract class AbstractNativeBuffer implements INativeBuffer
+{
+    private long mTimestamp;
+    private float mSamplesPerMillisecond;
+
+    /**
+     * Constructs an instance
+     * @param timestamp for the start of this buffer
+     * @param samplesPerMillisecond to calculate the time offset of sub-buffers extracted from this native buffer.
+     */
+    public AbstractNativeBuffer(long timestamp, float samplesPerMillisecond)
+    {
+        mTimestamp = timestamp;
+        mSamplesPerMillisecond = samplesPerMillisecond;
+    }
+
+    /**
+     * Timestamp for the start of this buffer
+     * @return timestamp in milliseconds
+     */
+    @Override
+    public long getTimestamp()
+    {
+        return mTimestamp;
+    }
+
+    /**
+     * Quantity of samples representing one millisecond of sample data, used for calculating fragment timestamp offsets.
+     * @return samples per millisecond count.
+     */
+    public float getSamplesPerMillisecond()
+    {
+        return mSamplesPerMillisecond;
+    }
+
+    /**
+     * Calculates the timestamp for a samples buffer fragment based on where it is extracted from relative to the
+     * native buffer starting timestamp.
+     * @param samplesPointer for the start of the fragment.  Note: this value will be divided by 2 to account for I/Q sample pairs.
+     * @return timestamp adjusted to the fragment or sub-buffer start sample.
+     */
+    protected long getFragmentTimestamp(int samplesPointer)
+    {
+        return getTimestamp() + (long)(samplesPointer / 2 / getSamplesPerMillisecond());
+    }
+}

src/main/java/io/github/dsheirer/buffer/AbstractNativeBufferFactory.java

@@ -0,0 +1,44 @@
+/*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 Dennis Sheirer
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * ****************************************************************************
+ */
+
+package io.github.dsheirer.buffer;
+
+/**
+ * Base class for native buffer factories.
+ */
+public abstract class AbstractNativeBufferFactory implements INativeBufferFactory
+{
+    private float mSamplesPerMillisecond = 0.0f;
+
+    @Override
+    public void setSamplesPerMillisecond(float samplesPerMillisecond)
+    {
+        mSamplesPerMillisecond = samplesPerMillisecond;
+    }
+
+    /**
+     * Quantity of I/Q sample pairs per milli-second at the current sample rate to use in calculating an accurate
+     * timestamp for sub-buffer that are generated from the native buffer.
+     * @return samples per millisecond.
+     */
+    public float getSamplesPerMillisecond()
+    {
+        return mSamplesPerMillisecond;
+    }
+}

src/main/java/io/github/dsheirer/buffer/ByteNativeBuffer.java

@@ -21,14 +21,13 @@ package io.github.dsheirer.buffer;
 
 import io.github.dsheirer.sample.complex.ComplexSamples;
 import io.github.dsheirer.sample.complex.InterleavedComplexSamples;
-
 import java.util.Iterator;
 
 /**
  * Native buffer sample array wrapper class that provides access to a stream of either interleaved or
  * non-interleaved complex sample buffers converted from the raw byte sample array.
  */
-public class ByteNativeBuffer implements INativeBuffer
+public class ByteNativeBuffer extends AbstractNativeBuffer
 {
     private static final int FRAGMENT_SIZE = 2048;
     private final static float[] LOOKUP_VALUES;
@@ -42,21 +41,22 @@ public class ByteNativeBuffer implements INativeBuffer
 
         for(int x = 0; x < 256; x++)
         {
-            LOOKUP_VALUES[x] = (float)(x - 127) / 128.0f;
+            LOOKUP_VALUES[x] = ((float)x - 127.5f) / 128.0f;
         }
     }
 
     private byte[] mSamples;
-    private long mTimestamp;
 
     /**
      * Constructs an instance
      * @param samples to process
      * @param timestamp of the samples
      * @param averageDc measured from sample stream
+     * @param samplesPerMillisecond to calculate derivative timestamps for sub-buffers.
      */
-    public ByteNativeBuffer(byte[] samples, long timestamp, float averageDc)
+    public ByteNativeBuffer(byte[] samples, long timestamp, float averageDc, float samplesPerMillisecond)
     {
+        super(timestamp, samplesPerMillisecond);
         //Ensure we're an even multiple of the fragment size.  Typically, this will be 64k or 128k
         if(samples.length % FRAGMENT_SIZE != 0)
         {
@@ -64,7 +64,6 @@ public class ByteNativeBuffer implements INativeBuffer
         }
 
         mSamples = samples;
-        mTimestamp = timestamp;
         mAverageDc = averageDc;
     }
 
@@ -74,12 +73,6 @@ public class ByteNativeBuffer implements INativeBuffer
         return mSamples.length / 2;
     }
 
-    @Override
-    public long getTimestamp()
-    {
-        return mTimestamp;
-    }
-
     @Override
     public Iterator<ComplexSamples> iterator()
     {
@@ -105,6 +98,8 @@ public class ByteNativeBuffer implements INativeBuffer
         @Override
         public ComplexSamples next()
         {
+            long timestamp = getFragmentTimestamp(mSamplesPointer);
+
             float[] i = new float[FRAGMENT_SIZE];
             float[] q = new float[FRAGMENT_SIZE];
             int samplesOffset = mSamplesPointer;
@@ -116,8 +111,7 @@ public class ByteNativeBuffer implements INativeBuffer
             }
 
             mSamplesPointer = samplesOffset;
-
-            return new ComplexSamples(i, q);
+            return new ComplexSamples(i, q, timestamp);
         }
     }
 
@@ -137,6 +131,8 @@ public class ByteNativeBuffer implements INativeBuffer
         @Override
         public InterleavedComplexSamples next()
         {
+            long timestamp = getFragmentTimestamp(mSamplesPointer);
+
             float[] converted = new float[FRAGMENT_SIZE * 2];
 
             int samplesPointer = mSamplesPointer;
@@ -148,7 +144,7 @@ public class ByteNativeBuffer implements INativeBuffer
 
             mSamplesPointer = samplesPointer;
 
-            return new InterleavedComplexSamples(converted, mTimestamp);
+            return new InterleavedComplexSamples(converted, timestamp);
         }
     }
 }

src/main/java/io/github/dsheirer/buffer/ByteNativeBufferFactory.java

@@ -24,18 +24,22 @@ import java.nio.ByteBuffer;
 /**
  * Implements a factory for creating ByteNativeBuffer instances
  */
-public class ByteNativeBufferFactory implements INativeBufferFactory
+public class ByteNativeBufferFactory extends AbstractNativeBufferFactory
 {
-    private static final float DC_FILTER_GAIN = 0.007f; //Normalizes DC over period of ~142 (1 / .007) buffers
-    private float mAverageDc = 0.0f;
+    private DcCorrectionManager mDcCorrectionManager = new DcCorrectionManager();
 
     @Override
     public INativeBuffer getBuffer(ByteBuffer samples, long timestamp)
     {
         byte[] copy = new byte[samples.capacity()];
         samples.get(copy);
-        calculateDc(copy);
-        return new ByteNativeBuffer(copy, timestamp, mAverageDc);
+
+        if(mDcCorrectionManager.shouldCalculateDc())
+        {
+            calculateDc(copy);
+        }
+
+        return new ByteNativeBuffer(copy, timestamp, mDcCorrectionManager.getAverageDc(), getSamplesPerMillisecond());
     }
 
     /**
@@ -45,7 +49,7 @@ public class ByteNativeBufferFactory implements INativeBufferFactory
      */
     private void calculateDc(byte[] samples)
     {
-        double dcAccumulator = 0;
+        float dcAccumulator = 0;
 
         for(byte sample: samples)
         {
@@ -53,9 +57,8 @@ public class ByteNativeBufferFactory implements INativeBufferFactory
         }
 
         dcAccumulator /= samples.length;
-        dcAccumulator -= 127.0f;
+        dcAccumulator -= 127.5f;
         dcAccumulator /= 128.0f;
-        dcAccumulator -= mAverageDc;
-        mAverageDc += (dcAccumulator * DC_FILTER_GAIN);
+        mDcCorrectionManager.adjust(dcAccumulator);
     }
 }

src/main/java/io/github/dsheirer/buffer/DcCorrectionManager.java

@@ -0,0 +1,114 @@
+/*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 Dennis Sheirer
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * ****************************************************************************
+ */
+
+package io.github.dsheirer.buffer;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Provides DC offset correction value and manages calculation processing interval.
+ */
+public class DcCorrectionManager
+{
+//    private static Logger mLog = LoggerFactory.getLogger(DcCorrectionManager.class);
+//    private DecimalFormat mDecimalFormat = new DecimalFormat("0.00000");
+
+    /**
+     * Time (delay) interval for running DC removal calculations
+     */
+    private static final long DC_PROCESSING_INTERVAL = TimeUnit.SECONDS.toMillis(50);
+
+    /**
+     * Number of buffers to process per DC calculation processing interval.
+     */
+    private static final int DC_CALCULATIONS_PER_INTERVAL = 5;
+
+    /**
+     * DC offset processing residual threshold for ending DC processing interval
+     */
+    private static final float TARGET_DC_OFFSET_REMAINING = 0.0001f;
+
+    /**
+     * Number of DC calculations remaining in the current interval
+     */
+    private int mDcCalculationsRemaining = DC_CALCULATIONS_PER_INTERVAL; //Initial value for coarse correction
+
+    /**
+     * Last time DC offset calculation interval ran
+     */
+    private long mLastDcCalculationTimestamp = 0;
+
+    /**
+     * DC offset calculation gain.
+     */
+    private static final float DC_FILTER_GAIN = 0.05f;
+
+    /**
+     * Current DC offset correction value
+     */
+    private float mAverageDc = 0.0f;
+
+    public float getAverageDc()
+    {
+        return mAverageDc;
+    }
+
+    /**
+     * Adjusts the average DC based on the current calculated DC offset present in a sample buffer.
+     * @param calculatedDc for the current sample buffer
+     */
+    public void adjust(float calculatedDc)
+    {
+        //Calculate the average scaled DC offset so that it can be applied in the native buffer's converted samples
+        float residualOffsetToRemove = calculatedDc - mAverageDc;
+
+        mAverageDc += (residualOffsetToRemove * DC_FILTER_GAIN);
+
+        if(Math.abs(residualOffsetToRemove) < TARGET_DC_OFFSET_REMAINING)
+        {
+            mDcCalculationsRemaining--;
+        }
+//
+//        mLog.info("DC: " + mDecimalFormat.format(mAverageDc) +
+//                " RES:" + mDecimalFormat.format(residualOffsetToRemove) +
+//                " REM:" + mDcCalculationsRemaining);
+    }
+
+    /**
+     * Indicates if a DC offset calculation for a buffer should be performed.
+     */
+    public boolean shouldCalculateDc()
+    {
+        if(System.currentTimeMillis() > (mLastDcCalculationTimestamp + DC_PROCESSING_INTERVAL))
+        {
+            if(mDcCalculationsRemaining > 0)
+            {
+                return true;
+            }
+            else
+            {
+                //Reset the number of buffers to calculate and the timestamp
+                mDcCalculationsRemaining = DC_CALCULATIONS_PER_INTERVAL;
+                mLastDcCalculationTimestamp = System.currentTimeMillis();
+            }
+        }
+
+        return false;
+    }
+}

src/main/java/io/github/dsheirer/buffer/FloatNativeBuffer.java

@@ -22,35 +22,24 @@ package io.github.dsheirer.buffer;
 import io.github.dsheirer.sample.SampleUtils;
 import io.github.dsheirer.sample.complex.ComplexSamples;
 import io.github.dsheirer.sample.complex.InterleavedComplexSamples;
-
 import java.util.Iterator;
 
 /**
  * Simple native buffer implementation that simply wraps a single, existing, non-native sample buffer.
  */
-public class FloatNativeBuffer implements INativeBuffer
+public class FloatNativeBuffer extends AbstractNativeBuffer
 {
     private float[] mInterleavedComplexSamples;
-    private long mTimestamp;
 
     /**
      * Constructs an instance
-     * @param complexSamples to wrap
+     * @param complexSamples interleaved to wrap
      * @param timestamp for the buffer
      */
-    public FloatNativeBuffer(float[] complexSamples, long timestamp)
+    public FloatNativeBuffer(float[] complexSamples, long timestamp, float samplesPerMillisecond)
     {
+        super(timestamp, samplesPerMillisecond);
         mInterleavedComplexSamples = complexSamples;
-        mTimestamp = timestamp;
-    }
-
-    /**
-     * Constructs an instance
-     * @param complexSamples to wrap
-     */
-    public FloatNativeBuffer(float[] complexSamples)
-    {
-        this(complexSamples, System.currentTimeMillis());
     }
 
     /**
@@ -58,9 +47,9 @@ public class FloatNativeBuffer implements INativeBuffer
      * @param samples to wrap
      * @param timestamp for the buffer
      */
-    public FloatNativeBuffer(ComplexSamples samples, long timestamp)
+    public FloatNativeBuffer(ComplexSamples samples)
     {
-        this(SampleUtils.interleave(samples), timestamp);
+        this(SampleUtils.interleave(samples), samples.timestamp(), 0.0f);
     }
 
     /**
@@ -69,7 +58,7 @@ public class FloatNativeBuffer implements INativeBuffer
      */
     public FloatNativeBuffer(InterleavedComplexSamples samples)
     {
-        this(samples.samples(), samples.timestamp());
+        this(samples.samples(), samples.timestamp(), 0.0f);
     }
 
     @Override
@@ -90,12 +79,6 @@ public class FloatNativeBuffer implements INativeBuffer
         return mInterleavedComplexSamples.length / 2;
     }
 
-    @Override
-    public long getTimestamp()
-    {
-        return mTimestamp;
-    }
-
     private class ComplexSamplesIterator implements  Iterator<ComplexSamples>
     {
         private boolean mEmpty;
@@ -115,7 +98,7 @@ public class FloatNativeBuffer implements INativeBuffer
             }
 
             mEmpty = true;
-            return SampleUtils.deinterleave(mInterleavedComplexSamples);
+            return SampleUtils.deinterleave(mInterleavedComplexSamples, getTimestamp());
         }
     }
 
@@ -139,7 +122,7 @@ public class FloatNativeBuffer implements INativeBuffer
             }
 
             mEmpty = true;
-            return new InterleavedComplexSamples(mInterleavedComplexSamples, mTimestamp);
+            return new InterleavedComplexSamples(mInterleavedComplexSamples, getTimestamp());
         }
     }
 }

src/main/java/io/github/dsheirer/buffer/INativeBufferFactory.java

@@ -33,7 +33,15 @@ public interface INativeBufferFactory
      *
      * @param samples byte array copied from native memory
      * @param timestamp of the samples
+     * @param samplesPerMillisecond to calculate timestamp offset for child buffers.
      * @return instance
      */
     INativeBuffer getBuffer(ByteBuffer samples, long timestamp);
+
+    /**
+     * Sets the samples per millisecond rate based on the current sample rate.
+     *
+     * @param samplesPerMillisecond to calculate timestamp offset for child buffers.
+     */
+    void setSamplesPerMillisecond(float samplesPerMillisecond);
 }

src/main/java/io/github/dsheirer/buffer/SignedByteNativeBuffer.java

@@ -21,14 +21,13 @@ package io.github.dsheirer.buffer;
 
 import io.github.dsheirer.sample.complex.ComplexSamples;
 import io.github.dsheirer.sample.complex.InterleavedComplexSamples;
-
 import java.util.Iterator;
 
 /**
  * Native buffer sample array wrapper class that provides access to a stream of either interleaved or
  * non-interleaved complex sample buffers converted from the raw byte sample array.
  */
-public class SignedByteNativeBuffer implements INativeBuffer
+public class SignedByteNativeBuffer extends AbstractNativeBuffer
 {
     private static final int FRAGMENT_SIZE = 2048;
     private final static float[] LOOKUP_VALUES;
@@ -47,7 +46,6 @@ public class SignedByteNativeBuffer implements INativeBuffer
     }
 
     private byte[] mSamples;
-    private long mTimestamp;
     private float mIAverageDc;
     private float mQAverageDc;
 
@@ -57,9 +55,12 @@ public class SignedByteNativeBuffer implements INativeBuffer
      * @param timestamp of the samples
      * @param iAverageDc of the sample stream
      * @param qAverageDc of the sample stream
+     * @param samplesPerMillisecond to calculate sub-buffer timestamps
      */
-    public SignedByteNativeBuffer(byte[] samples, long timestamp, float iAverageDc, float qAverageDc)
+    public SignedByteNativeBuffer(byte[] samples, long timestamp, float iAverageDc, float qAverageDc, float samplesPerMillisecond)
     {
+        super(timestamp, samplesPerMillisecond);
+
         //Ensure we're an even multiple of the fragment size.  Typically, this will be 64k or 128k
         if(samples.length % FRAGMENT_SIZE != 0)
         {
@@ -67,17 +68,10 @@ public class SignedByteNativeBuffer implements INativeBuffer
         }
 
         mSamples = samples;
-        mTimestamp = timestamp;
         mIAverageDc = iAverageDc;
         mQAverageDc = qAverageDc;
     }
 
-    @Override
-    public long getTimestamp()
-    {
-        return mTimestamp;
-    }
-
     @Override
     public int sampleCount()
     {
@@ -112,6 +106,8 @@ public class SignedByteNativeBuffer implements INativeBuffer
         @Override
         public ComplexSamples next()
         {
+            long timestamp = getFragmentTimestamp(mSamplesPointer);
+
             float[] i = new float[FRAGMENT_SIZE];
             float[] q = new float[FRAGMENT_SIZE];
             int samplesOffset = mSamplesPointer;
@@ -123,7 +119,7 @@ public class SignedByteNativeBuffer implements INativeBuffer
             }
 
             mSamplesPointer = samplesOffset;
-            return new ComplexSamples(i, q);
+            return new ComplexSamples(i, q, timestamp);
         }
     }
 
@@ -143,6 +139,8 @@ public class SignedByteNativeBuffer implements INativeBuffer
         @Override
         public InterleavedComplexSamples next()
         {
+            long timestamp = getFragmentTimestamp(mSamplesPointer);
+
             float[] converted = new float[FRAGMENT_SIZE * 2];
 
             int samplesOffset = mSamplesPointer;
@@ -155,7 +153,7 @@ public class SignedByteNativeBuffer implements INativeBuffer
 
             mSamplesPointer = samplesOffset;
 
-            return new InterleavedComplexSamples(converted, mTimestamp);
+            return new InterleavedComplexSamples(converted, timestamp);
         }
     }
 }

src/main/java/io/github/dsheirer/buffer/SignedByteNativeBufferFactory.java

@@ -20,14 +20,51 @@
 package io.github.dsheirer.buffer;
 
 import java.nio.ByteBuffer;
+import java.util.concurrent.TimeUnit;
 
 /**
  * Implements a factory for creating SignedByteNativeBuffer instances
  */
-public class SignedByteNativeBufferFactory implements INativeBufferFactory
+public class SignedByteNativeBufferFactory extends AbstractNativeBufferFactory
 {
-    private static final float DC_FILTER_GAIN = 0.02f; //Normalizes DC over period of ~50 (1 / .02) buffers
+    /**
+     * DC removal calculations will run once a minute
+     */
+    private static final long DC_PROCESSING_INTERVAL = TimeUnit.SECONDS.toMillis(60);
+
+    /**
+     * Number of buffers to process per DC calculation processing interval.
+     */
+    private static final int DC_CALCULATIONS_PER_INTERVAL = 5;
+
+    /**
+     * DC offset processing residual threshold for ending DC processing interval
+      */
+    private static final float TARGET_DC_OFFSET_REMAINING = 0.0002f;
+
+    /**
+     * Number of DC calculations remaining in the current interval
+     */
+    private int mDcCalculationsRemaining = DC_CALCULATIONS_PER_INTERVAL; //Initial value for coarse correction
+
+    /**
+     * Last time DC offset calculation interval ran
+     */
+    private long mLastDcCalculationTimestamp = 0;
+
+    /**
+     * DC offset calculation gain.
+     */
+    private static final float DC_FILTER_GAIN = 0.05f;
+
+    /**
+     * Current DC offset correction for Inphase samples
+     */
     private float mIAverageDc = 0.0f;
+
+    /**
+     * Current DC offset correction for Quadrature samples
+     */
     private float mQAverageDc = 0.0f;
 
     @Override
@@ -35,8 +72,35 @@ public class SignedByteNativeBufferFactory implements INativeBufferFactory
     {
         byte[] copy = new byte[samples.capacity()];
         samples.get(copy);
-        calculateDc(copy);
-        return new SignedByteNativeBuffer(copy, timestamp, mIAverageDc, mQAverageDc);
+
+        if(shouldCalculateDc())
+        {
+            calculateDc(copy);
+        }
+
+        return new SignedByteNativeBuffer(copy, timestamp, mIAverageDc, mQAverageDc, getSamplesPerMillisecond());
+    }
+
+    /**
+     * Indicates if a DC offset calculation for a buffer should be performed.
+     */
+    private boolean shouldCalculateDc()
+    {
+        if(System.currentTimeMillis() > (mLastDcCalculationTimestamp + DC_PROCESSING_INTERVAL))
+        {
+            if(mDcCalculationsRemaining > 0)
+            {
+                return true;
+            }
+            else
+            {
+                //Reset the number of buffers to calculate and the timestamp
+                mDcCalculationsRemaining = DC_CALCULATIONS_PER_INTERVAL;
+                mLastDcCalculationTimestamp = System.currentTimeMillis();
+            }
+        }
+
+        return false;
     }
 
     /**
@@ -46,8 +110,8 @@ public class SignedByteNativeBufferFactory implements INativeBufferFactory
      */
     private void calculateDc(byte[] samples)
     {
-        double iDcAccumulator = 0;
-        double qDcAccumulator = 0;
+        float iDcAccumulator = 0;
+        float qDcAccumulator = 0;
 
         for(int x = 0; x < samples.length; x += 2)
         {
@@ -64,5 +128,10 @@ public class SignedByteNativeBufferFactory implements INativeBufferFactory
         qDcAccumulator /= 128.0f;
         qDcAccumulator -= mQAverageDc;
         mQAverageDc += (qDcAccumulator * DC_FILTER_GAIN);
+
+        if(Math.abs(iDcAccumulator) < TARGET_DC_OFFSET_REMAINING && Math.abs(qDcAccumulator) < TARGET_DC_OFFSET_REMAINING)
+        {
+            mDcCalculationsRemaining--;
+        }
     }
 }

src/main/java/io/github/dsheirer/buffer/airspy/AirspyBufferIterator.java

@@ -20,7 +20,6 @@
 package io.github.dsheirer.buffer.airspy;
 
 import io.github.dsheirer.dsp.filter.hilbert.HilbertTransform;
-
 import java.util.Iterator;
 
 /**
@@ -42,8 +41,9 @@ public abstract class AirspyBufferIterator<T> implements Iterator<T>
     protected float[] mQBuffer = new float[FRAGMENT_SIZE + Q_OVERLAP];
     protected short[] mSamples;
     protected int mSamplesPointer = 0;
-    protected long mTimestamp;
     protected float mAverageDc;
+    private long mTimestamp;
+    private float mSamplesPerMillisecond;
 
     /**
      * Constructs an instance
@@ -52,8 +52,10 @@ public abstract class AirspyBufferIterator<T> implements Iterator<T>
      * @param residualQ samples from previous buffer
      * @param averageDc as measured
      * @param timestamp of the buffer
+     * @param samplesPerMillisecond to calculate sub-buffer fragment timestamps
      */
-    public AirspyBufferIterator(short[] samples, short[] residualI, short[] residualQ, float averageDc, long timestamp)
+    public AirspyBufferIterator(short[] samples, short[] residualI, short[] residualQ, float averageDc, long timestamp,
+                                float samplesPerMillisecond)
     {
         if(residualI.length != I_OVERLAP || residualQ.length != Q_OVERLAP)
         {
@@ -73,6 +75,7 @@ public abstract class AirspyBufferIterator<T> implements Iterator<T>
         mAverageDc = averageDc;
         mSamples = samples;
         mTimestamp = timestamp;
+        mSamplesPerMillisecond = samplesPerMillisecond;
 
         //Transfer and scale the residual I & Q samples from the previous buffer
         for(int i = 0; i < residualI.length; i++)
@@ -86,6 +89,17 @@ public abstract class AirspyBufferIterator<T> implements Iterator<T>
         }
     }
 
+    /**
+     * Calculates the timestamp for a samples buffer fragment based on where it is extracted from relative to the
+     * native buffer starting timestamp.
+     * @param samplesPointer for the start of the fragment.  Note: this value will be divided by 2 to account for I/Q sample pairs.
+     * @return timestamp adjusted to the fragment or sub-buffer start sample.
+     */
+    protected long getFragmentTimestamp(int samplesPointer)
+    {
+        return mTimestamp + (long)(samplesPointer / 2 / mSamplesPerMillisecond);
+    }
+
     @Override
     public boolean hasNext()
     {

src/main/java/io/github/dsheirer/buffer/airspy/AirspyBufferIteratorScalar.java

@@ -20,7 +20,6 @@
 package io.github.dsheirer.buffer.airspy;
 
 import io.github.dsheirer.sample.complex.ComplexSamples;
-
 import java.util.Arrays;
 
 /**
@@ -36,10 +35,11 @@ public class AirspyBufferIteratorScalar extends AirspyBufferIterator<ComplexSamp
      * @param residualQ samples from last buffer
      * @param averageDc measured
      * @param timestamp of the buffer
+     * @param samplesPerMillisecond to calculate sub-buffer fragment timestamps
      */
-    public AirspyBufferIteratorScalar(short[] samples, short[] residualI, short[] residualQ, float averageDc, long timestamp)
+    public AirspyBufferIteratorScalar(short[] samples, short[] residualI, short[] residualQ, float averageDc, long timestamp, float samplesPerMillisecond)
     {
-        super(samples, residualI, residualQ, averageDc, timestamp);
+        super(samples, residualI, residualQ, averageDc, timestamp, samplesPerMillisecond);
     }
 
     @Override
@@ -50,6 +50,8 @@ public class AirspyBufferIteratorScalar extends AirspyBufferIterator<ComplexSamp
             throw new IllegalStateException("End of buffer exceeded");
         }
 
+        long timestamp = getFragmentTimestamp(mSamplesPointer);
+
         int offset = mSamplesPointer;
 
         for(int x = 0; x < FRAGMENT_SIZE; x++)
@@ -91,6 +93,6 @@ public class AirspyBufferIteratorScalar extends AirspyBufferIterator<ComplexSamp
         System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
         System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
 
-        return new ComplexSamples(i, q);
+        return new ComplexSamples(i, q, timestamp);
     }
 }

src/main/java/io/github/dsheirer/buffer/airspy/AirspyBufferIteratorVector128Bits.java

@@ -20,12 +20,11 @@
 package io.github.dsheirer.buffer.airspy;
 
 import io.github.dsheirer.sample.complex.ComplexSamples;
+import java.util.Arrays;
 import jdk.incubator.vector.FloatVector;
 import jdk.incubator.vector.VectorOperators;
 import jdk.incubator.vector.VectorSpecies;
 
-import java.util.Arrays;
-
 /**
  * Vector SIMD implementation for non-packed Airspy native buffers
  */
@@ -41,10 +40,12 @@ public class AirspyBufferIteratorVector128Bits extends AirspyBufferIterator<Comp
      * @param residualQ samples from last buffer
      * @param averageDc measured
      * @param timestamp of the buffer
+     * @param samplesPerMillisecond to calculate sub-buffer fragment timestamps
      */
-    public AirspyBufferIteratorVector128Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc, long timestamp)
+    public AirspyBufferIteratorVector128Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc,
+                                             long timestamp, float samplesPerMillisecond)
     {
-        super(samples, residualI, residualQ, averageDc, timestamp);
+        super(samples, residualI, residualQ, averageDc, timestamp, samplesPerMillisecond);
     }
 
     @Override
@@ -55,6 +56,7 @@ public class AirspyBufferIteratorVector128Bits extends AirspyBufferIterator<Comp
             throw new IllegalStateException("End of buffer exceeded");
         }
 
+        long timestamp = getFragmentTimestamp(mSamplesPointer);
         int offset = mSamplesPointer;
         int fragmentPointer = 0;
         float[] scaledSamples = new float[VECTOR_SPECIES.length()];
@@ -121,6 +123,6 @@ public class AirspyBufferIteratorVector128Bits extends AirspyBufferIterator<Comp
         System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
         System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
 
-        return new ComplexSamples(i, q);
+        return new ComplexSamples(i, q, timestamp);
     }
 }

src/main/java/io/github/dsheirer/buffer/airspy/AirspyBufferIteratorVector256Bits.java

@@ -20,12 +20,11 @@
 package io.github.dsheirer.buffer.airspy;
 
 import io.github.dsheirer.sample.complex.ComplexSamples;
+import java.util.Arrays;
 import jdk.incubator.vector.FloatVector;
 import jdk.incubator.vector.VectorOperators;
 import jdk.incubator.vector.VectorSpecies;
 
-import java.util.Arrays;
-
 /**
  * Vector SIMD implementation for non-packed Airspy native buffers
  */
@@ -41,10 +40,12 @@ public class AirspyBufferIteratorVector256Bits extends AirspyBufferIterator<Comp
      * @param residualQ samples from last buffer
      * @param averageDc measured
      * @param timestamp of the buffer
+     * @param samplesPerMillisecond to calculate sub-buffer fragment timestamps
      */
-    public AirspyBufferIteratorVector256Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc, long timestamp)
+    public AirspyBufferIteratorVector256Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc,
+                                             long timestamp, float samplesPerMillisecond)
     {
-        super(samples, residualI, residualQ, averageDc, timestamp);
+        super(samples, residualI, residualQ, averageDc, timestamp, samplesPerMillisecond);
     }
 
     @Override
@@ -55,6 +56,7 @@ public class AirspyBufferIteratorVector256Bits extends AirspyBufferIterator<Comp
             throw new IllegalStateException("End of buffer exceeded");
         }
 
+        long timestamp = getFragmentTimestamp(mSamplesPointer);
         int offset = mSamplesPointer;
         int fragmentPointer = 0;
         float[] scaledSamples = new float[VECTOR_SPECIES.length()];
@@ -115,6 +117,6 @@ public class AirspyBufferIteratorVector256Bits extends AirspyBufferIterator<Comp
         System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
         System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
 
-        return new ComplexSamples(i, q);
+        return new ComplexSamples(i, q, timestamp);
     }
 }

src/main/java/io/github/dsheirer/buffer/airspy/AirspyBufferIteratorVector512Bits.java

@@ -20,12 +20,11 @@
 package io.github.dsheirer.buffer.airspy;
 
 import io.github.dsheirer.sample.complex.ComplexSamples;
+import java.util.Arrays;
 import jdk.incubator.vector.FloatVector;
 import jdk.incubator.vector.VectorOperators;
 import jdk.incubator.vector.VectorSpecies;
 
-import java.util.Arrays;
-
 /**
  * Vector SIMD implementation for non-packed Airspy native buffers
  */
@@ -42,10 +41,12 @@ public class AirspyBufferIteratorVector512Bits extends AirspyBufferIterator<Comp
      * @param residualQ samples from last buffer
      * @param averageDc measured
      * @param timestamp of the buffer
+     * @param samplesPerMillisecond to calculate sub-buffer fragment timestamps
      */
-    public AirspyBufferIteratorVector512Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc, long timestamp)
+    public AirspyBufferIteratorVector512Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc,
+                                             long timestamp, float samplesPerMillisecond)
     {
-        super(samples, residualI, residualQ, averageDc, timestamp);
+        super(samples, residualI, residualQ, averageDc, timestamp, samplesPerMillisecond);
         //Arrange the last 8 taps of the filter into the higher indices of an array to align for SIMD
         mFilterPart2 = new float[16];
         System.arraycopy(COEFFICIENTS, 16, mFilterPart2, 8, 8);
@@ -59,6 +60,8 @@ public class AirspyBufferIteratorVector512Bits extends AirspyBufferIterator<Comp
             throw new IllegalStateException("End of buffer exceeded");
         }
 
+        long timestamp = getFragmentTimestamp(mSamplesPointer);
+
         int offset = mSamplesPointer;
         int fragmentPointer = 0;
         float[] scaledSamples = new float[VECTOR_SPECIES.length()];
@@ -117,6 +120,6 @@ public class AirspyBufferIteratorVector512Bits extends AirspyBufferIterator<Comp
         System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
         System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
 
-        return new ComplexSamples(i, q);
+        return new ComplexSamples(i, q, timestamp);
     }
 }

src/main/java/io/github/dsheirer/buffer/airspy/AirspyBufferIteratorVector64Bits.java

@@ -20,12 +20,11 @@
 package io.github.dsheirer.buffer.airspy;
 
 import io.github.dsheirer.sample.complex.ComplexSamples;
+import java.util.Arrays;
 import jdk.incubator.vector.FloatVector;
 import jdk.incubator.vector.VectorOperators;
 import jdk.incubator.vector.VectorSpecies;
 
-import java.util.Arrays;
-
 /**
  * Vector SIMD implementation for non-packed Airspy native buffers
  */
@@ -41,10 +40,12 @@ public class AirspyBufferIteratorVector64Bits extends AirspyBufferIterator<Compl
      * @param residualQ samples from last buffer
      * @param averageDc measured
      * @param timestamp of the buffer
+     * @param samplesPerMillisecond to calculate sub-buffer fragment timestamps
      */
-    public AirspyBufferIteratorVector64Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc, long timestamp)
+    public AirspyBufferIteratorVector64Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc,
+                                            long timestamp, float samplesPerMillisecond)
     {
-        super(samples, residualI, residualQ, averageDc, timestamp);
+        super(samples, residualI, residualQ, averageDc, timestamp, samplesPerMillisecond);
     }
 
     @Override
@@ -55,6 +56,8 @@ public class AirspyBufferIteratorVector64Bits extends AirspyBufferIterator<Compl
             throw new IllegalStateException("End of buffer exceeded");
         }
 
+        long timestamp = getFragmentTimestamp(mSamplesPointer);
+
         int offset = mSamplesPointer;
         int fragmentPointer = 0;
         float[] scaledSamples = new float[VECTOR_SPECIES.length()];
@@ -133,6 +136,6 @@ public class AirspyBufferIteratorVector64Bits extends AirspyBufferIterator<Compl
         System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
         System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
 
-        return new ComplexSamples(i, q);
+        return new ComplexSamples(i, q, timestamp);
     }
 }

src/main/java/io/github/dsheirer/buffer/airspy/AirspyInterleavedBufferIteratorScalar.java

@@ -34,11 +34,12 @@ public class AirspyInterleavedBufferIteratorScalar extends AirspyBufferIterator<
      * @param residualQ samples from last buffer
      * @param averageDc measured
      * @param timestamp of the buffer
+     * @param samplesPerMillisecond to calculate sub-buffer fragment timestamps
      */
     public AirspyInterleavedBufferIteratorScalar(short[] samples, short[] residualI, short[] residualQ, float averageDc,
-                                                 long timestamp)
+                                                 long timestamp, float samplesPerMillisecond)
     {
-        super(samples, residualI, residualQ, averageDc, timestamp);
+        super(samples, residualI, residualQ, averageDc, timestamp, samplesPerMillisecond);
     }
 
     @Override
@@ -49,6 +50,7 @@ public class AirspyInterleavedBufferIteratorScalar extends AirspyBufferIterator<
             throw new IllegalStateException("End of buffer exceeded");
         }
 
+        long timestamp = getFragmentTimestamp(mSamplesPointer);
         int offset = mSamplesPointer;
 
         for(int x = 0; x < FRAGMENT_SIZE; x++)
@@ -89,6 +91,6 @@ public class AirspyInterleavedBufferIteratorScalar extends AirspyBufferIterator<
         System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
         System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
 
-        return new InterleavedComplexSamples(samples, mTimestamp);
+        return new InterleavedComplexSamples(samples, timestamp);
     }
 }

src/main/java/io/github/dsheirer/buffer/airspy/AirspyInterleavedBufferIteratorVector128Bits.java

@@ -39,11 +39,12 @@ public class AirspyInterleavedBufferIteratorVector128Bits extends AirspyBufferIt
      * @param residualQ samples from last buffer
      * @param averageDc measured
      * @param timestamp of the buffer
+     * @param samplesPerMillisecond to calculate sub-buffer fragment timestamps
      */
     public AirspyInterleavedBufferIteratorVector128Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc,
-                                                        long timestamp)
+                                                        long timestamp, float samplesPerMillisecond)
     {
-        super(samples, residualI, residualQ, averageDc, timestamp);
+        super(samples, residualI, residualQ, averageDc, timestamp, samplesPerMillisecond);
     }
 
     @Override
@@ -54,6 +55,7 @@ public class AirspyInterleavedBufferIteratorVector128Bits extends AirspyBufferIt
             throw new IllegalStateException("End of buffer exceeded");
         }
 
+        long timestamp = getFragmentTimestamp(mSamplesPointer);
         int offset = mSamplesPointer;
         int fragmentPointer = 0;
         float[] scaledSamples = new float[VECTOR_SPECIES.length()];
@@ -118,6 +120,6 @@ public class AirspyInterleavedBufferIteratorVector128Bits extends AirspyBufferIt
         System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
         System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
 
-        return new InterleavedComplexSamples(samples, mTimestamp);
+        return new InterleavedComplexSamples(samples, timestamp);
     }
 }

src/main/java/io/github/dsheirer/buffer/airspy/AirspyInterleavedBufferIteratorVector256Bits.java

@@ -39,11 +39,12 @@ public class AirspyInterleavedBufferIteratorVector256Bits extends AirspyBufferIt
      * @param residualQ samples from last buffer
      * @param averageDc measured
      * @param timestamp of the buffer
+     * @param samplesPerMillisecond to calculate sub-buffer fragment timestamps
      */
     public AirspyInterleavedBufferIteratorVector256Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc,
-                                                        long timestamp)
+                                                        long timestamp, float samplesPerMillisecond)
     {
-        super(samples, residualI, residualQ, averageDc, timestamp);
+        super(samples, residualI, residualQ, averageDc, timestamp, samplesPerMillisecond);
     }
 
     @Override
@@ -54,6 +55,7 @@ public class AirspyInterleavedBufferIteratorVector256Bits extends AirspyBufferIt
             throw new IllegalStateException("End of buffer exceeded");
         }
 
+        long timestamp = getFragmentTimestamp(mSamplesPointer);
         int offset = mSamplesPointer;
         int fragmentPointer = 0;
         float[] scaledSamples = new float[VECTOR_SPECIES.length()];
@@ -112,6 +114,6 @@ public class AirspyInterleavedBufferIteratorVector256Bits extends AirspyBufferIt
         System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
         System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
 
-        return new InterleavedComplexSamples(samples, mTimestamp);
+        return new InterleavedComplexSamples(samples, timestamp);
     }
 }

src/main/java/io/github/dsheirer/buffer/airspy/AirspyInterleavedBufferIteratorVector512Bits.java

@@ -40,11 +40,12 @@ public class AirspyInterleavedBufferIteratorVector512Bits extends AirspyBufferIt
      * @param residualQ samples from last buffer
      * @param averageDc measured
      * @param timestamp of the buffer
+     * @param samplesPerMillisecond to calculate sub-buffer fragment timestamps
      */
     public AirspyInterleavedBufferIteratorVector512Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc,
-                                                        long timestamp)
+                                                        long timestamp, float samplesPerMillisecond)
     {
-        super(samples, residualI, residualQ, averageDc, timestamp);
+        super(samples, residualI, residualQ, averageDc, timestamp, samplesPerMillisecond);
 
         //Arrange the last 8 taps of the filter into the higher indices of an array to align for SIMD
         mFilterPart2 = new float[16];
@@ -59,6 +60,7 @@ public class AirspyInterleavedBufferIteratorVector512Bits extends AirspyBufferIt
             throw new IllegalStateException("End of buffer exceeded");
         }
 
+        long timestamp = getFragmentTimestamp(mSamplesPointer);
         int offset = mSamplesPointer;
         int fragmentPointer = 0;
         float[] scaledSamples = new float[VECTOR_SPECIES.length()];
@@ -115,6 +117,6 @@ public class AirspyInterleavedBufferIteratorVector512Bits extends AirspyBufferIt
         System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
         System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
 
-        return new InterleavedComplexSamples(samples, mTimestamp);
+        return new InterleavedComplexSamples(samples, timestamp);
     }
 }

src/main/java/io/github/dsheirer/buffer/airspy/AirspyInterleavedBufferIteratorVector64Bits.java

@@ -39,11 +39,12 @@ public class AirspyInterleavedBufferIteratorVector64Bits extends AirspyBufferIte
      * @param residualQ samples from last buffer
      * @param averageDc measured
      * @param timestamp of the buffer
+     * @param samplesPerMillisecond to calculate sub-buffer fragment timestamps
      */
     public AirspyInterleavedBufferIteratorVector64Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc,
-                                                       long timestamp)
+                                                       long timestamp, float samplesPerMillisecond)
     {
-        super(samples, residualI, residualQ, averageDc, timestamp);
+        super(samples, residualI, residualQ, averageDc, timestamp, samplesPerMillisecond);
     }
 
     @Override
@@ -54,6 +55,7 @@ public class AirspyInterleavedBufferIteratorVector64Bits extends AirspyBufferIte
             throw new IllegalStateException("End of buffer exceeded");
         }
 
+        long timestamp = getFragmentTimestamp(mSamplesPointer);
         int offset = mSamplesPointer;
         int fragmentPointer = 0;
         float[] scaledSamples = new float[VECTOR_SPECIES.length()];
@@ -130,6 +132,6 @@ public class AirspyInterleavedBufferIteratorVector64Bits extends AirspyBufferIte
         System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
         System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
 
-        return new InterleavedComplexSamples(samples, mTimestamp);
+        return new InterleavedComplexSamples(samples, timestamp);
     }
 }

src/main/java/io/github/dsheirer/buffer/airspy/AirspyNativeBuffer.java

@@ -19,23 +19,21 @@
 
 package io.github.dsheirer.buffer.airspy;
 
-import io.github.dsheirer.buffer.INativeBuffer;
+import io.github.dsheirer.buffer.AbstractNativeBuffer;
 import io.github.dsheirer.sample.complex.ComplexSamples;
 import io.github.dsheirer.sample.complex.InterleavedComplexSamples;
 import io.github.dsheirer.vector.calibrate.Implementation;
-
 import java.util.Iterator;
 
 /**
  * Native buffer scalar implementation for Airspy non-packed samples.
  */
-public class AirspyNativeBuffer implements INativeBuffer
+public class AirspyNativeBuffer extends AbstractNativeBuffer
 {
     private short[] mSamples;
     private short[] mResidualI;
     private short[] mResidualQ;
     private float mAverageDc;
-    private long mTimestamp;
     private Implementation mInterleavedImplementation;
     private Implementation mNonInterleavedImplementation;
 
@@ -48,11 +46,14 @@ public class AirspyNativeBuffer implements INativeBuffer
      * @param timestamp of the buffer
      * @param interleavedImplementation optimal, scalar vs vector SIMD
      * @param nonInterleavedImplementation optimal, scalar vs vector SIMD
+     * @param samplesPerMillisecond used to calculate sub-buffer fragment timestamp offsets from the start of this buffer.
      */
     public AirspyNativeBuffer(short[] samples, short[] residualI, short[] residualQ, float averageDc,
                               long timestamp, Implementation interleavedImplementation,
-                              Implementation nonInterleavedImplementation)
+                              Implementation nonInterleavedImplementation, float samplesPerMillisecond)
     {
+        super(timestamp, samplesPerMillisecond);
+
         //Ensure we're an even multiple of the fragment size.  Typically, this will be 64k or 128k
         if(samples.length % AirspyBufferIterator.FRAGMENT_SIZE != 0)
         {
@@ -64,7 +65,6 @@ public class AirspyNativeBuffer implements INativeBuffer
         mResidualI = residualI;
         mResidualQ = residualQ;
         mAverageDc = averageDc;
-        mTimestamp = timestamp;
         mInterleavedImplementation = interleavedImplementation;
         mNonInterleavedImplementation = nonInterleavedImplementation;
     }
@@ -75,22 +75,16 @@ public class AirspyNativeBuffer implements INativeBuffer
         return mSamples.length / 2;
     }
 
-    @Override
-    public long getTimestamp()
-    {
-        return mTimestamp;
-    }
-
     @Override
     public Iterator<ComplexSamples> iterator()
     {
         return switch(mInterleavedImplementation)
         {
-            case VECTOR_SIMD_512 -> new AirspyBufferIteratorVector512Bits(mSamples, mResidualI, mResidualQ, mAverageDc, mTimestamp);
-            case VECTOR_SIMD_256-> new AirspyBufferIteratorVector256Bits(mSamples, mResidualI, mResidualQ, mAverageDc, mTimestamp);
-            case VECTOR_SIMD_128-> new AirspyBufferIteratorVector128Bits(mSamples, mResidualI, mResidualQ, mAverageDc, mTimestamp);
-            case VECTOR_SIMD_64 ->new AirspyBufferIteratorVector64Bits(mSamples, mResidualI, mResidualQ, mAverageDc, mTimestamp);
-            default -> new AirspyBufferIteratorScalar(mSamples, mResidualI, mResidualQ, mAverageDc, mTimestamp);
+            case VECTOR_SIMD_512 -> new AirspyBufferIteratorVector512Bits(mSamples, mResidualI, mResidualQ, mAverageDc, getTimestamp(), getSamplesPerMillisecond());
+            case VECTOR_SIMD_256-> new AirspyBufferIteratorVector256Bits(mSamples, mResidualI, mResidualQ, mAverageDc, getTimestamp(), getSamplesPerMillisecond());
+            case VECTOR_SIMD_128-> new AirspyBufferIteratorVector128Bits(mSamples, mResidualI, mResidualQ, mAverageDc, getTimestamp(), getSamplesPerMillisecond());
+            case VECTOR_SIMD_64 ->new AirspyBufferIteratorVector64Bits(mSamples, mResidualI, mResidualQ, mAverageDc, getTimestamp(), getSamplesPerMillisecond());
+            default -> new AirspyBufferIteratorScalar(mSamples, mResidualI, mResidualQ, mAverageDc, getTimestamp(), getSamplesPerMillisecond());
         };
     }
 
@@ -99,11 +93,11 @@ public class AirspyNativeBuffer implements INativeBuffer
     {
         return switch(mInterleavedImplementation)
         {
-            case VECTOR_SIMD_512 -> new AirspyInterleavedBufferIteratorVector512Bits(mSamples, mResidualI, mResidualQ, mAverageDc, mTimestamp);
-            case VECTOR_SIMD_256-> new AirspyInterleavedBufferIteratorVector256Bits(mSamples, mResidualI, mResidualQ, mAverageDc, mTimestamp);
-            case VECTOR_SIMD_128-> new AirspyInterleavedBufferIteratorVector128Bits(mSamples, mResidualI, mResidualQ, mAverageDc, mTimestamp);
-            case VECTOR_SIMD_64 ->new AirspyInterleavedBufferIteratorVector64Bits(mSamples, mResidualI, mResidualQ, mAverageDc, mTimestamp);
-            default -> new AirspyInterleavedBufferIteratorScalar(mSamples, mResidualI, mResidualQ, mAverageDc, mTimestamp);
+            case VECTOR_SIMD_512 -> new AirspyInterleavedBufferIteratorVector512Bits(mSamples, mResidualI, mResidualQ, mAverageDc, getTimestamp(), getSamplesPerMillisecond());
+            case VECTOR_SIMD_256-> new AirspyInterleavedBufferIteratorVector256Bits(mSamples, mResidualI, mResidualQ, mAverageDc, getTimestamp(), getSamplesPerMillisecond());
+            case VECTOR_SIMD_128-> new AirspyInterleavedBufferIteratorVector128Bits(mSamples, mResidualI, mResidualQ, mAverageDc, getTimestamp(), getSamplesPerMillisecond());
+            case VECTOR_SIMD_64 ->new AirspyInterleavedBufferIteratorVector64Bits(mSamples, mResidualI, mResidualQ, mAverageDc, getTimestamp(), getSamplesPerMillisecond());
+            default -> new AirspyInterleavedBufferIteratorScalar(mSamples, mResidualI, mResidualQ, mAverageDc, getTimestamp(), getSamplesPerMillisecond());
         };
     }
 }

src/main/java/io/github/dsheirer/buffer/airspy/AirspyNativeBufferFactory.java

@@ -19,19 +19,18 @@
 
 package io.github.dsheirer.buffer.airspy;
 
+import io.github.dsheirer.buffer.AbstractNativeBufferFactory;
 import io.github.dsheirer.buffer.INativeBuffer;
-import io.github.dsheirer.buffer.INativeBufferFactory;
 import io.github.dsheirer.vector.calibrate.CalibrationManager;
 import io.github.dsheirer.vector.calibrate.CalibrationType;
 import io.github.dsheirer.vector.calibrate.Implementation;
-
 import java.nio.ByteBuffer;
 import java.util.Arrays;
 
 /**
  * Implements a factory for creating SignedByteNativeBuffer instances
  */
-public class AirspyNativeBufferFactory implements INativeBufferFactory
+public class AirspyNativeBufferFactory extends AbstractNativeBufferFactory
 {
     private boolean mSamplePacking = false;
     private short[] mResidualI = new short[AirspyBufferIterator.I_OVERLAP];
@@ -106,7 +105,7 @@ public class AirspyNativeBufferFactory implements INativeBufferFactory
         INativeBuffer nativeBuffer = new AirspyNativeBuffer(samples,
                 Arrays.copyOf(mResidualI, mResidualI.length),
                 Arrays.copyOf(mResidualQ, mResidualQ.length), mConverter.getAverageDc(), timestamp,
-                mInterleavedIteratorImplementation, mNonInterleavedIteratorImplementation);
+                mInterleavedIteratorImplementation, mNonInterleavedIteratorImplementation, getSamplesPerMillisecond());
 
         extractResidual(samples);
 

src/main/java/io/github/dsheirer/buffer/airspy/ScalarPackedSampleConverter.java

@@ -19,6 +19,7 @@
 
 package io.github.dsheirer.buffer.airspy;
 
+import io.github.dsheirer.buffer.DcCorrectionManager;
 import java.nio.ByteBuffer;
 
 /**
@@ -26,40 +27,61 @@ import java.nio.ByteBuffer;
  */
 public class ScalarPackedSampleConverter implements IAirspySampleConverter
 {
-    private static final float DC_FILTER_GAIN = 0.007f; //Normalizes DC over period of ~142 (1 / .007) buffers
-    private float mAverageDc = 0.0f;
+    /**
+     * Manages DC calculations and processing interval
+     */
+    private DcCorrectionManager mDcCalculationManager = new DcCorrectionManager();
 
     @Override
     public short[] convert(ByteBuffer buffer)
     {
+        boolean shouldCalculateDc = mDcCalculationManager.shouldCalculateDc();
+
         int offset = 0;
-        long dcAccumulator = 0;
         short sample;
         short[] samples;
         byte b1, b2, b3;
 
         samples = new short[buffer.capacity() / 3 * 2];
 
-        for(int x = 0; x < samples.length; x += 2)
+        if(shouldCalculateDc)
         {
-            b1 = buffer.get(offset++);
-            b2 = buffer.get(offset++);
-            b3 = buffer.get(offset++);
+            long dcAccumulator = 0;
 
-            sample = (short)(((b1 & 0xFF) << 4) | ((b2 & 0xF0) >> 4));
-            samples[x] = sample;
-            dcAccumulator += sample;
+            for(int x = 0; x < samples.length; x += 2)
+            {
+                b1 = buffer.get(offset++);
+                b2 = buffer.get(offset++);
+                b3 = buffer.get(offset++);
 
-            sample = (short)(((b2 & 0xF) << 8) | (b3 & 0xFF));
-            samples[x] = sample;
-            dcAccumulator += sample;
+                sample = (short)(((b1 & 0xFF) << 4) | ((b2 & 0xF0) >> 4));
+                samples[x] = sample;
+                dcAccumulator += sample;
+
+                sample = (short)(((b2 & 0xF) << 8) | (b3 & 0xFF));
+                samples[x] = sample;
+                dcAccumulator += sample;
+            }
+
+            float averageDcNow = ((float)dcAccumulator / (float)samples.length) - 2048.0f;
+            averageDcNow *= AirspyBufferIterator.SCALE_SIGNED_12_BIT_TO_FLOAT;
+            mDcCalculationManager.adjust(averageDcNow);
         }
+        else
+        {
+            for(int x = 0; x < samples.length; x += 2)
+            {
+                b1 = buffer.get(offset++);
+                b2 = buffer.get(offset++);
+                b3 = buffer.get(offset++);
 
-        //Calculate the average scaled DC offset so that it can be applied in the native buffer's converted samples
-        float averageDcNow = ((float)dcAccumulator / (float)samples.length) - 2048.0f;
-        averageDcNow *= AirspyBufferIterator.SCALE_SIGNED_12_BIT_TO_FLOAT;
-        averageDcNow -= mAverageDc;
-        mAverageDc += (averageDcNow * DC_FILTER_GAIN);
+                sample = (short)(((b1 & 0xFF) << 4) | ((b2 & 0xF0) >> 4));
+                samples[x] = sample;
+
+                sample = (short)(((b2 & 0xF) << 8) | (b3 & 0xFF));
+                samples[x] = sample;
+            }
+        }
 
         return samples;
     }
@@ -67,7 +89,7 @@ public class ScalarPackedSampleConverter implements IAirspySampleConverter
     @Override
     public float getAverageDc()
     {
-        return mAverageDc;
+        return mDcCalculationManager.getAverageDc();
     }
 
     public static void main(String[] args)

src/main/java/io/github/dsheirer/buffer/airspy/ScalarUnpackedSampleConverter.java

@@ -19,6 +19,7 @@
 
 package io.github.dsheirer.buffer.airspy;
 
+import io.github.dsheirer.buffer.DcCorrectionManager;
 import java.nio.ByteBuffer;
 
 /**
@@ -26,34 +27,50 @@ import java.nio.ByteBuffer;
  */
 public class ScalarUnpackedSampleConverter implements IAirspySampleConverter
 {
-    private static final float DC_FILTER_GAIN = 0.007f; //Normalizes DC over period of ~142 (1 / .007) buffers
-    private float mAverageDc = 0.0f;
+    /**
+     * Manages DC calculations and processing interval
+     */
+    private DcCorrectionManager mDcCalculationManager = new DcCorrectionManager();
 
     @Override
     public short[] convert(ByteBuffer buffer)
     {
+        boolean shouldCalculateDc = mDcCalculationManager.shouldCalculateDc();
+
         int offset = 0;
-        long dcAccumulator = 0;
         short sample;
         short[] samples;
         byte b1, b2;
 
         samples = new short[buffer.capacity() / 2];
 
-        for(int x = 0; x < samples.length; x++)
+        if(shouldCalculateDc)
         {
-            b1 = buffer.get(offset++);
-            b2 = buffer.get(offset++);
-            sample = (short)(((b2 & 0x0F) << 8) | (b1 & 0xFF));
-            samples[x] = sample;
-            dcAccumulator += sample;
-        }
+            long dcAccumulator = 0;
 
-        //Calculate the average scaled DC offset so that it can be applied in the native buffer's converted samples
-        float averageDcNow = ((float)dcAccumulator / (float)samples.length) - 2048.0f;
-        averageDcNow *= AirspyBufferIterator.SCALE_SIGNED_12_BIT_TO_FLOAT;
-        averageDcNow -= mAverageDc;
-        mAverageDc += (averageDcNow * DC_FILTER_GAIN);
+            for(int x = 0; x < samples.length; x++)
+            {
+                b1 = buffer.get(offset++);
+                b2 = buffer.get(offset++);
+                sample = (short)(((b2 & 0x0F) << 8) | (b1 & 0xFF));
+                samples[x] = sample;
+                dcAccumulator += sample;
+            }
+
+            float averageDcNow = ((float)dcAccumulator / (float)samples.length) - 2048.0f;
+            averageDcNow *= AirspyBufferIterator.SCALE_SIGNED_12_BIT_TO_FLOAT;
+            mDcCalculationManager.adjust(averageDcNow);
+        }
+        else
+        {
+            for(int x = 0; x < samples.length; x++)
+            {
+                b1 = buffer.get(offset++);
+                b2 = buffer.get(offset++);
+                sample = (short)(((b2 & 0x0F) << 8) | (b1 & 0xFF));
+                samples[x] = sample;
+            }
+        }
 
         return samples;
     }
@@ -61,6 +78,6 @@ public class ScalarUnpackedSampleConverter implements IAirspySampleConverter
     @Override
     public float getAverageDc()
     {
-        return mAverageDc;
+        return mDcCalculationManager.getAverageDc();
     }
 }

src/main/java/io/github/dsheirer/buffer/airspy/VectorUnpackedSampleConverter.java

@@ -19,25 +19,29 @@
 
 package io.github.dsheirer.buffer.airspy;
 
+import io.github.dsheirer.buffer.DcCorrectionManager;
+import java.nio.ByteBuffer;
 import jdk.incubator.vector.ShortVector;
 import jdk.incubator.vector.VectorOperators;
 import jdk.incubator.vector.VectorSpecies;
 
-import java.nio.ByteBuffer;
-
 /**
  * Scalar implementation of airspy sample converter for un-packed samples.
  */
 public class VectorUnpackedSampleConverter implements IAirspySampleConverter
 {
     private static final VectorSpecies<Short> VECTOR_SPECIES = ShortVector.SPECIES_PREFERRED;
-    private static final float DC_FILTER_GAIN = 0.007f; //Normalizes DC over period of ~142 (1 / .007) buffers
-    private float mAverageDc = 0.0f;
+
+    /**
+     * Manages DC calculations and processing interval
+     */
+    private DcCorrectionManager mDcCalculationManager = new DcCorrectionManager();
 
     @Override
     public short[] convert(ByteBuffer buffer)
     {
-        long dcAccumulator = 0;
+        boolean shouldCalculateDc = mDcCalculationManager.shouldCalculateDc();
+
         short sample;
         short[] samples;
         byte b1, b2;
@@ -53,44 +57,73 @@ public class VectorUnpackedSampleConverter implements IAirspySampleConverter
         short[] bytes1 = new short[VECTOR_SPECIES.length()];
         short[] bytes2 = new short[VECTOR_SPECIES.length()];
 
-        for(; samplesOffset < VECTOR_SPECIES.loopBound(samples.length); samplesOffset += VECTOR_SPECIES.length())
+        if(shouldCalculateDc)
         {
-            bytesOffset = 0;
+            long dcAccumulator = 0;
 
-            while(bytesOffset < VECTOR_SPECIES.length())
+            for(; samplesOffset < VECTOR_SPECIES.loopBound(samples.length); samplesOffset += VECTOR_SPECIES.length())
             {
-                bytes1[bytesOffset] = (short)(buffer.get(rawPointer++) & 0xFF);
-                bytes2[bytesOffset++] = (short)(buffer.get(rawPointer++) & 0x0F);
+                bytesOffset = 0;
+
+                while(bytesOffset < VECTOR_SPECIES.length())
+                {
+                    bytes1[bytesOffset] = (short)(buffer.get(rawPointer++) & 0xFF);
+                    bytes2[bytesOffset++] = (short)(buffer.get(rawPointer++) & 0x0F);
+                }
+
+                vector = ShortVector.fromArray(VECTOR_SPECIES, bytes1, 0)
+                        .or(ShortVector.fromArray(VECTOR_SPECIES, bytes2, 0).lanewise(VectorOperators.LSHL, 8));
+                dcAccumulator += vector.reduceLanes(VectorOperators.ADD);
+                vector.intoArray(samples, samplesOffset);
             }
 
-            vector = ShortVector.fromArray(VECTOR_SPECIES, bytes1, 0)
-                    .or(ShortVector.fromArray(VECTOR_SPECIES, bytes2, 0).lanewise(VectorOperators.LSHL, 8));
-            dcAccumulator += vector.reduceLanes(VectorOperators.ADD);
-            vector.intoArray(samples, samplesOffset);
-        }
+            for(; samplesOffset < samples.length; samplesOffset++)
+            {
+                b1 = buffer.get(rawPointer++);
+                b2 = buffer.get(rawPointer++);
 
-        for(; samplesOffset < samples.length; samplesOffset++)
+                sample = (short)(((b2 & 0x0F) << 8) | (b1 & 0xFF));
+                samples[samplesOffset] = sample;
+                dcAccumulator += sample;
+            }
+
+            float averageDcNow = ((float)dcAccumulator / (float)samples.length) - 2048.0f;
+            averageDcNow *= AirspyBufferIterator.SCALE_SIGNED_12_BIT_TO_FLOAT;
+            mDcCalculationManager.adjust(averageDcNow);
+        }
+        else
         {
-            b1 = buffer.get(rawPointer++);
-            b2 = buffer.get(rawPointer++);
+            for(; samplesOffset < VECTOR_SPECIES.loopBound(samples.length); samplesOffset += VECTOR_SPECIES.length())
+            {
+                bytesOffset = 0;
 
-            sample = (short)(((b2 & 0x0F) << 8) | (b1 & 0xFF));
-            samples[samplesOffset] = sample;
-            dcAccumulator += sample;
+                while(bytesOffset < VECTOR_SPECIES.length())
+                {
+                    bytes1[bytesOffset] = (short)(buffer.get(rawPointer++) & 0xFF);
+                    bytes2[bytesOffset++] = (short)(buffer.get(rawPointer++) & 0x0F);
+                }
+
+                vector = ShortVector.fromArray(VECTOR_SPECIES, bytes1, 0)
+                        .or(ShortVector.fromArray(VECTOR_SPECIES, bytes2, 0).lanewise(VectorOperators.LSHL, 8));
+                vector.intoArray(samples, samplesOffset);
+            }
+
+            for(; samplesOffset < samples.length; samplesOffset++)
+            {
+                b1 = buffer.get(rawPointer++);
+                b2 = buffer.get(rawPointer++);
+
+                sample = (short)(((b2 & 0x0F) << 8) | (b1 & 0xFF));
+                samples[samplesOffset] = sample;
+            }
         }
 
-        //Calculate the average scaled DC offset so that it can be applied in the native buffer's converted samples
-        float averageDcNow = ((float)dcAccumulator / (float)samples.length) - 2048.0f;
-        averageDcNow *= AirspyBufferIterator.SCALE_SIGNED_12_BIT_TO_FLOAT;
-        averageDcNow -= mAverageDc;
-        mAverageDc += (averageDcNow * DC_FILTER_GAIN);
-
         return samples;
     }
 
     @Override
     public float getAverageDc()
     {
-        return mAverageDc;
+        return mDcCalculationManager.getAverageDc();
     }
 }

src/main/java/io/github/dsheirer/channel/metadata/NowPlayingPanel.java

@@ -1,7 +1,6 @@
 /*
- * ******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2019 Dennis Sheirer
+ * *****************************************************************************
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,7 +14,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>
- * *****************************************************************************
+ * ****************************************************************************
  */
 package io.github.dsheirer.channel.metadata;
 
@@ -28,10 +27,11 @@ import io.github.dsheirer.module.decode.event.DecodeEventPanel;
 import io.github.dsheirer.module.decode.event.MessageActivityPanel;
 import io.github.dsheirer.playlist.PlaylistManager;
 import io.github.dsheirer.preference.UserPreferences;
+import io.github.dsheirer.settings.SettingsManager;
+import java.awt.Color;
 import net.miginfocom.swing.MigLayout;
 
 import javax.swing.JPanel;
-import java.awt.Color;
 
 public class NowPlayingPanel extends JPanel
 {
@@ -45,13 +45,14 @@ public class NowPlayingPanel extends JPanel
      * GUI panel that combines the currently decoding channels metadata table and viewers for channel details,
      * messages, events, and spectral view.
      */
-    public NowPlayingPanel(PlaylistManager playlistManager, IconModel iconModel, UserPreferences userPreferences)
+    public NowPlayingPanel(PlaylistManager playlistManager, IconModel iconModel, UserPreferences userPreferences,
+                           SettingsManager settingsManager)
     {
         mChannelDetailPanel = new ChannelDetailPanel(playlistManager.getChannelProcessingManager());
         mDecodeEventPanel = new DecodeEventPanel(iconModel, userPreferences, playlistManager.getAliasModel());
         mMessageActivityPanel = new MessageActivityPanel(userPreferences);
         mChannelMetadataPanel = new ChannelMetadataPanel(playlistManager, iconModel, userPreferences);
-        mChannelPowerPanel = new ChannelPowerPanel(playlistManager);
+        mChannelPowerPanel = new ChannelPowerPanel(playlistManager, settingsManager);
 
         init();
     }
@@ -68,6 +69,10 @@ public class NowPlayingPanel extends JPanel
         tabbedPane.setFont(this.getFont());
         tabbedPane.setForeground(Color.BLACK);
 
+        //Register state change listener to toggle visibility state for channel tab to turn-on/off FFT processing
+        tabbedPane.addChangeListener(e -> mChannelPowerPanel.setPanelVisible(tabbedPane.getSelectedIndex() == tabbedPane
+                .indexOfComponent(mChannelPowerPanel)));
+
         JideSplitPane splitPane = new JideSplitPane(JideSplitPane.VERTICAL_SPLIT);
         splitPane.setShowGripper(true);
         splitPane.add(mChannelMetadataPanel);

src/main/java/io/github/dsheirer/controller/ControllerPanel.java

@@ -1,6 +1,6 @@
 /*
  * *****************************************************************************
- * Copyright (C) 2014-2022 Dennis Sheirer
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -32,6 +32,8 @@ import io.github.dsheirer.preference.UserPreferences;
 import io.github.dsheirer.settings.SettingsManager;
 import io.github.dsheirer.source.tuner.manager.TunerManager;
 import io.github.dsheirer.source.tuner.ui.TunerViewPanel;
+import java.awt.Color;
+import java.awt.Dimension;
 import jiconfont.icons.font_awesome.FontAwesome;
 import jiconfont.swing.IconFontSwing;
 import net.miginfocom.swing.MigLayout;
@@ -41,8 +43,6 @@ import org.slf4j.LoggerFactory;
 import javax.swing.Icon;
 import javax.swing.JLabel;
 import javax.swing.JPanel;
-import java.awt.Color;
-import java.awt.Dimension;
 
 public class ControllerPanel extends JPanel
 {
@@ -63,7 +63,7 @@ public class ControllerPanel extends JPanel
     {
         mAudioPanel = new AudioPanel(iconModel, userPreferences, settingsManager, audioPlaybackManager,
             playlistManager.getAliasModel());
-        mNowPlayingPanel = new NowPlayingPanel(playlistManager, iconModel, userPreferences);
+        mNowPlayingPanel = new NowPlayingPanel(playlistManager, iconModel, userPreferences, settingsManager);
         mMapPanel = new MapPanel(mapService, playlistManager.getAliasModel(), iconModel, settingsManager);
         mTunerManagerPanel = new TunerViewPanel(tunerManager, userPreferences);
 

src/main/java/io/github/dsheirer/controller/channel/ChannelAutoStartFrame.java

@@ -1,7 +1,6 @@
 /*
- * ******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2018 Dennis Sheirer
+ * *****************************************************************************
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,22 +14,13 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>
- * *****************************************************************************
+ * ****************************************************************************
  */
 package io.github.dsheirer.controller.channel;
 
+import io.github.dsheirer.preference.UserPreferences;
 import io.github.dsheirer.sample.Listener;
 import io.github.dsheirer.util.ThreadPool;
-import net.miginfocom.swing.MigLayout;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import javax.swing.JButton;
-import javax.swing.JFrame;
-import javax.swing.JLabel;
-import javax.swing.JPanel;
-import javax.swing.JScrollPane;
-import javax.swing.JTable;
 import java.awt.Dimension;
 import java.awt.EventQueue;
 import java.awt.event.ActionEvent;
@@ -41,12 +31,21 @@ import java.util.List;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
+import net.miginfocom.swing.MigLayout;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
 
 public class ChannelAutoStartFrame extends JFrame
 {
     private final static Logger mLog = LoggerFactory.getLogger(ChannelAutoStartFrame.class);
 
-    private static final int COUNTDOWN_SECONDS = 10;
     private Listener<ChannelEvent> mChannelEventListener;
     private List<Channel> mChannels;
 
@@ -55,7 +54,7 @@ public class ChannelAutoStartFrame extends JFrame
     private JButton mCancelButton;
     private JTable mChannelTable;
     private AtomicBoolean mChannelsStarted = new AtomicBoolean();
-
+    private int mAutoStartTimeoutSeconds;
     private ScheduledFuture<?> mTimerFuture;
 
     /**
@@ -66,10 +65,12 @@ public class ChannelAutoStartFrame extends JFrame
      * @param listener to receive channel start/enable request(s)
      * @param channels to auto-start
      */
-    public ChannelAutoStartFrame(Listener<ChannelEvent> listener, List<Channel> channels)
+    public ChannelAutoStartFrame(Listener<ChannelEvent> listener, List<Channel> channels, UserPreferences userPreferences)
     {
         mChannelEventListener = listener;
         mChannels = channels;
+        mAutoStartTimeoutSeconds = userPreferences.getApplicationPreference().getChannelAutoStartTimeout();
+
         init();
 
         EventQueue.invokeLater(() -> {
@@ -100,7 +101,7 @@ public class ChannelAutoStartFrame extends JFrame
             "[][][grow,fill][]"));
         panel.add(new JLabel("The following channels will be automatically"), "span");
 
-        mCountdownLabel = new JLabel(getCountdownText(COUNTDOWN_SECONDS));
+        mCountdownLabel = new JLabel(getCountdownText(mAutoStartTimeoutSeconds));
         panel.add(mCountdownLabel, "span");
 
         panel.add(new JScrollPane(getChannelTable()), "span");
@@ -220,7 +221,7 @@ public class ChannelAutoStartFrame extends JFrame
      */
     public class CountdownTimer implements Runnable
     {
-        private int mCount = COUNTDOWN_SECONDS;
+        private int mCount = mAutoStartTimeoutSeconds;
 
         @Override
         public void run()

src/main/java/io/github/dsheirer/controller/channel/ChannelProcessingManager.java

@@ -1,6 +1,6 @@
 /*
  * *****************************************************************************
- * Copyright (C) 2014-2022 Dennis Sheirer
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -623,30 +623,27 @@ public class ChannelProcessingManager implements Listener<ChannelEvent>
                 Platform.runLater(() -> channel.setProcessing(false));
             }
 
-            //Since the processing chain's source will block on stop(), throw it to the thread pool to run
-            ThreadPool.CACHED.submit(() -> {
-                try
-                {
-                    processingChain.stop();
-                    processingChain.removeEventLoggingModules();
-                    processingChain.removeRecordingModules();
+            try
+            {
+                processingChain.stop();
+                processingChain.removeEventLoggingModules();
+                processingChain.removeRecordingModules();
 
-                    //Deregister channel from receive frequency correction events to show in the spectral display (hack!)
-                    processingChain.removeFrequencyChangeListener(channel);
-                    channel.resetFrequencyCorrection();
+                //Deregister channel from receive frequency correction events to show in the spectral display (hack!)
+                processingChain.removeFrequencyChangeListener(channel);
+                channel.resetFrequencyCorrection();
 
-                    mChannelEventBroadcaster.broadcast(new ChannelEvent(channel, ChannelEvent.Event.NOTIFICATION_PROCESSING_STOP));
-                    mChannelEventBroadcaster.removeListener(processingChain);
+                mChannelEventBroadcaster.broadcast(new ChannelEvent(channel, ChannelEvent.Event.NOTIFICATION_PROCESSING_STOP));
+                mChannelEventBroadcaster.removeListener(processingChain);
 
-                    //Unregister for event bus requests and notifications
-                    processingChain.getEventBus().unregister(ChannelProcessingManager.this);
-                    processingChain.dispose();
-                }
-                catch(Exception e)
-                {
-                    mLog.error("Error during shutdown of processing chain for channel [" + channel.getName() + "}", e);
-                }
-            });
+                //Unregister for event bus requests and notifications
+                processingChain.getEventBus().unregister(ChannelProcessingManager.this);
+                processingChain.dispose();
+            }
+            catch(Exception e)
+            {
+                mLog.error("Error during shutdown of processing chain for channel [" + channel.getName() + "}", e);
+            }
         }
     }
 

src/main/java/io/github/dsheirer/controller/channel/ChannelSelectionManager.java

@@ -1,7 +1,6 @@
 /*
- * ******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2018 Dennis Sheirer
+ * *****************************************************************************
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,7 +14,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>
- * *****************************************************************************
+ * ****************************************************************************
  */
 package io.github.dsheirer.controller.channel;
 
@@ -33,7 +32,7 @@ public class ChannelSelectionManager implements Listener<ChannelEvent>
     public ChannelSelectionManager(ChannelModel channelModel)
     {
         mChannelEventListener = channelModel;
-        channelModel.addListener(this::receive);
+        channelModel.addListener(ChannelSelectionManager.this);
     }
 
     @Override

src/main/java/io/github/dsheirer/dsp/filter/channelizer/AbstractComplexPolyphaseChannelizer.java

@@ -1,6 +1,6 @@
 /*
  * *****************************************************************************
- * Copyright (C) 2014-2022 Dennis Sheirer
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,11 +23,10 @@ import io.github.dsheirer.sample.Listener;
 import io.github.dsheirer.sample.complex.InterleavedComplexSamples;
 import io.github.dsheirer.source.ISourceEventListener;
 import io.github.dsheirer.source.SourceEvent;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public abstract class AbstractComplexPolyphaseChannelizer implements Listener<InterleavedComplexSamples>, ISourceEventListener
 {
@@ -38,6 +37,7 @@ public abstract class AbstractComplexPolyphaseChannelizer implements Listener<In
     private int mChannelCount;
     private int mSubChannelCount;
     private double mChannelSampleRate;
+    protected long mCurrentSamplesTimestamp;
 
     /**
      * Complex sample polyphase channelizer
@@ -106,7 +106,7 @@ public abstract class AbstractComplexPolyphaseChannelizer implements Listener<In
     {
         for(PolyphaseChannelSource channel : mChannels)
         {
-            channel.receiveChannelResults(channelResultsList);
+            channel.receiveChannelResults(channelResultsList, mCurrentSamplesTimestamp);
         }
     }
 
@@ -122,6 +122,11 @@ public abstract class AbstractComplexPolyphaseChannelizer implements Listener<In
             mChannels.add(polyphaseChannelSource);
             mSourceChangeBroadcaster.addListener(polyphaseChannelSource.getSourceEventListener());
         }
+        else
+        {
+            mLog.error("Error adding polyphase channel source - " + (polyphaseChannelSource == null ? "source is null" :
+                    "channel source is already added to this channelizer"));
+        }
     }
 
     /**
@@ -136,6 +141,11 @@ public abstract class AbstractComplexPolyphaseChannelizer implements Listener<In
             mChannels.remove(polyphaseChannelSource);
             mSourceChangeBroadcaster.removeListener(polyphaseChannelSource.getSourceEventListener());
         }
+        else
+        {
+            mLog.error("Error removing polyphase channel source - " + (polyphaseChannelSource == null ? "source is null" :
+                    "channel source was not previously added to this channelizer"));
+        }
     }
 
     /**

src/main/java/io/github/dsheirer/dsp/filter/channelizer/ChannelCalculator.java

@@ -1,31 +1,34 @@
-/*******************************************************************************
- * *********************************************************************************************************************
- * sdr-trunk
- * Copyright (C) 2014-2017 Dennis Sheirer
+/*
+ * *****************************************************************************
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
- * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public
- * License as published by  the Free Software Foundation, either version 3 of the License, or  (at your option) any
- * later version.
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- * This program is distributed in the hope that it will be useful,  but WITHOUT ANY WARRANTY; without even the implied
- * warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License  along with this program.
- * If not, see <http://www.gnu.org/licenses/>
- * *********************************************************************************************************************
- ******************************************************************************/
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * ****************************************************************************
+ */
 package io.github.dsheirer.dsp.filter.channelizer;
 
 import io.github.dsheirer.source.tuner.channel.TunerChannel;
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.List;
 import org.apache.commons.math3.util.FastMath;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.ArrayList;
-import java.util.List;
-
 public class ChannelCalculator
 {
+    private static final DecimalFormat FREQUENCY_FORMAT = new DecimalFormat("0.00000");
     private final static Logger mLog = LoggerFactory.getLogger(ChannelCalculator.class);
 
     /**
@@ -546,13 +549,13 @@ public class ChannelCalculator
     public String toString()
     {
         StringBuilder sb = new StringBuilder();
-        sb.append("Channel Calculator Settings");
-        sb.append(" Channels:").append(getChannelCount());
-        sb.append(" Sample Rate:").append(getSampleRate());
-        sb.append(" Channel Bandwidth:").append(getChannelBandwidth());
-        sb.append(" Channel Rate:").append(getChannelSampleRate());
-        sb.append(" Min:").append(getMinimumFrequency());
-        sb.append(" Max:").append(getMaximumFrequency());
+        sb.append("Channel Calculator | Tuner SR:").append(FREQUENCY_FORMAT.format(getSampleRate() / 1E6D));
+        sb.append(" CF:").append(FREQUENCY_FORMAT.format(getCenterFrequency() / 1E6D));
+        sb.append(" MIN:").append(FREQUENCY_FORMAT.format(getMinimumFrequency() / 1E6D));
+        sb.append(" MAX:").append(FREQUENCY_FORMAT.format(getMaximumFrequency() / 1E6D));
+        sb.append(" | Channel COUNT:").append(getChannelCount());
+        sb.append(" BW:").append(FREQUENCY_FORMAT.format(getChannelBandwidth() / 1E6D));
+        sb.append(" SR:").append(FREQUENCY_FORMAT.format(getChannelSampleRate() / 1E6D));
         return sb.toString();
     }
 }

src/main/java/io/github/dsheirer/dsp/filter/channelizer/ComplexPolyphaseChannelizerM2.java

@@ -1,6 +1,6 @@
 /*
  * *****************************************************************************
- * Copyright (C) 2014-2022 Dennis Sheirer
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,16 +22,14 @@ import io.github.dsheirer.dsp.filter.FilterFactory;
 import io.github.dsheirer.dsp.filter.design.FilterDesignException;
 import io.github.dsheirer.sample.complex.InterleavedComplexSamples;
 import io.github.dsheirer.util.Dispatcher;
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.List;
 import org.apache.commons.math3.util.FastMath;
 import org.jtransforms.fft.FloatFFT_1D;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.text.DecimalFormat;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
 /**
  * Non-Maximally Decimated Polyphase Filter Bank (NMDPFB) channelizer that divides the input baseband complex sample
  * stream into equal bandwidth channels that are each oversampled by 2x for output.
@@ -70,8 +68,8 @@ public class ComplexPolyphaseChannelizerM2 extends AbstractComplexPolyphaseChann
      */
     private static final int PROCESSED_CHANNEL_RESULTS_THRESHOLD = 1024;
 
-    //Sized at 152 buffers a second where max = 5 seconds
-    private IFFTProcessorDispatcher mIFFTProcessorDispatcher = new IFFTProcessorDispatcher(5 * 152);
+    //Sized to process 1/20th batch of 152 buffers a second,  at 40 times per second
+    private IFFTProcessorDispatcher mIFFTProcessorDispatcher = new IFFTProcessorDispatcher(152 / 20, 25);
     private FloatFFT_1D mFFT;
     private float[] mInlineSamples;
     private float[] mInlineFilter;
@@ -193,7 +191,8 @@ public class ComplexPolyphaseChannelizerM2 extends AbstractComplexPolyphaseChann
     @Override
     public void receive(InterleavedComplexSamples complexSamples)
     {
-//TODO: how do we pass the timestamp onto the sample assemblers?
+        mCurrentSamplesTimestamp = complexSamples.timestamp();
+
         float[] samples = complexSamples.samples();
 
         int samplesPointer = 0;
@@ -407,25 +406,32 @@ public class ComplexPolyphaseChannelizerM2 extends AbstractComplexPolyphaseChann
      */
     public class IFFTProcessorDispatcher extends Dispatcher<List<float[]>>
     {
-        public IFFTProcessorDispatcher(int maximumSize)
+        public IFFTProcessorDispatcher(int batchSize, long interval)
         {
-            super(maximumSize, "sdrtrunk polyphase ifft processor", Collections.emptyList());
+            super("sdrtrunk polyphase ifft processor", batchSize, interval);
 
             //We create a listener interface to receive the batched channel results arrays from the scheduled thread pool
             //dispatcher thread that is part of this continuous buffer processor.  We perform an IFFT on each
             //channel results array contained in each results buffer and then dispatch the buffer
             //so that it can be distributed to each channel listener.
             setListener(list -> {
-                List<float[]> processedChannelResults = new ArrayList<>();
-
-                for(float[] channelResults: list)
+                try
                 {
-                    //Rotate each of the channels to the correct phase using the IFFT
-                    mFFT.complexInverse(channelResults, true);
-                    processedChannelResults.add(channelResults);
-                }
+                    List<float[]> processedChannelResults = new ArrayList<>();
 
-                dispatch(processedChannelResults);
+                    for(float[] channelResults: list)
+                    {
+                        //Rotate each of the channels to the correct phase using the IFFT
+                        mFFT.complexInverse(channelResults, true);
+                        processedChannelResults.add(channelResults);
+                    }
+
+                    dispatch(processedChannelResults);
+                }
+                catch(Throwable t)
+                {
+                    mLog.error("Error during IFFT and dispatch of processed channel results", t);
+                }
             });
         }
     }

src/main/java/io/github/dsheirer/dsp/filter/channelizer/PolyphaseChannelManager.java

@@ -1,6 +1,6 @@
 /*
  * *****************************************************************************
- * Copyright (C) 2014-2022 Dennis Sheirer
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,34 +20,27 @@ package io.github.dsheirer.dsp.filter.channelizer;
 
 import io.github.dsheirer.buffer.INativeBuffer;
 import io.github.dsheirer.buffer.INativeBufferProvider;
-import io.github.dsheirer.buffer.NativeBufferPoisonPill;
 import io.github.dsheirer.controller.channel.event.ChannelStopProcessingRequest;
-import io.github.dsheirer.dsp.filter.FilterFactory;
-import io.github.dsheirer.dsp.filter.channelizer.output.IPolyphaseChannelOutputProcessor;
-import io.github.dsheirer.dsp.filter.channelizer.output.OneChannelOutputProcessor;
-import io.github.dsheirer.dsp.filter.channelizer.output.TwoChannelOutputProcessor;
 import io.github.dsheirer.dsp.filter.design.FilterDesignException;
 import io.github.dsheirer.eventbus.MyEventBus;
 import io.github.dsheirer.sample.Broadcaster;
 import io.github.dsheirer.sample.Listener;
 import io.github.dsheirer.sample.complex.InterleavedComplexSamples;
 import io.github.dsheirer.source.ISourceEventProcessor;
-import io.github.dsheirer.source.Source;
 import io.github.dsheirer.source.SourceEvent;
 import io.github.dsheirer.source.SourceException;
 import io.github.dsheirer.source.tuner.TunerController;
 import io.github.dsheirer.source.tuner.channel.TunerChannel;
 import io.github.dsheirer.source.tuner.channel.TunerChannelSource;
 import io.github.dsheirer.util.Dispatcher;
+import java.text.DecimalFormat;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.Queue;
 import java.util.SortedSet;
 import java.util.TreeSet;
-import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.CopyOnWriteArrayList;
 import org.apache.commons.math3.util.FastMath;
 import org.slf4j.Logger;
@@ -71,16 +64,17 @@ import org.slf4j.LoggerFactory;
  */
 public class PolyphaseChannelManager implements ISourceEventProcessor
 {
+    private static final DecimalFormat FREQUENCY_FORMAT = new DecimalFormat("0.00000");
     private final static Logger mLog = LoggerFactory.getLogger(PolyphaseChannelManager.class);
     private static final double MINIMUM_CHANNEL_BANDWIDTH = 25000.0;
     private static final double CHANNEL_OVERSAMPLING = 2.0;
     private static final int POLYPHASE_CHANNELIZER_TAPS_PER_CHANNEL = 9;
-    private static final int POLYPHASE_SYNTHESIZER_TAPS_PER_CHANNEL = 9;
 
     private Broadcaster<SourceEvent> mSourceEventBroadcaster = new Broadcaster<>();
     private INativeBufferProvider mNativeBufferProvider;
     private List<PolyphaseChannelSource> mChannelSources = new CopyOnWriteArrayList<>();
     private ChannelCalculator mChannelCalculator;
+    private SynthesisFilterManager mFilterManager = new SynthesisFilterManager();
     private ComplexPolyphaseChannelizerM2 mPolyphaseChannelizer;
     private ChannelSourceEventListener mChannelSourceEventListener = new ChannelSourceEventListener();
     private NativeBufferReceiver mNativeBufferReceiver = new NativeBufferReceiver();
@@ -114,8 +108,7 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
         }
 
         mChannelCalculator = new ChannelCalculator(sampleRate, channelCount, frequency, CHANNEL_OVERSAMPLING);
-        mBufferDispatcher = new Dispatcher(500, "sdrtrunk polyphase buffer processor",
-                new NativeBufferPoisonPill());
+        mBufferDispatcher = new Dispatcher("sdrtrunk polyphase buffer processor", 50, 10);
         mBufferDispatcher.setListener(mNativeBufferReceiver);
     }
 
@@ -129,6 +122,34 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
         this(tunerController, tunerController.getFrequency(), tunerController.getSampleRate());
     }
 
+    /**
+     * Provides a description of the state of this manager.
+     */
+    public String getStateDescription()
+    {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Polyphase Channel Manager Providing [").append(mChannelSources.size()).append("] Channels");
+        sb.append("\n\t").append(mChannelCalculator);
+        for(PolyphaseChannelSource pcs: mChannelSources)
+        {
+            List<Integer> indexes = pcs.getOutputProcessorIndexes();
+            double sampleRate = pcs.getSampleRate();
+            long indexCenterFrequency = pcs.getIndexCenterFrequency();
+            long appliedFrequencyOffset = pcs.getFrequencyOffset();
+            long requestedCenterFrequency = pcs.getFrequency();
+
+            sb.append("\n\tPolyphase | Tuner SR:").append(FREQUENCY_FORMAT.format(pcs.getTunerSampleRate() / 1E6d));
+            sb.append(" CF:").append(FREQUENCY_FORMAT.format(pcs.getTunerCenterFrequency() / 1E6d));
+            sb.append(" BW: ").append(FREQUENCY_FORMAT.format(sampleRate / 1E6d));
+            sb.append(" | Channel CF: ").append(FREQUENCY_FORMAT.format(indexCenterFrequency / 1E6d));
+            sb.append(" REQUESTED CF: ").append(FREQUENCY_FORMAT.format(requestedCenterFrequency / 1E6d));
+            sb.append(" MIXER:").append(FREQUENCY_FORMAT.format(appliedFrequencyOffset / 1E6d));
+            sb.append(" | Polyphase Indices: ").append(indexes);
+        }
+
+        return sb.toString();
+    }
+
     public void stopAllChannels()
     {
         mRunning = false;
@@ -153,14 +174,6 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
         }
     }
 
-    /**
-     * Current channel sample rate which is (2 * channel bandwidth).
-     */
-    public double getChannelSampleRate()
-    {
-        return mChannelCalculator.getChannelSampleRate();
-    }
-
     /**
      * Current channel bandwidth/spacing.
      */
@@ -181,63 +194,22 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
 
         if(mRunning)
         {
-            List<Integer> polyphaseIndexes = mChannelCalculator.getChannelIndexes(tunerChannel);
-
-            IPolyphaseChannelOutputProcessor outputProcessor = getOutputProcessor(polyphaseIndexes);
-
-            if(outputProcessor != null)
+            try
             {
-                long centerFrequency = mChannelCalculator.getCenterFrequencyForIndexes(polyphaseIndexes);
+                channelSource = new PolyphaseChannelSource(tunerChannel, mChannelCalculator, mFilterManager,
+                        mChannelSourceEventListener);
 
-                try
-                {
-                    channelSource = new PolyphaseChannelSource(tunerChannel, outputProcessor, mChannelSourceEventListener,
-                            mChannelCalculator.getChannelSampleRate(), centerFrequency);
-
-                    mChannelSources.add(channelSource);
-                }
-                catch(FilterDesignException fde)
-                {
-                    mLog.debug("Couldn't design final output low pass filter for polyphase channel source");
-                }
+                mChannelSources.add(channelSource);
+            }
+            catch(IllegalArgumentException iae)
+            {
+                mLog.debug("Couldn't design final output low pass filter for polyphase channel source");
             }
         }
 
         return channelSource;
     }
 
-    /**
-     * Creates a processor to process the channelizer channel indexes into a composite output stream providing
-     * channelized complex sample buffers to a registered source listener.
-     * @param indexes to target by the output processor
-     * @return output processor compatible with the number of indexes to monitor
-     */
-    private IPolyphaseChannelOutputProcessor getOutputProcessor(List<Integer> indexes)
-    {
-        switch(indexes.size())
-        {
-            case 1:
-                return new OneChannelOutputProcessor(mChannelCalculator.getChannelSampleRate(), indexes,
-                    mChannelCalculator.getChannelCount());
-            case 2:
-                try
-                {
-                    float[] filter = getOutputProcessorFilter(2);
-                    return new TwoChannelOutputProcessor(mChannelCalculator.getChannelSampleRate(), indexes, filter,
-                        mChannelCalculator.getChannelCount());
-                }
-                catch(FilterDesignException fde)
-                {
-                    mLog.error("Error designing 2 channel synthesis filter for output processor");
-                }
-            default:
-                //TODO: create output processor for greater than 2 input channels
-                mLog.error("Request to create an output processor for unexpected channel index size:" + indexes.size());
-                mLog.info(mChannelCalculator.toString());
-                return null;
-        }
-    }
-
     /**
      * Starts/adds the channel source to receive channelized sample buffers, registering with the tuner to receive
      * sample buffers when this is the first channel.
@@ -249,7 +221,6 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
         synchronized(mBufferDispatcher)
         {
             //Note: the polyphase channel source has already been added to the mChannelSources in getChannel() method
-
             checkChannelizerConfiguration();
 
             mPolyphaseChannelizer.addChannel(channelSource);
@@ -311,10 +282,6 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
         switch(sourceEvent.getEvent())
         {
             case NOTIFICATION_FREQUENCY_CHANGE:
-                //Update channel calculator immediately so that channels can be allocated
-                mChannelCalculator.setCenterFrequency(sourceEvent.getValue().longValue());
-
-                //Defer channelizer configuration changes to be handled on the buffer processor thread
                 mNativeBufferReceiver.receive(sourceEvent);
                 break;
             case NOTIFICATION_SAMPLE_RATE_CHANGE:
@@ -330,7 +297,7 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
                 //no-op
                 break;
             default:
-                mLog.info("Unrecognized source event: " + sourceEvent.toString());
+                mLog.info("Unrecognized source event: " + sourceEvent);
                 break;
         }
     }
@@ -381,79 +348,21 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
      * Updates each of the output processors for any changes in the tuner's center frequency or sample rate, which
      * would cause the output processors to change the polyphase channelizer results channel(s) that the processor is
      * consuming
-     *
-     * @param sourceEvent (optional-can be null) to broadcast to each output processor following the update
      */
-    private void updateOutputProcessors(SourceEvent sourceEvent)
+    private void updateOutputProcessors()
     {
         for(PolyphaseChannelSource channelSource: mChannelSources)
         {
-            updateOutputProcessor(channelSource);
-
-            //Send the non-null source event to each channel source
-            if(sourceEvent != null)
+            try
             {
-                try
-                {
-                    channelSource.process(sourceEvent);
-                }
-                catch(SourceException se)
-                {
-                    mLog.error("Error while notifying polyphase channel source of a source event", se);
-                }
+                channelSource.updateOutputProcessor(mChannelCalculator, mFilterManager);
             }
-        }
-    }
-
-    /**
-     * Updates the polyphase channel source's output processor due to a change in the center frequency or sample
-     * rate for the source providing sample buffers to the polyphase channelizer, or whenever the DDC channel's
-     * center tuned frequency changes.
-     *
-     * @param channelSource that requires an update to its output processor
-     */
-    private void updateOutputProcessor(PolyphaseChannelSource channelSource)
-    {
-        try
-        {
-            //If a change in sample rate or center frequency makes this channel no longer viable, then the channel
-            //calculator will throw an IllegalArgException ... handled below
-            List<Integer> indexes = mChannelCalculator.getChannelIndexes(channelSource.getTunerChannel());
-
-            long centerFrequency = mChannelCalculator.getCenterFrequencyForIndexes(indexes);
-
-            //If the indexes size is the same then update the current processor, otherwise create a new one
-            IPolyphaseChannelOutputProcessor outputProcessor = channelSource.getPolyphaseChannelOutputProcessor();
-
-            if(outputProcessor != null && outputProcessor.getInputChannelCount() == indexes.size())
+            catch(IllegalArgumentException iae)
             {
-                channelSource.getPolyphaseChannelOutputProcessor().setPolyphaseChannelIndices(indexes);
-                channelSource.setFrequency(centerFrequency);
-
-                if(indexes.size() > 1)
-                {
-                    try
-                    {
-                        float[] filter = getOutputProcessorFilter(indexes.size());
-                        channelSource.getPolyphaseChannelOutputProcessor().setSynthesisFilter(filter);
-                    }
-                    catch(FilterDesignException fde)
-                    {
-                        mLog.error("Error creating an updated synthesis filter for the channel output processor");
-                    }
-                }
+                mLog.error("Error updating polyphase channel source output processor following tuner frequency or " +
+                        "sample rate change");
+                stopChannelSource(channelSource);
             }
-            else
-            {
-                channelSource.setPolyphaseChannelOutputProcessor(getOutputProcessor(indexes), centerFrequency);
-            }
-        }
-        catch(IllegalArgumentException iae)
-        {
-            mLog.error("Error updating polyphase channel source - can't determine output channel indexes for " +
-                "updated tuner center frequency and sample rate.  Stopping channel source", iae);
-
-            stopChannelSource(channelSource);
         }
     }
 
@@ -497,29 +406,6 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
         mSourceEventBroadcaster.removeListener(listener);
     }
 
-    /**
-     * Generates (or reuses) an output processor filter for the specified number of channels.  Each
-     * filter is created only once and stored in a map for reuse.  This map is cleared anytime that the
-     * input sample rate changes, so that the filters can be recreated with the new channel sample rate.
-     * @param channels count
-     * @return filter
-     * @throws FilterDesignException if the filter cannot be designed to specification (-6 dB band edge)
-     */
-    private float[] getOutputProcessorFilter(int channels) throws FilterDesignException
-    {
-        float[] taps = mOutputProcessorFilters.get(channels);
-
-        if(taps == null)
-        {
-            taps = FilterFactory.getSincM2Synthesizer(mChannelCalculator.getChannelSampleRate(),
-                mChannelCalculator.getChannelBandwidth(), channels, POLYPHASE_SYNTHESIZER_TAPS_PER_CHANNEL);
-
-            mOutputProcessorFilters.put(channels, taps);
-        }
-
-        return taps;
-    }
-
     /**
      * Internal class for handling requests for start/stop sample stream from polyphase channel sources
      */
@@ -542,9 +428,10 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
                     }
                     break;
                 case REQUEST_STOP_SAMPLE_STREAM:
-                    if(sourceEvent.hasSource() && sourceEvent.getSource() instanceof PolyphaseChannelSource)
+                    if(sourceEvent.hasSource() && sourceEvent.getSource() instanceof PolyphaseChannelSource channelSource)
                     {
-                        stopChannelSource((PolyphaseChannelSource)sourceEvent.getSource());
+                        stopChannelSource(channelSource);
+                        channelSource.dispose();
                     }
                     else
                     {
@@ -552,17 +439,6 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
                             (sourceEvent.hasSource() ? sourceEvent.getSource().getClass() : "null source"));
                     }
                     break;
-                case REQUEST_SOURCE_DISPOSE:
-                    Source source = sourceEvent.getSource();
-
-                    if(source instanceof PolyphaseChannelSource)
-                    {
-                        source.dispose();
-                    }
-                    break;
-                case NOTIFICATION_FREQUENCY_CORRECTION_CHANGE:
-                    //ignore
-                    break;
                 case NOTIFICATION_MEASURED_FREQUENCY_ERROR_SYNC_LOCKED:
                     //Rebroadcast so that the tuner source can process this event
                     mSourceEventBroadcaster.broadcast(sourceEvent);
@@ -578,58 +454,68 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
     /**
      * Processes the incoming buffer stream from the provider and transfers the buffers to the polyphase channelizer.
      *
-     * This monitor incorporates a queue for receiving source events that affect configuration of the channelizer so
-     * that they can be processed on the buffer processor calling thread, avoiding unnecessary locks on the channelizer
-     * and/or the channel sources and output processors.
+     * This monitor incorporates a source event handler that queues a center frequency update so that it can be
+     * handled on the buffer processing thread, avoiding having to lock on the output processor thread.  Since we
+     * anticipate that these two threads will contend for access to this update required flag, we use an update lock
+     * to protect access to the flag.
      */
     public class NativeBufferReceiver implements Listener<INativeBuffer>
     {
-        private Queue<SourceEvent> mQueuedSourceEvents = new ConcurrentLinkedQueue<>();
+        private boolean mOutputProcessorUpdateRequired = false;
 
         /**
-         * Queues the source event for deferred execution on the buffer processing thread.
+         * Processes tuner center frequency change source events to flag when output processors need updating.
          * @param event that affects configuration of the channelizer (frequency or sample rate change events)
          */
         public void receive(SourceEvent event)
         {
-            mQueuedSourceEvents.offer(event);
+            long frequency = event.getValue().longValue();
+
+            if(mChannelCalculator.getCenterFrequency() != frequency)
+            {
+                //Update the channel calculator frequency so that it's ready when the output processor update occurs
+                mChannelCalculator.setCenterFrequency(frequency);
+                mOutputProcessorUpdateRequired = true;
+            }
         }
 
+        /**
+         * Process native buffer streams and update polyphase output channels when the parent tuner center
+         * frequency changes.
+         * @param nativeBuffer of sample to process.
+         */
         @Override
         public void receive(INativeBuffer nativeBuffer)
         {
-            try
+            if(mOutputProcessorUpdateRequired)
             {
-                //Process any queued source events before processing the buffers
-                SourceEvent queuedSourceEvent = mQueuedSourceEvents.poll();
-
-                while(queuedSourceEvent != null)
+                try
                 {
-                    switch(queuedSourceEvent.getEvent())
-                    {
-                        case NOTIFICATION_FREQUENCY_CHANGE:
-                            //Don't send the tuner's frequency change event down to the channels - it would cause chaos
-                            updateOutputProcessors(null);
-                            break;
-                    }
-
-                    queuedSourceEvent = mQueuedSourceEvents.poll();
+                    updateOutputProcessors();
                 }
-
-                if(mPolyphaseChannelizer != null)
+                catch(Exception e)
                 {
-                    Iterator<InterleavedComplexSamples> iterator = nativeBuffer.iteratorInterleaved();
+                    mLog.error("Error updating polyphase channel output processors");
+                }
+                mOutputProcessorUpdateRequired = false;
+            }
 
-                    while(iterator.hasNext())
+            if(mPolyphaseChannelizer != null)
+            {
+                Iterator<InterleavedComplexSamples> iterator = nativeBuffer.iteratorInterleaved();
+
+                while(iterator.hasNext())
+                {
+                    try
                     {
                         mPolyphaseChannelizer.receive(iterator.next());
                     }
+                    catch(Throwable throwable)
+                    {
+                        mLog.error("Error", throwable);
+                    }
                 }
             }
-            catch(Throwable throwable)
-            {
-                mLog.error("Error", throwable);
-            }
         }
     }
 }

src/main/java/io/github/dsheirer/dsp/filter/channelizer/PolyphaseChannelSource.java

@@ -1,6 +1,6 @@
 /*
  * *****************************************************************************
- * Copyright (C) 2014-2022 Dennis Sheirer
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,15 +19,18 @@
 package io.github.dsheirer.dsp.filter.channelizer;
 
 import io.github.dsheirer.dsp.filter.channelizer.output.IPolyphaseChannelOutputProcessor;
+import io.github.dsheirer.dsp.filter.channelizer.output.OneChannelOutputProcessor;
+import io.github.dsheirer.dsp.filter.channelizer.output.TwoChannelOutputProcessor;
 import io.github.dsheirer.dsp.filter.design.FilterDesignException;
 import io.github.dsheirer.sample.Listener;
 import io.github.dsheirer.sample.complex.ComplexSamples;
 import io.github.dsheirer.source.SourceEvent;
-import io.github.dsheirer.source.tuner.channel.StreamProcessorWithHeartbeat;
 import io.github.dsheirer.source.tuner.channel.TunerChannel;
 import io.github.dsheirer.source.tuner.channel.TunerChannelSource;
-
+import java.util.ArrayList;
 import java.util.List;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * Polyphase Channelizer's Tuner Channel Source implementation.  Wraps a ChannelOutputProcessor instance and
@@ -36,34 +39,66 @@ import java.util.List;
  */
 public class PolyphaseChannelSource extends TunerChannelSource implements Listener<ComplexSamples>
 {
+    private Logger mLog = LoggerFactory.getLogger(PolyphaseChannelSource.class);
     private IPolyphaseChannelOutputProcessor mPolyphaseChannelOutputProcessor;
-    private IPolyphaseChannelOutputProcessor mReplacementPolyphaseChannelOutputProcessor;
-    private StreamProcessorWithHeartbeat<ComplexSamples> mStreamHeartbeatProcessor;
-    private long mReplacementFrequency;
+    private Listener<ComplexSamples> mSamplesListener;
     private double mChannelSampleRate;
     private long mIndexCenterFrequency;
-    private long mChannelFrequencyCorrection;
+    private List<Integer> mOutputProcessorIndexes = new ArrayList<>();
+    private double mTunerSampleRate;
+    private double mTunerCenterFrequency;
+    private PendingOutputProcessorUpdate mPendingOutputProcessorUpdate;
 
     /**
      * Constructs an instance
      *
      * @param tunerChannel describing the desired channel frequency and bandwidth/minimum sample rate
-     * @param outputProcessor - to process polyphase channelizer channel results into a channel stream
+     * @param channelCalculator for current channel center frequency and sample rate and index calculations
+     * @param filterManager for access to new or cached synthesis filters
      * @param producerSourceEventListener to receive source event requests (e.g. start/stop sample stream)
-     * @param channelSampleRate for the downstream sample output
-     * @param centerFrequency of the incoming polyphase channel(s)
-     * @throws FilterDesignException if a channel low pass filter can't be designed to the channel specification
+     * @throws IllegalArgumentException if a channel low pass filter can't be designed to the channel specification
      */
-    public PolyphaseChannelSource(TunerChannel tunerChannel, IPolyphaseChannelOutputProcessor outputProcessor,
-                                  Listener<SourceEvent> producerSourceEventListener, double channelSampleRate,
-                                  long centerFrequency) throws FilterDesignException
+    public PolyphaseChannelSource(TunerChannel tunerChannel, ChannelCalculator channelCalculator, SynthesisFilterManager filterManager,
+                                  Listener<SourceEvent> producerSourceEventListener) throws IllegalArgumentException
     {
         super(producerSourceEventListener, tunerChannel);
-        mPolyphaseChannelOutputProcessor = outputProcessor;
-        mPolyphaseChannelOutputProcessor.setListener(this);
-        mChannelSampleRate = channelSampleRate;
-        mStreamHeartbeatProcessor = new StreamProcessorWithHeartbeat<>(getHeartbeatManager(), HEARTBEAT_INTERVAL_MS);
-        setFrequency(centerFrequency);
+        mChannelSampleRate = channelCalculator.getChannelSampleRate();
+        doUpdateOutputProcessor(channelCalculator, filterManager);
+    }
+
+    /**
+     * Description of the state or configuration of the output processor.
+     */
+    public String getStateDescription()
+    {
+        return mPolyphaseChannelOutputProcessor.getStateDescription();
+    }
+
+    /**
+     * Current output processor indexes.
+     * @return indexes
+     */
+    public List<Integer> getOutputProcessorIndexes()
+    {
+        return mOutputProcessorIndexes;
+    }
+
+    /**
+     * Sample rate or bandwidth of the tuner providing input to the channelizer.
+     * @return sample rate
+     */
+    public double getTunerSampleRate()
+    {
+        return mTunerSampleRate;
+    }
+
+    /**
+     * Center tuned frequency of the tuner providing input to the channelizer.
+     * @return center frequency
+     */
+    public double getTunerCenterFrequency()
+    {
+        return mTunerCenterFrequency;
     }
 
     @Override
@@ -71,8 +106,6 @@ public class PolyphaseChannelSource extends TunerChannelSource implements Listen
     {
         super.start();
 
-        mStreamHeartbeatProcessor.start();
-
         if(mPolyphaseChannelOutputProcessor != null)
         {
             mPolyphaseChannelOutputProcessor.start();
@@ -88,8 +121,6 @@ public class PolyphaseChannelSource extends TunerChannelSource implements Listen
         {
             mPolyphaseChannelOutputProcessor.stop();
         }
-
-        mStreamHeartbeatProcessor.stop();
     }
 
     /**
@@ -98,70 +129,135 @@ public class PolyphaseChannelSource extends TunerChannelSource implements Listen
     @Override
     public void setListener(final Listener<ComplexSamples> listener)
     {
-        mStreamHeartbeatProcessor.setListener(listener);
+        mSamplesListener = listener;
         mPolyphaseChannelOutputProcessor.setListener(this);
     }
 
     @Override
     public void receive(ComplexSamples complexSamples)
     {
-        mStreamHeartbeatProcessor.receive(complexSamples);
-    }
-
-    /**
-     * Channel output processor used by this channel source to convert polyphase channel results into a specific
-     * channel complex buffer output stream.
-     */
-    public IPolyphaseChannelOutputProcessor getPolyphaseChannelOutputProcessor()
-    {
-        return mPolyphaseChannelOutputProcessor;
-    }
-
-    /**
-     * Sets/updates the output processor for this channel source, replacing the existing output processor.
-     *
-     * @param outputProcessor to use
-     * @param frequency center for the channels processed by the output processor
-     */
-    public void setPolyphaseChannelOutputProcessor(IPolyphaseChannelOutputProcessor outputProcessor, long frequency)
-    {
-        //If this is the first time, simply assign the output processor
-        if(mPolyphaseChannelOutputProcessor == null)
+        if(mSamplesListener != null)
         {
-            mPolyphaseChannelOutputProcessor = outputProcessor;
-            mPolyphaseChannelOutputProcessor.setListener(this);
-        }
-        //Otherwise, we have to swap out the processor on the sample processing thread
-        else
-        {
-            mReplacementPolyphaseChannelOutputProcessor = outputProcessor;
-            mReplacementFrequency = frequency;
+            try
+            {
+                mSamplesListener.receive(complexSamples);
+            }
+            catch(Throwable t)
+            {
+                mLog.error("Error dispatching complex samples to listener [" + mSamplesListener.getClass() + "]", t);
+            }
         }
     }
 
     /**
-     * Updates the output processor to use the new output processor provided by the external
-     * polyphase channel manager.  This method should only be executed on the sample processing
-     * thread, within the processChannelResults() method.
+     * Queues a request to update the output processor whenever the source tuner's center frequency changes.
+     * @param channelCalculator providing access to updated tuner center frequency, sample rate, etc.
+     * @param filterManager for designing and caching synthesis filters
      */
-    private void swapOutputProcessor()
+    public void updateOutputProcessor(ChannelCalculator channelCalculator, SynthesisFilterManager filterManager)
+            throws IllegalArgumentException
     {
-        if(mReplacementPolyphaseChannelOutputProcessor != null)
+        mPendingOutputProcessorUpdate = new PendingOutputProcessorUpdate(channelCalculator, filterManager);
+    }
+
+    /**
+     * Performs the output processor update.  This method must be invoked on the channel results calling thread to
+     * ensure we don't have thread contention on the output processor.
+     * @param channelCalculator for updates
+     * @param filterManager for updates
+     * @throws IllegalArgumentException if there's an issue.
+     */
+    public void doUpdateOutputProcessor(ChannelCalculator channelCalculator, SynthesisFilterManager filterManager)
+            throws IllegalArgumentException
+    {
+        String errorMessage = null;
+
+        //If a change in sample rate or center frequency makes this channel no longer viable, then the channel
+        //calculator will throw an IllegalArgException ... handled below
+        List<Integer> indexes = channelCalculator.getChannelIndexes(getTunerChannel());
+
+        mOutputProcessorIndexes.clear();
+        mOutputProcessorIndexes.addAll(indexes);
+        mTunerCenterFrequency = channelCalculator.getCenterFrequency();
+        mTunerSampleRate = channelCalculator.getSampleRate();
+
+        //The provided channels are necessarily aligned to the center frequency that this source is providing and an
+        //oscillator will mix the provided channels to bring the desired center frequency to baseband.
+        setFrequency(channelCalculator.getCenterFrequencyForIndexes(indexes));
+
+        if(mPolyphaseChannelOutputProcessor != null && mPolyphaseChannelOutputProcessor.getInputChannelCount() == indexes.size())
         {
-            IPolyphaseChannelOutputProcessor existingProcessor = mPolyphaseChannelOutputProcessor;
-            existingProcessor.stop();
-            existingProcessor.setListener(null);
+            mPolyphaseChannelOutputProcessor.setPolyphaseChannelIndices(indexes);
 
-            //Swap out the processor so that incoming samples can accumulate in the new channel output processor
-            mPolyphaseChannelOutputProcessor = mReplacementPolyphaseChannelOutputProcessor;
-            mReplacementPolyphaseChannelOutputProcessor = null;
-            mPolyphaseChannelOutputProcessor.setListener(this);
-            mPolyphaseChannelOutputProcessor.start();
+            if(indexes.size() > 1)
+            {
+                try
+                {
+                    float[] filter = filterManager.getFilter(channelCalculator.getChannelSampleRate(),
+                            channelCalculator.getChannelBandwidth(), indexes.size());
+                    mPolyphaseChannelOutputProcessor.setSynthesisFilter(filter);
+                }
+                catch(FilterDesignException fde)
+                {
+                    mLog.error("Error creating an updated synthesis filter for the channel output processor");
+                    errorMessage ="Cannot update output processor - unable to design synthesis filter for [" +
+                        indexes.size() + "] channel indices - channel sample rate [" + channelCalculator.getChannelSampleRate() +
+                        "] channel bandwidth [" + channelCalculator.getChannelBandwidth() + "]";
+                }
+            }
 
-            //Finally, setup the frequency offset for the output processor.
-            mIndexCenterFrequency = mReplacementFrequency;
             mPolyphaseChannelOutputProcessor.setFrequencyOffset(getFrequencyOffset());
         }
+        else //Create a new output processor.
+        {
+            if(mPolyphaseChannelOutputProcessor != null)
+            {
+                mPolyphaseChannelOutputProcessor.setListener(null);
+                mPolyphaseChannelOutputProcessor.stop();
+            }
+
+            mPolyphaseChannelOutputProcessor = null;
+
+            switch(indexes.size())
+            {
+                case 1:
+                    mPolyphaseChannelOutputProcessor = new OneChannelOutputProcessor(channelCalculator.getChannelSampleRate(),
+                            indexes, channelCalculator.getChannelCount(), getHeartbeatManager());
+                    mPolyphaseChannelOutputProcessor.setListener(this);
+                    mPolyphaseChannelOutputProcessor.setFrequencyOffset(getFrequencyOffset());
+                    mPolyphaseChannelOutputProcessor.start();
+                    break;
+                case 2:
+                    try
+                    {
+                        float[] filter = filterManager.getFilter(channelCalculator.getChannelSampleRate(),
+                                channelCalculator.getChannelBandwidth(), 2);
+                        mPolyphaseChannelOutputProcessor = new TwoChannelOutputProcessor(channelCalculator.getChannelSampleRate(),
+                                indexes, filter, channelCalculator.getChannelCount(), getHeartbeatManager());
+                        mPolyphaseChannelOutputProcessor.setListener(this);
+                        mPolyphaseChannelOutputProcessor.setFrequencyOffset(getFrequencyOffset());
+                        mPolyphaseChannelOutputProcessor.start();
+                    }
+                    catch(FilterDesignException fde)
+                    {
+                        errorMessage = "Cannot create new output processor - unable to design synthesis filter for [" +
+                                indexes.size() + "] channel indices";
+                        mLog.error("Error creating a synthesis filter for a new channel output processor");
+                    }
+                    break;
+                default:
+                    mLog.error("Request to create an output processor for unexpected channel index size:" + indexes.size());
+                    mLog.info(channelCalculator.toString());
+                    errorMessage = "Unable to create new channel output processor - unexpected channel index size: " +
+                            indexes.size();
+            }
+        }
+
+        //Unlikely, but if we had an error designing a synthesis filter, throw an exception
+        if(errorMessage != null)
+        {
+            throw new IllegalArgumentException(errorMessage);
+        }
     }
 
     /**
@@ -170,15 +266,29 @@ public class PolyphaseChannelSource extends TunerChannelSource implements Listen
      * channel aggregation, and dispatch the results to the downstream sample listener/consumer.
      *
      * @param channelResultsList containing a list of polyphase channelizer output arrays.
+     * @param currentSamplesTimestamp for the samples
      */
-    public void receiveChannelResults(List<float[]> channelResultsList)
+    public void receiveChannelResults(List<float[]> channelResultsList, long currentSamplesTimestamp)
     {
-        if(mReplacementPolyphaseChannelOutputProcessor != null)
+        if(mPendingOutputProcessorUpdate != null)
         {
-            swapOutputProcessor();
+            ChannelCalculator channelCalculator = mPendingOutputProcessorUpdate.getChannelCalculator();
+            SynthesisFilterManager filterManager = mPendingOutputProcessorUpdate.getSynthesisFilterManager();
+            mPendingOutputProcessorUpdate = null;
+            doUpdateOutputProcessor(channelCalculator, filterManager);
         }
 
-        mPolyphaseChannelOutputProcessor.receiveChannelResults(channelResultsList);
+        try
+        {
+            if(mPolyphaseChannelOutputProcessor != null)
+            {
+                mPolyphaseChannelOutputProcessor.receiveChannelResults(channelResultsList, currentSamplesTimestamp);
+            }
+        }
+        catch(Exception e)
+        {
+            mLog.error("Error processing channel results", e);
+        }
     }
 
     /**
@@ -212,57 +322,32 @@ public class PolyphaseChannelSource extends TunerChannelSource implements Listen
         }
     }
 
-    @Override
-    public long getChannelFrequencyCorrection()
-    {
-        return mChannelFrequencyCorrection;
-    }
-
     /**
-     * Adjusts the frequency correction value that is being applied to the channelized output stream by the
-     * polyphase channel output processor.
-     *
-     * @param value to apply for frequency correction in hertz
-     */
-    protected void setChannelFrequencyCorrection(long value)
-    {
-//TODO: push this frequency correction down to the output processor ...
-        mChannelFrequencyCorrection = value;
-        updateFrequencyOffset();
-        broadcastConsumerSourceEvent(SourceEvent.frequencyCorrectionChange(mChannelFrequencyCorrection));
-    }
-
-    /**
-     * Sets the center frequency for this channel.frequency for the incoming sample stream channel results and resets frequency correction to zero.
+     * Sets the center frequency for this channel.
      * @param frequency in hertz
      */
     @Override
     public void setFrequency(long frequency)
     {
         mIndexCenterFrequency = frequency;
+    }
 
-        //Set frequency correction to zero to trigger an update to the mixer and allow downstream monitors to
-        //recalculate the frequency error correction again
-        setChannelFrequencyCorrection(0);
+    /**
+     * Center frequency from the incoming index channel(s).
+     * @return frequency in hertz
+     */
+    public long getIndexCenterFrequency()
+    {
+        return mIndexCenterFrequency;
     }
 
     /**
      * Calculates the frequency offset required to mix the incoming signal to center the desired frequency
      * within the channel
      */
-    private long getFrequencyOffset()
+    public long getFrequencyOffset()
     {
-        return mIndexCenterFrequency - getTunerChannel().getFrequency() + mChannelFrequencyCorrection;
-    }
-
-    /**
-     * Updates the frequency offset being applied by the output processor.  Calculates the offset using the center
-     * frequency of the incoming polyphase channel results and the desired output channel frequency adjusted by any
-     * requested frequency correction value.
-     */
-    private void updateFrequencyOffset()
-    {
-        mPolyphaseChannelOutputProcessor.setFrequencyOffset(getFrequencyOffset());
+        return mIndexCenterFrequency - getTunerChannel().getFrequency();
     }
 
     @Override
@@ -271,4 +356,40 @@ public class PolyphaseChannelSource extends TunerChannelSource implements Listen
         return "POLYPHASE [" + mPolyphaseChannelOutputProcessor.getInputChannelCount() + "] " +
             getTunerChannel().getFrequency();
     }
+
+    /**
+     * Support classes needed to update the output processor.
+     */
+    public class PendingOutputProcessorUpdate
+    {
+        private final ChannelCalculator mChannelCalculator;
+        private final SynthesisFilterManager mSynthesisFilterManager;
+
+        /**
+         * Constructs an instance
+         * @param channelCalculator for support
+         * @param synthesisFilterManager for support
+         */
+        public PendingOutputProcessorUpdate(ChannelCalculator channelCalculator, SynthesisFilterManager synthesisFilterManager)
+        {
+            mChannelCalculator = channelCalculator;
+            mSynthesisFilterManager = synthesisFilterManager;
+        }
+
+        /**
+         * Channel calculator
+         */
+        public ChannelCalculator getChannelCalculator()
+        {
+            return mChannelCalculator;
+        }
+
+        /**
+         * Channel calculator
+         */
+        public SynthesisFilterManager getSynthesisFilterManager()
+        {
+            return mSynthesisFilterManager;
+        }
+    }
 }

src/main/java/io/github/dsheirer/dsp/filter/channelizer/SynthesisFilterManager.java

@@ -0,0 +1,58 @@
+/*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 Dennis Sheirer
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * ****************************************************************************
+ */
+
+package io.github.dsheirer.dsp.filter.channelizer;
+
+import io.github.dsheirer.dsp.filter.FilterFactory;
+import io.github.dsheirer.dsp.filter.design.FilterDesignException;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Creates and caches channel output processor synthesis filters.
+ */
+public class SynthesisFilterManager
+{
+    private static final int POLYPHASE_SYNTHESIZER_TAPS_PER_CHANNEL = 9;
+    private static final String SEPARATOR = "-";
+    private Map<String,float[]> mFilterMap = new HashMap<>();
+
+    /**
+     * Design or retrieve a previously cached output processor synthesis filter.
+     * @param sampleRate of the tuner
+     * @param channelBandwidth per channel
+     * @param channelCount as the number of channels being synthesized/aggregated for the output processor (1 or 2)
+     * @return filter
+     * @throws FilterDesignException if the filter cannot be designed based on the supplied parameters.
+     */
+    public float[] getFilter(double sampleRate, double channelBandwidth, int channelCount) throws FilterDesignException
+    {
+        String key = sampleRate + SEPARATOR + channelBandwidth + SEPARATOR + channelCount;
+
+        if(mFilterMap.containsKey(key))
+        {
+            return mFilterMap.get(key);
+        }
+
+        float[] taps = FilterFactory.getSincM2Synthesizer(sampleRate, channelBandwidth, channelCount,
+                POLYPHASE_SYNTHESIZER_TAPS_PER_CHANNEL);
+        mFilterMap.put(key, taps);
+        return taps;
+    }
+}

src/main/java/io/github/dsheirer/dsp/filter/channelizer/TwoChannelSynthesizerM2.java

@@ -1,6 +1,6 @@
 /*
  * *****************************************************************************
- * Copyright (C) 2014-2022 Dennis Sheirer
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,6 +19,7 @@
 package io.github.dsheirer.dsp.filter.channelizer;
 
 import io.github.dsheirer.sample.complex.ComplexSamples;
+import java.util.Arrays;
 import org.apache.commons.math3.util.FastMath;
 import org.jtransforms.fft.FloatFFT_1D;
 import org.slf4j.Logger;
@@ -65,6 +66,20 @@ public class TwoChannelSynthesizerM2
         init(filter);
     }
 
+    /**
+     * Description of the state/configuration of this synthesizer to support debugging.
+     * @return state description.
+     */
+    public String getStateDescription()
+    {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Two-Channel Synthesizer");
+        sb.append("\n\t\t Interleaved Filter: " + Arrays.toString(mIQInterleavedFilter));
+        sb.append("\n\t\t Serpentine Buffer Length: ").append(mSerpentineDataBuffer.length);
+        sb.append("\n\t\t Filter Vector Product Length: ").append(mFilterVectorProduct.length);
+        return sb.toString();
+    }
+
     /**
      * Initializes the synthesizer filter and data buffers for operation.
      *
@@ -73,7 +88,6 @@ public class TwoChannelSynthesizerM2
     private void init(float[] filter)
     {
         int tapsPerChannel = (int) FastMath.ceil(filter.length / 2);
-
         mIQInterleavedFilter = getInterleavedFilter(filter, tapsPerChannel);
         mSerpentineDataBuffer = new float[mIQInterleavedFilter.length];
         mFilterVectorProduct = new float[mIQInterleavedFilter.length];
@@ -156,7 +170,7 @@ public class TwoChannelSynthesizerM2
             mTopBlockFlag = !mTopBlockFlag;
         }
 
-        return new ComplexSamples(i, q);
+        return new ComplexSamples(i, q, channelBuffer1.timestamp());
     }
 
     /**

src/main/java/io/github/dsheirer/dsp/filter/channelizer/output/ChannelOutputProcessor.java

@@ -1,6 +1,6 @@
 /*
  * *****************************************************************************
- * Copyright (C) 2014-2022 Dennis Sheirer
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,20 +20,21 @@ package io.github.dsheirer.dsp.filter.channelizer.output;
 
 import io.github.dsheirer.sample.Listener;
 import io.github.dsheirer.sample.complex.ComplexSamples;
+import io.github.dsheirer.source.heartbeat.HeartbeatManager;
 import io.github.dsheirer.util.Dispatcher;
+import java.util.List;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.Collections;
-import java.util.List;
-
 public abstract class ChannelOutputProcessor implements IPolyphaseChannelOutputProcessor
 {
     private final static Logger mLog = LoggerFactory.getLogger(ChannelOutputProcessor.class);
 
     private Dispatcher<List<float[]>> mChannelResultsDispatcher;
+    private HeartbeatManager mHeartbeatManager;
     protected Listener<ComplexSamples> mComplexSamplesListener;
     private int mInputChannelCount;
+    private long mCurrentSampleTimestamp = System.currentTimeMillis();
 
     /**
      * Base class for polyphase channelizer output channel processing.  Provides built-in frequency translation
@@ -42,12 +43,34 @@ public abstract class ChannelOutputProcessor implements IPolyphaseChannelOutputP
      * @param inputChannelCount is the number of input channels for this output processor
      * @param sampleRate of the output channel.  This is used to match the oscillator's sample rate to the output
      * channel sample rate for frequency translation/correction.
+     * @param heartbeatManager to receive pings on the dispatcher thread
      */
-    public ChannelOutputProcessor(int inputChannelCount, double sampleRate)
+    public ChannelOutputProcessor(int inputChannelCount, double sampleRate, HeartbeatManager heartbeatManager)
     {
         mInputChannelCount = inputChannelCount;
-        mChannelResultsDispatcher = new Dispatcher<>((int)sampleRate, "sdrtrunk polyphase channel", Collections.emptyList());
-        mChannelResultsDispatcher.setListener(floats -> process(floats));
+        //Process 1/10th of the sample rate per second at a rate of 20 times a second (200% of anticipated rate)
+        mHeartbeatManager = heartbeatManager;
+        mChannelResultsDispatcher = new Dispatcher("sdrtrunk polyphase channel", (int)(sampleRate / 10),
+                50, mHeartbeatManager);
+        mChannelResultsDispatcher.setListener(floats -> {
+            try
+            {
+                process(floats);
+            }
+            catch(Throwable t)
+            {
+                mLog.error("Error processing channel results", t);
+            }
+        });
+    }
+
+    /**
+     * Timestamp for the current series of samples.
+     * @return time in milliseconds to use with assembled complex sample buffers.
+     */
+    protected long getCurrentSampleTimestamp()
+    {
+        return mCurrentSampleTimestamp;
     }
 
     @Override
@@ -82,9 +105,10 @@ public abstract class ChannelOutputProcessor implements IPolyphaseChannelOutputP
     }
 
     @Override
-    public void receiveChannelResults(List<float[]> channelResultsList)
+    public void receiveChannelResults(List<float[]> channelResultsList, long timestamp)
     {
         mChannelResultsDispatcher.receive(channelResultsList);
+        mCurrentSampleTimestamp = timestamp;
     }
 
     /**

src/main/java/io/github/dsheirer/dsp/filter/channelizer/output/IPolyphaseChannelOutputProcessor.java

@@ -1,6 +1,6 @@
 /*
  * *****************************************************************************
- * Copyright (C) 2014-2022 Dennis Sheirer
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,11 +20,15 @@ package io.github.dsheirer.dsp.filter.channelizer.output;
 
 import io.github.dsheirer.sample.Listener;
 import io.github.dsheirer.sample.complex.ComplexSamples;
-
 import java.util.List;
 
 public interface IPolyphaseChannelOutputProcessor
 {
+    /**
+     * Description of the state/configuration of this output processor
+     */
+    String getStateDescription();
+
     /**
      * Start processing channel results
      */
@@ -37,19 +41,15 @@ public interface IPolyphaseChannelOutputProcessor
     /**
      * Receive and enqueue output results from the polyphase analysis channelizer
      * @param channelResults to enqueue
+     * @param timestamp for the first channel results buffer
      */
-    void receiveChannelResults(List<float[]> channelResults);
+    void receiveChannelResults(List<float[]> channelResults, long timestamp);
 
     /**
      * Listener to receive assembled complex samples buffers
      */
     void setListener(Listener<ComplexSamples> listener);
 
-//    /**
-//     * Process the channel output channel results queue and deliver the output to the listener
-//     */
-//    void processChannelResults();
-
     /**
      * Sets the desired frequency offset from center.  The samples will be mixed with an oscillator set to this offset
      * frequency to produce an output where the desired signal is centered in the passband.

src/main/java/io/github/dsheirer/dsp/filter/channelizer/output/MixerAssembler.java

@@ -65,7 +65,8 @@ public abstract class MixerAssembler
 
     /**
      * Access the fully assembled buffer when hasBuffer() indicates that a buffer is ready.
+     * @param timestamp to use for the assembled complex samples buffer
      * @return true if a full buffer is assembled and ready.
      */
-    public abstract ComplexSamples getBuffer();
+    public abstract ComplexSamples getBuffer(long timestamp);
 }

src/main/java/io/github/dsheirer/dsp/filter/channelizer/output/OneChannelMixerAssembler.java

@@ -61,9 +61,9 @@ public class OneChannelMixerAssembler extends MixerAssembler
      * @return assembled buffer.
      */
     @Override
-    public ComplexSamples getBuffer()
+    public ComplexSamples getBuffer(long timestamp)
     {
-        ComplexSamples buffer = mSampleAssembler.getBufferAndReset();
+        ComplexSamples buffer = mSampleAssembler.getBufferAndReset(timestamp);
 
         if(getMixer().hasFrequency())
         {

src/main/java/io/github/dsheirer/dsp/filter/channelizer/output/OneChannelOutputProcessor.java

@@ -1,6 +1,6 @@
 /*
  * *****************************************************************************
- * Copyright (C) 2014-2022 Dennis Sheirer
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,11 +19,11 @@
 package io.github.dsheirer.dsp.filter.channelizer.output;
 
 import io.github.dsheirer.sample.complex.ComplexSamples;
+import io.github.dsheirer.source.heartbeat.HeartbeatManager;
+import java.util.List;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.List;
-
 public class OneChannelOutputProcessor extends ChannelOutputProcessor
 {
     private final static Logger mLog = LoggerFactory.getLogger(OneChannelOutputProcessor.class);
@@ -37,15 +37,27 @@ public class OneChannelOutputProcessor extends ChannelOutputProcessor
      * @param sampleRate of the output sample stream.
      * @param channelIndexes containing a single channel index.
      * @param gain value to apply.  This is typically the same as the channelizer's channel count.
+     * @param heartbeatManager to receive heartbeats on the dispatch thread
      */
-    public OneChannelOutputProcessor(double sampleRate, List<Integer> channelIndexes, float gain)
+    public OneChannelOutputProcessor(double sampleRate, List<Integer> channelIndexes, float gain,
+                                     HeartbeatManager heartbeatManager)
     {
-        super(1, sampleRate);
+        super(1, sampleRate, heartbeatManager);
         setPolyphaseChannelIndices(channelIndexes);
         mMixerAssembler = new OneChannelMixerAssembler(gain);
         mMixerAssembler.getMixer().setSampleRate(sampleRate);
     }
 
+    @Override
+    public String getStateDescription()
+    {
+        StringBuilder sb = new StringBuilder();
+        sb.append("One Channel Output Processor");
+        sb.append("\n\tIndex (doubled) [").append(mChannelOffset).append("]");
+        sb.append("\n\tMixer Assembler: none");
+        return sb.toString();
+    }
+
     @Override
     public void setSynthesisFilter(float[] filter)
     {
@@ -80,7 +92,7 @@ public class OneChannelOutputProcessor extends ChannelOutputProcessor
      * Extract the channel from the channel results array and pass to the assembler.  The assembler will
      * apply frequency translation and gain and indicate when a buffer is fully assembled.
      *
-     * @param lists to process containing a list of a list of channel array of I/Q sample pairs (I0,Q0,I1,Q1...In,Qn)
+     * @param channelResultsList to process containing a list of a list of channel array of I/Q sample pairs (I0,Q0,I1,Q1...In,Qn)
      */
     @Override
     public void process(List<float[]> channelResultsList)
@@ -91,7 +103,7 @@ public class OneChannelOutputProcessor extends ChannelOutputProcessor
 
             if(mMixerAssembler.hasBuffer())
             {
-                ComplexSamples buffer = mMixerAssembler.getBuffer();
+                ComplexSamples buffer = mMixerAssembler.getBuffer(getCurrentSampleTimestamp());
 
                 if(mComplexSamplesListener != null)
                 {

src/main/java/io/github/dsheirer/dsp/filter/channelizer/output/SampleAssembler.java

@@ -76,9 +76,9 @@ public class SampleAssembler
     /**
      * Extracts the full buffer from this assembler and resets the assembler to accept more samples.
      */
-    public ComplexSamples getBufferAndReset()
+    public ComplexSamples getBufferAndReset(long timestamp)
     {
-        ComplexSamples buffer = new ComplexSamples(mI, mQ);
+        ComplexSamples buffer = new ComplexSamples(mI, mQ, timestamp);
         reset();
         return buffer;
     }

src/main/java/io/github/dsheirer/dsp/filter/channelizer/output/TwoChannelMixerAssembler.java

@@ -1,6 +1,6 @@
 /*
  * *****************************************************************************
- * Copyright (C) 2014-2022 Dennis Sheirer
+ * Copyright (C) 2014-2023 Dennis Sheirer
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -42,6 +42,19 @@ public class TwoChannelMixerAssembler extends MixerAssembler
         super(gain);
     }
 
+    /**
+     * Description of the state/configuration of this mixer assembler.
+     */
+    public String getStateDescription()
+    {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Two Channel Mixer Assembler - State Description:");
+        sb.append("\n\tTwo-Channel Synthesizer: ").append(mTwoChannelSynthesizer.getStateDescription());
+        sb.append("\n\tMixer Frequency: ").append(getMixer().getFrequency());
+        sb.append("\n\tGain: ").append(getGain().getGain());
+        return sb.toString();
+    }
+
     /**
      * Sets the filter coefficients to use for two-channel synthesis
      * @param filter
@@ -76,13 +89,14 @@ public class TwoChannelMixerAssembler extends MixerAssembler
 
     /**
      * Access the assembled buffer.  Frequency offset and gain are applied to the returned buffer.
+     * @param timestamp to use for the assembled buffer
      * @return assembled buffer.
      */
     @Override
-    public ComplexSamples getBuffer()
+    public ComplexSamples getBuffer(long timestamp)
     {
-        ComplexSamples channel1 = mChannel1SampleAssembler.getBufferAndReset();
-        ComplexSamples channel2 = mChannel2SampleAssembler.getBufferAndReset();
+        ComplexSamples channel1 = mChannel1SampleAssembler.getBufferAndReset(timestamp);
+        ComplexSamples channel2 = mChannel2SampleAssembler.getBufferAndReset(timestamp);
 
         //Synthesize two channels into one, reducing sample rate by 2 so it's same as single channel rate
         ComplexSamples buffer = mTwoChannelSynthesizer.process(channel1, channel2);