Update version to 0.5.0 beta 2

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

.github/workflows/gradle.yml

@@ -0,0 +1,34 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
+# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
+
+name: Java CI with Gradle
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    strategy:
+      matrix: 
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up JDK 17
+        uses: actions/setup-java@v2
+        with:
+          java-version: '17'
+          distribution: 'liberica'
+          java-package: 'jdk+fx'
+      - name: Build with Gradle
+        uses: gradle/gradle-build-action@937999e9cc2425eddc7fd62d1053baf041147db7
+        with:
+          arguments: clean build

.idea/dictionaries/denny.xml

@@ -2,6 +2,7 @@
   <dictionary name="denny">
     <words>
       <w>bahroo</w>
+      <w>basebanded</w>
       <w>broadcastify</w>
       <w>correlator</w>
       <w>deinterleave</w>

.idea/misc.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ExternalStorageConfigurationManager" enabled="true" />
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_13" default="false" project-jdk-name="15" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="liberica-17.0.2-fx" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

README.md

@@ -1,3 +1,5 @@
+![Gradle Build](https://github.com/dsheirer/sdrtrunk/actions/workflows/gradle.yml/badge.svg)
+
 # sdrtrunk
 A cross-platform java application for decoding, monitoring, recording and streaming trunked mobile and related radio protocols using Software Defined Radios (SDR).
 
@@ -33,8 +35,12 @@ Once unzipped, open a command prompt to where you unzipped the release.  Change
 * **Windows** sdr-trunk.bat
 * **Linux/OSX** ./sdr-trunk
 
-## Optional - P25 Audio
-If you're using sdrtrunk with a P25 trunked radio system, 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.
+## 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)
@@ -46,7 +52,15 @@ If you're using sdrtrunk with a P25 trunked radio system, the [JMBE](https://git
 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 11 or higher installed on your local compuber.  Use the gradle wrapper to build the source code:
+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
 ```
@@ -59,6 +73,18 @@ 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:

build.gradle

@@ -1,58 +1,63 @@
 /*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 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/>
+ * ****************************************************************************
  */
 plugins {
     id 'application'
     id 'java'
     id 'idea'
-    id 'org.openjfx.javafxplugin' version '0.0.8'
-    id 'org.beryx.runtime' version '1.11.4'
+    id 'org.beryx.runtime' version '1.12.7'
 }
 
 repositories {
-    jcenter()
     mavenCentral()
     maven { url "https://jitpack.io" }
 }
 
-version = '0.5.0-alpha6'
-sourceCompatibility = '13'
+version = '0.5.0-beta2'
+sourceCompatibility = '17'
 
 sourceSets {
     main.java.srcDirs 'src/main'
     test.java.srcDirs 'src/test'
 }
 
+test {
+    useJUnitPlatform()
+}
+
 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.+'
+
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
 
     //Jitpack imports
-    implementation 'com.github.nwaldispuehl:java-lame:v3.98.4'
     implementation 'com.github.dnault:libresample4j:master'
     implementation 'com.github.DSheirer.jmbe:jmbe-api:1.0.0'
+    implementation 'com.github.nwaldispuehl:java-lame:v3.98.4'
 
     //mavenCentral/jcenter imports
-    implementation 'ch.qos.logback:logback-core:1.2.3'
     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.9.8'
     implementation 'com.fazecast:jSerialComm:2.5.0'
     implementation 'com.github.jiconfont:jiconfont-font_awesome:4.7.0.1'
@@ -64,54 +69,40 @@ dependencies {
     implementation 'com.jidesoft:jide-oss:3.6.18'
     implementation 'com.miglayout:miglayout-swing:5.2'
     implementation 'com.mpatric:mp3agic:0.9.1'
+    implementation 'commons-io:commons-io:2.7'
     implementation 'eu.hansolo:charts:1.0.5'
     implementation 'io.github.dsheirer:radio-reference-api:15.1.8'
     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 'commons-io:commons-io:2.7'
     implementation 'org.apache.commons:commons-lang3:3.8.1'
     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.0.2'
+    implementation 'org.controlsfx:controlsfx:11.1.0'
     implementation 'org.rauschig:jarchivelib:1.0.0'
-
     implementation 'org.slf4j:slf4j-api:1.7.25'
     implementation 'org.usb4java:libusb4java:1.3.0'
     implementation 'org.usb4java:usb4java:1.3.0'
     implementation 'org.usb4java:usb4java-javax:1.3.0'
+    implementation 'io.github.dsheirer:libusb4java-darwin-aarch64:1.3.0' //usb4java native lib for OSX M1 cpu
     implementation 'pl.edu.icm:JLargeArrays:1.6'
+}
 
-    //These must remain as compile options to ensure they are included in the build to produce multi-OS images
-    compile "org.openjfx:javafx-base:15:win"
-    compile "org.openjfx:javafx-base:15:linux"
-    compile "org.openjfx:javafx-base:15:mac"
-    compile "org.openjfx:javafx-controls:15:win"
-    compile "org.openjfx:javafx-controls:15:linux"
-    compile "org.openjfx:javafx-controls:15:mac"
-    compile "org.openjfx:javafx-graphics:15:win"
-    compile "org.openjfx:javafx-graphics:15:linux"
-    compile "org.openjfx:javafx-graphics:15:mac"
-    compile "org.openjfx:javafx-swing:15:win"
-    compile "org.openjfx:javafx-swing:15:linux"
-    compile "org.openjfx:javafx-swing:15:mac"
+/**
+ * This is needed for the JDK17 vector API ... until it moves out of incubation
+ */
+tasks.withType(JavaCompile) {
+    options.compilerArgs.add("--add-modules=jdk.incubator.vector") //Needed while Panama Vector API remains in incubator
 }
 
 application {
     mainClassName = "io.github.dsheirer.gui.SDRTrunk"
-}
-
-idea {
-    module {
-        downloadJavadoc = true
-        downloadSources = true
-    }
-}
-
-javafx {
-    version = "15"
-    modules = ['javafx.base', 'javafx.controls', 'javafx.graphics', 'javafx.swing']
+    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
 }
 
 jar {
@@ -127,85 +118,109 @@ jar {
     }
 }
 
+idea {
+    module {
+        downloadJavadoc = true
+        downloadSources = true
+    }
+}
+
 /**
- * Java Development Kit (JDK) locations.  In order to build OS-specific images, these paths must point to the 'bin'
- * directory within a JDK for each of the specified architectures.  These JDKs are used by the runtime and runtimeZip
- * tasks to produce platform-specific builds.  If none of these paths exists, then an image will be created for the
- * host OS using the installed JDK.
+ * Runtime target OS and CPU image names.  We append version here so that version details are at end of zip filename.
  */
-def jdk_base = '/media/denny/WD250GB/java/bellsoft/'
+String targetLinuxAarch64 = 'linux-aarch64-v' + version
+String targetLinuxX86_64 = 'linux-x86_64-v' + version
+String targetOsxAarch64 = 'osx-aarch64-v' + version
+String targetOsxX86_64 = 'osx-x86_64-v' + version
+String targetWindowsX86_64 = 'windows-x86_64-v' + version
 
-def jdk_linux_arm64 = jdk_base + 'linux-arm64/jdk-15'
-def jdk_linux_x86_64 = jdk_base + 'linux-x64/jdk-15'
-def jdk_osx_x86_64 = jdk_base + 'osx-x64/jdk-15.jdk'
-def jdk_windows_x86_64 = jdk_base + 'windows-x64/jdk-15'
+/**
+ * Optional pre-downloaded Java Development Kit (JDK) for each target OS and CPU.  These locations are hard-coded to the
+ * 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-17.0.2-full'
+String jdk_linux_x86_64 = jdk_base + 'linux-x64/jdk-17.0.2-full'
+String jdk_osx_x86_64 = jdk_base + 'osx-x64/jdk-17.0.2-full.jdk'
+String jdk_osx_aarch64 = jdk_base + 'osx-arm64/jdk-17.0.2-full.jdk'
+String jdk_windows_x86_64 = jdk_base + 'windows-x64/jdk-17.0.2-full'
 
-def file_jdk_linux_arm64 = new File(jdk_linux_arm64)
-def file_jdk_linux_x86_64 = new File(jdk_linux_x86_64)
-def file_jdk_osx_x86_64 = new File(jdk_osx_x86_64)
-def file_jdk_windows_x86_64 = new File(jdk_windows_x86_64)
+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()
 
-def hasTargetJdk = file_jdk_linux_x86_64.exists() ||
-        file_jdk_linux_arm64 ||
-        file_jdk_osx_x86_64.exists() ||
-        file_jdk_windows_x86_64.exists()
+/**
+ * Auto-download target JDKs.  Defaults to false, or the user can override via the gradle command line by
+ * including this option: '-PdownloadJdks=true'
+ */
+boolean downloadJdks = project.hasProperty('downloadJdks') ? project.getProperty('downloadJdks') : false
 
+/**
+ * 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
+ */
 runtime {
-    if(file_jdk_linux_arm64.exists())
-    {
-        targetPlatform('linux-arm64-v' + version, jdk_linux_arm64)
+    //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/17.0.2+9/bellsoft-jdk17.0.2+9-linux-aarch64-full.tar.gz")
+        }
+        targetPlatform(targetLinuxX86_64) {
+            jdkHome = jdkDownload("https://download.bell-sw.com/java/17.0.2+9/bellsoft-jdk17.0.2+9-linux-amd64-full.tar.gz")
+        }
+        targetPlatform(targetOsxAarch64) {
+            jdkHome = jdkDownload("https://download.bell-sw.com/java/17.0.2+9/bellsoft-jdk17.0.2+9-macos-aarch64-full.tar.gz")
+        }
+        targetPlatform(targetOsxX86_64) {
+            jdkHome = jdkDownload("https://download.bell-sw.com/java/17.0.2+9/bellsoft-jdk17.0.2+9-macos-amd64-full.tar.gz")
+        }
+        targetPlatform(targetWindowsX86_64) {
+            jdkHome = jdkDownload("https://download.bell-sw.com/java/17.0.2+9/bellsoft-jdk17.0.2+9-windows-amd64-full.zip")
+        }
     }
-    else
-    {
-        println("Skipping OS Image - Linux ARM 64-bit JDK was not found at " + jdk_linux_arm64)
+    //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")
     }
 
-    if(file_jdk_linux_x86_64.exists())
-    {
-        targetPlatform('linux-x86_64-v' + version, jdk_linux_x86_64)
-    }
-    else
-    {
-        println("Skipping OS Image - Linux x86 64-bit JDK was not found at " + jdk_linux_x86_64)
-    }
+    //Additional modules to include with auto-detected modules.
+    modules = ['jdk.crypto.ec'] //jdk.crypto.ec needed for HTTPS connections (broadcastify calls & map tile server)
 
-    if(file_jdk_osx_x86_64.exists())
-    {
-        targetPlatform('osx-x86_64-v' + version, jdk_osx_x86_64)
-    }
-    else
-    {
-        println("Skipping OS Image - OSX x86 64-bit JDK was not found at " + jdk_osx_x86_64);
-    }
-
-    if(file_jdk_windows_x86_64.exists())
-    {
-        targetPlatform('windows-x86_64-v' + version, jdk_windows_x86_64)
-    }
-    else
-    {
-        println("Skipping OS Image - Windows x86 64-bit JDK was not found at " + jdk_windows_x86_64)
-    }
+    //Use auto-detected modules and 'add' any specified modules.
+    additive = true
 
+    //Recommended options for reducing/shrinking runtime target image size
     options = ['--strip-debug', '--compress', '2', '--no-header-files', '--no-man-pages']
-    modules = ['java.desktop', 'java.naming', 'jdk.unsupported', 'jdk.unsupported.desktop', 'java.net.http',
-               'java.sql', 'jdk.crypto.ec']
-    imageZip = hasTargetJdk ? file("$buildDir/image/sdr-trunk.zip") : file("$buildDir/image/sdr-trunk-" + version + ".zip")
-}
 
-/**
- * Copy JavaFX OS-specific libraries from each JDK to each platform target directory
- */
-tasks.runtime.doLast
-{
-    delete(fileTree('build/image/sdr-trunk-linux-arm64-v' + version + '/lib').include { it.name ==~ /javafx.*-(win|mac)\.jar/ })
-    delete(fileTree('build/image/sdr-trunk-linux-x86_64-v' + version + '/lib').include { it.name ==~ /javafx.*-(win|mac)\.jar/ })
-    delete(fileTree('build/image/sdr-trunk-osx-x86_64-v' + version + '/lib').include { it.name ==~ /javafx.*-(win|linux)\.jar/ })
-    delete(fileTree('build/image/sdr-trunk-windows-x86_64-v' + version + '/lib').include { it.name ==~ /javafx.*-(linux|mac)\.jar/ })
-
-    //JavaFX web and media modules are transitive dependencies of ControlsFX but are not required for this application
-    delete(fileTree('build/image/sdr-trunk-linux-arm64-v' + version + '/lib').include { it.name ==~ /javafx-(web|media)-.*\.jar/ })
-    delete(fileTree('build/image/sdr-trunk-linux-x86_64-v' + version + '/lib').include { it.name ==~ /javafx-(web|media)-.*\.jar/ })
-    delete(fileTree('build/image/sdr-trunk-osx-x86_64-v' + version + '/lib').include { it.name ==~ /javafx-(web|media)-.*\.jar/ })
-    delete(fileTree('build/image/sdr-trunk-windows-x86_64-v' + version + '/lib').include { it.name ==~ /javafx-(web|media)-.*\.jar/ })
+    //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")
 }

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

src/main/java/io/github/dsheirer/alias/action/RecurringAction.java

@@ -1,7 +1,6 @@
 /*
- * ******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2018 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,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.alias.action;
@@ -26,8 +25,8 @@ import io.github.dsheirer.alias.Alias;
 import io.github.dsheirer.message.IMessage;
 import io.github.dsheirer.util.ThreadPool;
 
-import javax.swing.JOptionPane;
-import java.awt.EventQueue;
+import javax.swing.*;
+import java.awt.*;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -92,7 +91,7 @@ public abstract class RecurringAction extends AliasAction
      */
     private void performThreadedAction(final Alias alias, final IMessage message)
     {
-        ThreadPool.SCHEDULED.schedule(() -> performAction(alias, message), 0, TimeUnit.SECONDS);
+        ThreadPool.CACHED.execute(() -> performAction(alias, message));
     }
 
     @Override

src/main/java/io/github/dsheirer/alias/action/beep/BeepAction.java

@@ -1,7 +1,6 @@
 /*
- * ******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2018 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,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.alias.action.beep;
@@ -72,7 +71,7 @@ public class BeepAction extends RecurringAction
 	@Override
 	public void performAction(Alias alias, IMessage message )
 	{
-		DataLine.Info info = new DataLine.Info(Clip.class, AudioFormats.PCM_SIGNED_8KHZ_16BITS_MONO);
+		DataLine.Info info = new DataLine.Info(Clip.class, AudioFormats.PCM_SIGNED_8000_HZ_16_BIT_MONO);
 
 		if(!AudioSystem.isLineSupported(info))
 		{
@@ -83,7 +82,7 @@ public class BeepAction extends RecurringAction
 		try
 		{
 			Clip clip = (Clip)AudioSystem.getLine(info);
-			clip.open(AudioFormats.PCM_SIGNED_8KHZ_16BITS_MONO, mToneBytes, 0, mToneBytes.length);
+			clip.open(AudioFormats.PCM_SIGNED_8000_HZ_16_BIT_MONO, mToneBytes, 0, mToneBytes.length);
 			clip.start();
 		}
 		catch(Exception e)

src/main/java/io/github/dsheirer/alias/id/talkgroup/TalkgroupFormat.java

@@ -46,6 +46,8 @@ public enum TalkgroupFormat
         "MDC-1200 valid value range is 1-65,535"),
     MPT1327("###-####", 1, 0x7FFFFF, "000-0001 to 127-8192",
         "<html>MPT-1327 valid ranges are 0-127(prefix)<br>and 1-8192(ident) (ie. 000-0001 to 127-8192)"),
+    NBFM("*****", 1, 0xFFFF, "1 to 65,535",
+            "NBFM valid value range is 1-65,535"),
     PASSPORT("*****", 1, 0xFFFF, "1 to 65,535",
         "Passport valid value range is 1-65,535"),
     UNKNOWN("********", 1, 0xFFFFFF, "1 to 16,777,215",
@@ -131,6 +133,8 @@ public enum TalkgroupFormat
                 return MDC1200;
             case MPT1327:
                 return MPT1327;
+            case NBFM:
+                return NBFM;
             case PASSPORT:
                 return PASSPORT;
             default:

src/main/java/io/github/dsheirer/alias/id/talkgroup/TalkgroupFormatter.java

@@ -28,6 +28,7 @@ import io.github.dsheirer.preference.identifier.talkgroup.FleetsyncTalkgroupForm
 import io.github.dsheirer.preference.identifier.talkgroup.LTRTalkgroupFormatter;
 import io.github.dsheirer.preference.identifier.talkgroup.MDC1200TalkgroupFormatter;
 import io.github.dsheirer.preference.identifier.talkgroup.MPT1327TalkgroupFormatter;
+import io.github.dsheirer.preference.identifier.talkgroup.NBFMTalkgroupFormatter;
 import io.github.dsheirer.preference.identifier.talkgroup.PassportTalkgroupFormatter;
 import io.github.dsheirer.preference.identifier.talkgroup.UnknownTalkgroupFormatter;
 import io.github.dsheirer.protocol.Protocol;
@@ -56,6 +57,7 @@ public class TalkgroupFormatter
         mFormatterMap.put(Protocol.LTR_NET, ltr);
         mFormatterMap.put(Protocol.MDC1200, new MDC1200TalkgroupFormatter());
         mFormatterMap.put(Protocol.MPT1327, new MPT1327TalkgroupFormatter());
+        mFormatterMap.put(Protocol.NBFM, new NBFMTalkgroupFormatter());
         mFormatterMap.put(Protocol.PASSPORT, new PassportTalkgroupFormatter());
         mFormatterMap.put(Protocol.UNKNOWN, new UnknownTalkgroupFormatter());
     }

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

@@ -1,3 +1,22 @@
+/*
+ * *****************************************************************************
+ * 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;
 
 import javax.sound.sampled.AudioFormat;
@@ -5,81 +24,107 @@ import javax.sound.sampled.DataLine;
 import javax.sound.sampled.Line;
 import javax.sound.sampled.SourceDataLine;
 
+/**
+ * Audio formats
+ */
 public class AudioFormats
 {
-	public static final AudioFormat.Encoding IMBE_ENCODING = 
-			new AudioFormat.Encoding( "IMBE" );
-
 	public static final boolean LITTLE_ENDIAN = false;
-	public static final boolean BIG_ENDIAN = true;
-	
-	public static final float IMBE_FRAME_RATE = 50;
-	public static final float IMBE_SAMPLE_RATE = 50;
-	public static final float PCM_8KHZ_RATE = 8000;
-	public static final float PCM_48KHZ_RATE = 48000;
-	
-	public static final int IMBE_FRAME_SIZE_BYTES = 18;
-	public static final int IMBE_SAMPLE_SIZE_BITS = 144;
+
+	public static final float PCM_8_KHZ_RATE = 8000;
+	public static final float PCM_16_KHZ_RATE = 16000;
+	public static final float PCM_22050_HZ_RATE = 22050;
+	public static final float PCM_44100_HZ_RATE = 44100;
+
 	public static final int ONE_CHANNEL = 1;
 	public static final int TWO_CHANNELS = 2;
-	public static final int PCM_SAMPLE_SIZE_BITS = 16;
-	public static final int PCM_FRAME_SIZE_BYTES_MONO = 2;
-	public static final int PCM_FRAME_SIZE_BYTES_STEREO = 4;
-	
-	public static AudioFormat IMBE_AUDIO_FORMAT = 
-				new AudioFormat( IMBE_ENCODING, 
-								 IMBE_SAMPLE_RATE,
-								 IMBE_SAMPLE_SIZE_BITS,
-								 ONE_CHANNEL, 
-								 IMBE_FRAME_SIZE_BYTES, 
-								 IMBE_FRAME_RATE,
-								 LITTLE_ENDIAN );
-	
-	public static AudioFormat PCM_SIGNED_8KHZ_16BITS_MONO =
-						new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, 
-								 PCM_8KHZ_RATE,
-								 PCM_SAMPLE_SIZE_BITS,
-								 ONE_CHANNEL, 
-								 PCM_FRAME_SIZE_BYTES_MONO, 
-								 PCM_8KHZ_RATE,
-								 LITTLE_ENDIAN );
+	public static final int PCM_SAMPLE_SIZE_16_BITS = 16;
+	public static final int PCM_SAMPLE_SIZE_32_BITS = 32;
+	public static final int PCM_FRAME_SIZE_BYTES_16_BIT_MONO = 2;
+	public static final int PCM_FRAME_SIZE_BYTES_32_BIT_MONO = 4;
+	public static final int PCM_FRAME_SIZE_BYTES_16_BIT_STEREO = 4;
 
-	public static AudioFormat PCM_SIGNED_8KHZ_16BITS_STEREO =
-			new AudioFormat( AudioFormat.Encoding.PCM_SIGNED,
-					PCM_8KHZ_RATE,
-					PCM_SAMPLE_SIZE_BITS,
-					TWO_CHANNELS,
-					PCM_FRAME_SIZE_BYTES_STEREO,
-					PCM_8KHZ_RATE,
+	public static AudioFormat PCM_SIGNED_8000_HZ_32_BIT_MONO = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED,
+					PCM_8_KHZ_RATE,
+					PCM_SAMPLE_SIZE_32_BITS,
+					ONE_CHANNEL,
+					PCM_FRAME_SIZE_BYTES_32_BIT_MONO,
+					PCM_8_KHZ_RATE,
+					LITTLE_ENDIAN );
+
+	public static AudioFormat PCM_SIGNED_8000_HZ_16_BIT_MONO = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED,
+					PCM_8_KHZ_RATE,
+					PCM_SAMPLE_SIZE_16_BITS,
+					ONE_CHANNEL,
+					PCM_FRAME_SIZE_BYTES_16_BIT_MONO,
+					PCM_8_KHZ_RATE,
+					LITTLE_ENDIAN );
+
+	public static AudioFormat PCM_SIGNED_16000_HZ_16_BIT_MONO = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED,
+					PCM_16_KHZ_RATE,
+					PCM_SAMPLE_SIZE_16_BITS,
+					ONE_CHANNEL,
+					PCM_FRAME_SIZE_BYTES_16_BIT_MONO,
+					PCM_16_KHZ_RATE,
+					LITTLE_ENDIAN );
+
+	public static AudioFormat PCM_SIGNED_16000_HZ_32_BIT_MONO = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED,
+					PCM_16_KHZ_RATE,
+					PCM_SAMPLE_SIZE_32_BITS,
+					ONE_CHANNEL,
+					PCM_FRAME_SIZE_BYTES_32_BIT_MONO,
+					PCM_16_KHZ_RATE,
+					LITTLE_ENDIAN );
+
+	public static AudioFormat PCM_SIGNED_22050_HZ_16_BIT_MONO = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED,
+					PCM_22050_HZ_RATE,
+					PCM_SAMPLE_SIZE_16_BITS,
+					ONE_CHANNEL,
+					PCM_FRAME_SIZE_BYTES_16_BIT_MONO,
+					PCM_22050_HZ_RATE,
+					LITTLE_ENDIAN );
+
+	public static AudioFormat PCM_SIGNED_22050_HZ_32_BIT_MONO = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED,
+					PCM_22050_HZ_RATE,
+					PCM_SAMPLE_SIZE_32_BITS,
+					ONE_CHANNEL,
+					PCM_FRAME_SIZE_BYTES_32_BIT_MONO,
+					PCM_22050_HZ_RATE,
+					LITTLE_ENDIAN );
+
+	public static AudioFormat PCM_SIGNED_44100_HZ_16_BIT_MONO = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED,
+					PCM_44100_HZ_RATE,
+					PCM_SAMPLE_SIZE_16_BITS,
+					ONE_CHANNEL,
+					PCM_FRAME_SIZE_BYTES_16_BIT_MONO,
+					PCM_44100_HZ_RATE,
+					LITTLE_ENDIAN );
+
+	public static AudioFormat PCM_SIGNED_44100_HZ_32_BIT_MONO = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED,
+					PCM_44100_HZ_RATE,
+					PCM_SAMPLE_SIZE_32_BITS,
+					ONE_CHANNEL,
+					PCM_FRAME_SIZE_BYTES_32_BIT_MONO,
+					PCM_44100_HZ_RATE,
+					LITTLE_ENDIAN );
+
+	public static AudioFormat PCM_SIGNED_8000_HZ_16BITS_STEREO = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED,
+					PCM_8_KHZ_RATE,
+					PCM_SAMPLE_SIZE_16_BITS,
+					TWO_CHANNELS,
+					PCM_FRAME_SIZE_BYTES_16_BIT_STEREO,
+					PCM_8_KHZ_RATE,
 					LITTLE_ENDIAN );
 
-	public static AudioFormat PCM_SIGNED_48KHZ_16BITS_MONO =
-						new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, 
-								 PCM_48KHZ_RATE,
-								 PCM_SAMPLE_SIZE_BITS,
-								 ONE_CHANNEL, 
-								 PCM_FRAME_SIZE_BYTES_MONO, 
-								 PCM_48KHZ_RATE,
-								 LITTLE_ENDIAN );
-	
-	public static AudioFormat PCM_SIGNED_48KHZ_16BITS_STEREO =
-						new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, 
-								 PCM_48KHZ_RATE,
-								 PCM_SAMPLE_SIZE_BITS,
-								 TWO_CHANNELS, 
-								 PCM_FRAME_SIZE_BYTES_STEREO, 
-								 PCM_48KHZ_RATE,
-								 LITTLE_ENDIAN );
-	
 	/**
 	 * Source Data Line Info for a 48 kHz, 16-bits signed PCM one channel
 	 */
 	public static final Line.Info MONO_SOURCE_DATALINE_INFO = 
-		new DataLine.Info( SourceDataLine.class, PCM_SIGNED_8KHZ_16BITS_MONO);
+		new DataLine.Info( SourceDataLine.class, PCM_SIGNED_8000_HZ_16_BIT_MONO);
 	
 	/**
 	 * Source Data Line Info for a 48 kHz, 16-bits signed PCM two channels
 	 */
 	public static final Line.Info STEREO_SOURCE_DATALINE_INFO = 
-		new DataLine.Info( SourceDataLine.class, PCM_SIGNED_8KHZ_16BITS_STEREO);
+		new DataLine.Info( SourceDataLine.class, PCM_SIGNED_8000_HZ_16BITS_STEREO);
 }

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

@@ -1,23 +1,20 @@
 /*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 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;
 
@@ -25,13 +22,13 @@ import io.github.dsheirer.alias.AliasList;
 import io.github.dsheirer.audio.squelch.ISquelchStateListener;
 import io.github.dsheirer.audio.squelch.SquelchState;
 import io.github.dsheirer.audio.squelch.SquelchStateEvent;
+import io.github.dsheirer.dsp.filter.FilterFactory;
 import io.github.dsheirer.dsp.filter.design.FilterDesignException;
 import io.github.dsheirer.dsp.filter.fir.FIRFilterSpecification;
-import io.github.dsheirer.dsp.filter.fir.real.RealFIRFilter2;
+import io.github.dsheirer.dsp.filter.fir.real.IRealFilter;
 import io.github.dsheirer.dsp.filter.fir.remez.RemezFIRFilterDesigner;
 import io.github.dsheirer.sample.Listener;
-import io.github.dsheirer.sample.buffer.IReusableBufferListener;
-import io.github.dsheirer.sample.buffer.ReusableFloatBuffer;
+import io.github.dsheirer.sample.real.IRealBufferListener;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -41,8 +38,8 @@ import org.slf4j.LoggerFactory;
  *
  * Incorporates audio squelch state listener to control if audio packets are broadcast or ignored.
  */
-public class AudioModule extends AbstractAudioModule implements ISquelchStateListener, IReusableBufferListener,
-    Listener<ReusableFloatBuffer>
+public class AudioModule extends AbstractAudioModule implements ISquelchStateListener, IRealBufferListener,
+    Listener<float[]>
 {
     private static final Logger mLog = LoggerFactory.getLogger(AudioModule.class);
     private static float[] sHighPassFilterCoefficients;
@@ -73,7 +70,7 @@ public class AudioModule extends AbstractAudioModule implements ISquelchStateLis
         }
     }
 
-    private RealFIRFilter2 mHighPassFilter = new RealFIRFilter2(sHighPassFilterCoefficients);
+    private IRealFilter mHighPassFilter = FilterFactory.getRealFilter(sHighPassFilterCoefficients);
     private SquelchStateListener mSquelchStateListener = new SquelchStateListener();
     private SquelchState mSquelchState = SquelchState.SQUELCH;
 
@@ -120,22 +117,17 @@ public class AudioModule extends AbstractAudioModule implements ISquelchStateLis
     }
 
     @Override
-    public void receive(ReusableFloatBuffer audioBuffer)
+    public void receive(float[] audioBuffer)
     {
         if(mSquelchState == SquelchState.UNSQUELCH)
         {
-            ReusableFloatBuffer highPassFilteredAudio = mHighPassFilter.filter(audioBuffer);
-            addAudio(highPassFilteredAudio.getSamplesCopy());
-            highPassFilteredAudio.decrementUserCount();
-        }
-        else
-        {
-            audioBuffer.decrementUserCount();
+            audioBuffer = mHighPassFilter.filter(audioBuffer);
+            addAudio(audioBuffer);
         }
     }
 
     @Override
-    public Listener<ReusableFloatBuffer> getReusableBufferListener()
+    public Listener<float[]> getBufferListener()
     {
         //Redirect received reusable buffers to the receive(buffer) method
         return this;

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

@@ -1,6 +1,6 @@
 /*
  * *****************************************************************************
- *  Copyright (C) 2014-2020 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
@@ -20,7 +20,6 @@ package io.github.dsheirer.audio;
 
 import io.github.dsheirer.sample.Broadcaster;
 import io.github.dsheirer.sample.Listener;
-import io.github.dsheirer.sample.buffer.AbstractReusableBuffer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 

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

@@ -1,18 +1,21 @@
-/*******************************************************************************
- * sdr-trunk
- * Copyright (C) 2014-2018 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  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;
 
 import io.github.dsheirer.sample.ConversionUtils;
@@ -75,5 +78,4 @@ public class AudioUtils
 
         return stream.toByteArray();
     }
-
 }

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

@@ -1,27 +1,26 @@
 /*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 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.broadcast;
 
 import io.github.dsheirer.audio.convert.ISilenceGenerator;
+import io.github.dsheirer.audio.convert.InputAudioFormat;
+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;
@@ -31,6 +30,7 @@ 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;
@@ -73,12 +73,13 @@ public abstract class AudioStreamingBroadcaster<T extends BroadcastConfiguration
      * The last audio packet's metadata is automatically attached to the closed audio recording when it is enqueued for
      * broadcast.  That metadata will be updated on the remote server once the audio recording is opened for streaming.
      */
-    public AudioStreamingBroadcaster(T broadcastConfiguration)
+    public AudioStreamingBroadcaster(T broadcastConfiguration, InputAudioFormat inputAudioFormat, MP3Setting mp3Setting)
     {
         super(broadcastConfiguration);
         mDelay = getBroadcastConfiguration().getDelay();
         mMaximumRecordingAge = getBroadcastConfiguration().getMaximumRecordingAge();
-        mSilenceGenerator = BroadcastFactory.getSilenceGenerator(broadcastConfiguration.getBroadcastFormat());
+        mSilenceGenerator = BroadcastFactory.getSilenceGenerator(broadcastConfiguration.getBroadcastFormat(),
+                inputAudioFormat, mp3Setting);
     }
 
     public void dispose()
@@ -279,7 +280,13 @@ public abstract class AudioStreamingBroadcaster<T extends BroadcastConfiguration
                     {
                         if(mFinalSilencePadding > 0)
                         {
-                            broadcastAudio(mSilenceGenerator.generate(mFinalSilencePadding));
+                            List<byte[]> finalSilence = mSilenceGenerator.generate(mFinalSilencePadding);
+
+                            for(byte[] silence: finalSilence)
+                            {
+                                broadcastAudio(silence);
+                            }
+
                             mFinalSilencePadding = 0;
                         }
 
@@ -312,7 +319,11 @@ public abstract class AudioStreamingBroadcaster<T extends BroadcastConfiguration
                     }
                     else
                     {
-                        broadcastAudio(mSilenceGenerator.generate(PROCESSOR_RUN_INTERVAL_MS));
+                        List<byte[]> silenceFrames = mSilenceGenerator.generate(PROCESSOR_RUN_INTERVAL_MS);
+                        for(byte[] silence: silenceFrames)
+                        {
+                            broadcastAudio(silence);
+                        }
                     }
                 }
                 catch(Throwable t)

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

@@ -1,6 +1,6 @@
 /*
  * *****************************************************************************
- *  Copyright (C) 2014-2020 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
@@ -150,7 +150,7 @@ public class AudioStreamingManager implements Listener<AudioSegment>
 
                     try
                     {
-                        AudioSegmentRecorder.record(audioSegment, path, RecordFormat.MP3);
+                        AudioSegmentRecorder.record(audioSegment, path, RecordFormat.MP3, mUserPreferences);
                         IdentifierCollection identifierCollectionCopy =
                             new IdentifierCollection(audioSegment.getIdentifierCollection().getIdentifiers());
 

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

@@ -1,23 +1,20 @@
 /*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 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.broadcast;
 
@@ -35,8 +32,11 @@ import io.github.dsheirer.audio.broadcast.shoutcast.v2.ShoutcastV2AudioStreaming
 import io.github.dsheirer.audio.broadcast.shoutcast.v2.ShoutcastV2Configuration;
 import io.github.dsheirer.audio.convert.IAudioConverter;
 import io.github.dsheirer.audio.convert.ISilenceGenerator;
+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.audio.convert.MP3SilenceGenerator;
+import io.github.dsheirer.preference.UserPreferences;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -44,42 +44,44 @@ public class BroadcastFactory
 {
     private final static Logger mLog = LoggerFactory.getLogger(BroadcastFactory.class);
 
-    public static final int MP3_MONO_16_KHZ_BITRATE = 16;
-    public static final boolean MP3_CONSTANT_BITRATE = false;
-
     /**
      * Creates an audio streaming broadcaster for the configuration
      *
      * @param configuration describing the server and audio types
      * @return configured broadcaster or null
      */
-    public static AbstractAudioBroadcaster getBroadcaster(BroadcastConfiguration configuration, AliasModel aliasModel)
+    public static AbstractAudioBroadcaster getBroadcaster(BroadcastConfiguration configuration, AliasModel aliasModel,
+                                                          UserPreferences userPreferences)
     {
         if(configuration != null)
         {
-            IAudioConverter converter = getAudioConverter(configuration);
+            InputAudioFormat inputAudioFormat = userPreferences.getMP3Preference().getAudioSampleRate();
+            MP3Setting mp3Setting = userPreferences.getMP3Preference().getMP3Setting();
 
-            if(converter != null)
+            switch(configuration.getBroadcastServerType())
             {
-                switch(configuration.getBroadcastServerType())
-                {
-                    case BROADCASTIFY_CALL:
-                        return new BroadcastifyCallBroadcaster((BroadcastifyCallConfiguration)configuration, aliasModel);
-                    case BROADCASTIFY:
-                        return new IcecastTCPAudioBroadcaster((BroadcastifyFeedConfiguration) configuration, aliasModel);
-                    case ICECAST_TCP:
-                        return new IcecastTCPAudioBroadcaster((IcecastTCPConfiguration) configuration, aliasModel);
-                    case ICECAST_HTTP:
-                        return new IcecastHTTPAudioBroadcaster((IcecastHTTPConfiguration) configuration, aliasModel);
-                    case SHOUTCAST_V1:
-                        return new ShoutcastV1AudioBroadcaster((ShoutcastV1Configuration) configuration, aliasModel);
-                    case SHOUTCAST_V2:
-                        return new ShoutcastV2AudioStreamingBroadcaster((ShoutcastV2Configuration) configuration, aliasModel);
-                    case UNKNOWN:
-                    default:
-                        mLog.info("Unrecognized broadcastAudio configuration: " + configuration.getBroadcastFormat().name());
-                        break;
-                }
+                case BROADCASTIFY_CALL:
+                    return new BroadcastifyCallBroadcaster((BroadcastifyCallConfiguration)configuration,
+                            inputAudioFormat, mp3Setting, aliasModel);
+                case BROADCASTIFY:
+                    return new IcecastTCPAudioBroadcaster((BroadcastifyFeedConfiguration) configuration,
+                            inputAudioFormat, mp3Setting, aliasModel);
+                case ICECAST_TCP:
+                    return new IcecastTCPAudioBroadcaster((IcecastTCPConfiguration) configuration, inputAudioFormat,
+                            mp3Setting, aliasModel);
+                case ICECAST_HTTP:
+                    return new IcecastHTTPAudioBroadcaster((IcecastHTTPConfiguration) configuration, inputAudioFormat,
+                            mp3Setting, aliasModel);
+                case SHOUTCAST_V1:
+                    return new ShoutcastV1AudioBroadcaster((ShoutcastV1Configuration) configuration, inputAudioFormat,
+                            mp3Setting, aliasModel);
+                case SHOUTCAST_V2:
+                    return new ShoutcastV2AudioStreamingBroadcaster((ShoutcastV2Configuration) configuration,
+                            inputAudioFormat, mp3Setting, aliasModel);
+                case UNKNOWN:
+                default:
+                    mLog.info("Unrecognized broadcastAudio configuration: " + configuration.getBroadcastFormat().name());
+                    break;
             }
         }
 
@@ -92,12 +94,13 @@ public class BroadcastFactory
      * @param configuration containing the requested output audio format
      * @return audio convert or null
      */
-    public static IAudioConverter getAudioConverter(BroadcastConfiguration configuration)
+    public static IAudioConverter getAudioConverter(BroadcastConfiguration configuration, InputAudioFormat inputAudioFormat,
+                                                    MP3Setting mp3Setting)
     {
         switch(configuration.getBroadcastFormat())
         {
             case MP3:
-                return new MP3AudioConverter(MP3_MONO_16_KHZ_BITRATE, MP3_CONSTANT_BITRATE);
+                return new MP3AudioConverter(inputAudioFormat, mp3Setting);
             default:
                 mLog.info("Unrecognized broadcastAudio format: " + configuration.getBroadcastFormat().name());
         }
@@ -137,12 +140,12 @@ public class BroadcastFactory
         return null;
     }
 
-    public static ISilenceGenerator getSilenceGenerator(BroadcastFormat format)
+    public static ISilenceGenerator getSilenceGenerator(BroadcastFormat format, InputAudioFormat inputAudioFormat, MP3Setting mp3Setting)
     {
         switch(format)
         {
             case MP3:
-                return new MP3SilenceGenerator();
+                return new MP3SilenceGenerator(inputAudioFormat, mp3Setting);
             default:
                 throw new IllegalArgumentException("Unrecognized broadcast format [" + format +
                     "] can't create silence generator");

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

@@ -1,23 +1,20 @@
 /*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 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.broadcast;
 
@@ -34,7 +31,7 @@ import javafx.collections.ObservableList;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import javax.swing.ImageIcon;
+import javax.swing.*;
 import javax.swing.table.AbstractTableModel;
 import java.io.IOException;
 import java.nio.file.DirectoryStream;
@@ -80,6 +77,7 @@ public class BroadcastModel extends AbstractTableModel implements Listener<Audio
     private AliasModel mAliasModel;
     private Broadcaster<BroadcastEvent> mBroadcastEventBroadcaster = new Broadcaster<>();
     private BroadcastEventListener mBroadcastEventListener = new BroadcastEventListener();
+    private UserPreferences mUserPreferences;
 
     /**
      * Model for managing Broadcast configurations and any associated broadcaster instances.
@@ -88,6 +86,7 @@ public class BroadcastModel extends AbstractTableModel implements Listener<Audio
     {
         mAliasModel = aliasModel;
         mIconModel = iconModel;
+        mUserPreferences = userPreferences;
 
         //Monitor to remove temporary recording files that have been streamed by all audio broadcasters
         ThreadPool.SCHEDULED.scheduleAtFixedRate(new RecordingDeletionMonitor(), 15l, 15l, TimeUnit.SECONDS);
@@ -346,7 +345,8 @@ public class BroadcastModel extends AbstractTableModel implements Listener<Audio
                 deleteBroadcaster(configuredBroadcast);
             }
 
-            AbstractAudioBroadcaster audioBroadcaster = BroadcastFactory.getBroadcaster(broadcastConfiguration, mAliasModel);
+            AbstractAudioBroadcaster audioBroadcaster = BroadcastFactory.getBroadcaster(broadcastConfiguration,
+                    mAliasModel, mUserPreferences);
 
             if(audioBroadcaster != null)
             {

src/main/java/io/github/dsheirer/audio/broadcast/broadcastify/BroadcastifyCallBroadcaster.java

@@ -1,6 +1,6 @@
 /*
  * *****************************************************************************
- *  Copyright (C) 2014-2020 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
@@ -25,6 +25,8 @@ import io.github.dsheirer.audio.broadcast.AbstractAudioBroadcaster;
 import io.github.dsheirer.audio.broadcast.AudioRecording;
 import io.github.dsheirer.audio.broadcast.BroadcastEvent;
 import io.github.dsheirer.audio.broadcast.BroadcastState;
+import io.github.dsheirer.audio.convert.InputAudioFormat;
+import io.github.dsheirer.audio.convert.MP3Setting;
 import io.github.dsheirer.gui.playlist.radioreference.RadioReferenceDecoder;
 import io.github.dsheirer.identifier.Form;
 import io.github.dsheirer.identifier.Identifier;
@@ -81,7 +83,8 @@ public class BroadcastifyCallBroadcaster extends AbstractAudioBroadcaster<Broadc
      * @param config to use
      * @param aliasModel for access to aliases
      */
-    public BroadcastifyCallBroadcaster(BroadcastifyCallConfiguration config, AliasModel aliasModel)
+    public BroadcastifyCallBroadcaster(BroadcastifyCallConfiguration config, InputAudioFormat inputAudioFormat,
+                                       MP3Setting mp3Setting, AliasModel aliasModel)
     {
         super(config);
     }
@@ -417,38 +420,48 @@ public class BroadcastifyCallBroadcaster extends AbstractAudioBroadcaster<Broadc
     {
         List<Identifier> toIdentifiers = audioRecording.getIdentifierCollection().getIdentifiers(Role.TO);
 
-        if(toIdentifiers.size() >= 1)
+        //Format a patch group first, if there are multiples
+        for(Identifier identifier: toIdentifiers)
         {
-            Identifier to = toIdentifiers.get(0);
-
-            if(to instanceof TalkgroupIdentifier)
+            if(identifier instanceof PatchGroupIdentifier patchGroupIdentifier)
+            {
+                return format(patchGroupIdentifier);
+            }
+        }
+
+        for(Identifier identifier: toIdentifiers)
+        {
+            if(identifier instanceof TalkgroupIdentifier talkgroupIdentifier)
             {
-                TalkgroupIdentifier talkgroupIdentifier = (TalkgroupIdentifier)to;
                 return String.valueOf(RadioReferenceDecoder.convertToRadioReferenceTalkgroup(talkgroupIdentifier.getValue(),
-                    talkgroupIdentifier.getProtocol()));
+                        talkgroupIdentifier.getProtocol()));
             }
-            else if(to instanceof PatchGroupIdentifier)
+            else if(identifier instanceof RadioIdentifier radioIdentifier)
             {
-                PatchGroup patchGroup = ((PatchGroupIdentifier)to).getValue();
-
-                StringBuilder sb = new StringBuilder();
-                sb.append(patchGroup.getPatchGroup().getValue().toString());
-                for(TalkgroupIdentifier patched: patchGroup.getPatchedGroupIdentifiers())
-                {
-                    sb.append(",").append(patched.getValue());
-                }
-
-                return sb.toString();
-            }
-            else if(to instanceof RadioIdentifier)
-            {
-                return ((RadioIdentifier)to).getValue().toString();
+                return radioIdentifier.getValue().toString();
             }
         }
 
         return "0";
     }
 
+    /**
+     * Formats a patch group
+     */
+    public static String format(PatchGroupIdentifier patchGroupIdentifier)
+    {
+        PatchGroup patchGroup = patchGroupIdentifier.getValue();
+
+        StringBuilder sb = new StringBuilder();
+        sb.append(patchGroup.getPatchGroup().getValue().toString());
+        for(TalkgroupIdentifier patched: patchGroup.getPatchedGroupIdentifiers())
+        {
+            sb.append(",").append(patched.getValue());
+        }
+
+        return sb.toString();
+    }
+
     /**
      * Tests both the connection and configuration against the Broadcastify Call API service
      * @param configuration containing API key and system id

src/main/java/io/github/dsheirer/audio/broadcast/icecast/IcecastAudioBroadcaster.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,23 +14,26 @@
  *
  * 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.icecast;
 
 import io.github.dsheirer.alias.AliasModel;
 import io.github.dsheirer.audio.broadcast.AudioStreamingBroadcaster;
 import io.github.dsheirer.audio.broadcast.BroadcastConfiguration;
 import io.github.dsheirer.audio.broadcast.IBroadcastMetadataUpdater;
+import io.github.dsheirer.audio.convert.InputAudioFormat;
+import io.github.dsheirer.audio.convert.MP3Setting;
 
 public abstract class IcecastAudioBroadcaster extends AudioStreamingBroadcaster
 {
     private IBroadcastMetadataUpdater mMetadataUpdater;
     private AliasModel mAliasModel;
 
-    public IcecastAudioBroadcaster(BroadcastConfiguration broadcastConfiguration, AliasModel aliasModel)
+    public IcecastAudioBroadcaster(BroadcastConfiguration broadcastConfiguration, InputAudioFormat inputAudioFormat,
+                                   MP3Setting mp3Setting, AliasModel aliasModel)
     {
-        super(broadcastConfiguration);
+        super(broadcastConfiguration, inputAudioFormat, mp3Setting);
         mAliasModel = aliasModel;
     }
 

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

@@ -1,23 +1,20 @@
 /*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 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.broadcast.icecast;
 
@@ -100,7 +97,7 @@ public class IcecastBroadcastMetadataUpdater implements IBroadcastMetadataUpdate
             final String metadataUpdateURL = sb.toString();
             URI uri = URI.create(metadataUpdateURL);
 
-            ThreadPool.SCHEDULED.submit(new Runnable()
+            ThreadPool.CACHED.submit(new Runnable()
             {
                 @Override
                 public void run()

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

@@ -1,29 +1,28 @@
 /*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 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.broadcast.icecast;
 
 import io.github.dsheirer.alias.AliasModel;
 import io.github.dsheirer.audio.broadcast.BroadcastState;
+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.properties.SystemProperties;
 import io.github.dsheirer.util.ThreadPool;
 import org.apache.mina.core.RuntimeIoException;
@@ -45,7 +44,6 @@ import java.net.ConnectException;
 import java.net.InetSocketAddress;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 public class IcecastHTTPAudioBroadcaster extends IcecastAudioBroadcaster
@@ -72,9 +70,10 @@ public class IcecastHTTPAudioBroadcaster extends IcecastAudioBroadcaster
      *
      * @param configuration for the Icecast stream
      */
-    public IcecastHTTPAudioBroadcaster(IcecastHTTPConfiguration configuration, AliasModel aliasModel)
+    public IcecastHTTPAudioBroadcaster(IcecastHTTPConfiguration configuration, InputAudioFormat inputAudioFormat,
+                                       MP3Setting mp3Setting, AliasModel aliasModel)
     {
-        super(configuration, aliasModel);
+        super(configuration, inputAudioFormat, mp3Setting, aliasModel);
     }
 
     /**
@@ -164,8 +163,7 @@ public class IcecastHTTPAudioBroadcaster extends IcecastAudioBroadcaster
                 }
             };
 
-            ThreadPool.SCHEDULED.schedule(runnable, 0l, TimeUnit.SECONDS);
-
+            ThreadPool.CACHED.submit(runnable);
         }
 
         return connected();

src/main/java/io/github/dsheirer/audio/broadcast/icecast/IcecastTCPAudioBroadcaster.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,14 +14,16 @@
  *
  * 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.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.convert.InputAudioFormat;
 import io.github.dsheirer.audio.convert.MP3AudioConverter;
+import io.github.dsheirer.audio.convert.MP3Setting;
 import io.github.dsheirer.properties.SystemProperties;
 import io.github.dsheirer.util.ThreadPool;
 import org.apache.mina.core.RuntimeIoException;
@@ -66,9 +68,10 @@ public class IcecastTCPAudioBroadcaster extends IcecastAudioBroadcaster
      *
      * @param configuration for the Icecast stream
      */
-    public IcecastTCPAudioBroadcaster(IcecastTCPConfiguration configuration, AliasModel aliasModel)
+    public IcecastTCPAudioBroadcaster(IcecastTCPConfiguration configuration, InputAudioFormat inputAudioFormat,
+                                      MP3Setting mp3Setting, AliasModel aliasModel)
     {
-        super(configuration, aliasModel);
+        super(configuration, inputAudioFormat, mp3Setting, aliasModel);
     }
 
     /**
@@ -167,7 +170,7 @@ public class IcecastTCPAudioBroadcaster extends IcecastAudioBroadcaster
                 }
             };
 
-            ThreadPool.SCHEDULED.schedule(runnable, 0l, TimeUnit.SECONDS);
+            ThreadPool.CACHED.submit(runnable);
         }
 
         return connected();

src/main/java/io/github/dsheirer/audio/broadcast/shoutcast/v1/ShoutcastV1AudioBroadcaster.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,14 +14,16 @@
  *
  * 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.shoutcast.v1;
 
 import io.github.dsheirer.alias.AliasModel;
 import io.github.dsheirer.audio.broadcast.AudioStreamingBroadcaster;
 import io.github.dsheirer.audio.broadcast.BroadcastState;
 import io.github.dsheirer.audio.broadcast.IBroadcastMetadataUpdater;
+import io.github.dsheirer.audio.convert.InputAudioFormat;
+import io.github.dsheirer.audio.convert.MP3Setting;
 import io.github.dsheirer.util.ThreadPool;
 import org.apache.mina.core.RuntimeIoException;
 import org.apache.mina.core.buffer.IoBuffer;
@@ -37,7 +39,6 @@ import org.slf4j.LoggerFactory;
 import java.io.IOException;
 import java.net.ConnectException;
 import java.net.InetSocketAddress;
-import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 public class ShoutcastV1AudioBroadcaster extends AudioStreamingBroadcaster
@@ -62,9 +63,10 @@ public class ShoutcastV1AudioBroadcaster extends AudioStreamingBroadcaster
      *
      * @param configuration for the Shoutcast stream
      */
-    public ShoutcastV1AudioBroadcaster(ShoutcastV1Configuration configuration, AliasModel aliasModel)
+    public ShoutcastV1AudioBroadcaster(ShoutcastV1Configuration configuration, InputAudioFormat inputAudioFormat,
+                                       MP3Setting mp3Setting, AliasModel aliasModel)
     {
-        super(configuration);
+        super(configuration, inputAudioFormat, mp3Setting);
         mAliasModel = aliasModel;
     }
 
@@ -179,7 +181,7 @@ public class ShoutcastV1AudioBroadcaster extends AudioStreamingBroadcaster
                 }
             };
 
-            ThreadPool.SCHEDULED.schedule(runnable, 0l, TimeUnit.SECONDS);
+            ThreadPool.CACHED.submit(runnable);
         }
 
         return connected();

src/main/java/io/github/dsheirer/audio/broadcast/shoutcast/v1/ShoutcastV1BroadcastMetadataUpdater.java

@@ -1,23 +1,20 @@
 /*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 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.broadcast.shoutcast.v1;
 
@@ -53,7 +50,6 @@ import java.util.List;
 import java.util.Map;
 import java.util.Queue;
 import java.util.concurrent.LinkedTransferQueue;
-import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 public class ShoutcastV1BroadcastMetadataUpdater implements IBroadcastMetadataUpdater
@@ -138,7 +134,7 @@ public class ShoutcastV1BroadcastMetadataUpdater implements IBroadcastMetadataUp
 
                 if(updateRequest != null)
                 {
-                    ThreadPool.SCHEDULED.schedule(new Runnable()
+                    ThreadPool.CACHED.submit(new Runnable()
                     {
                         @Override
                         public void run()
@@ -176,7 +172,7 @@ public class ShoutcastV1BroadcastMetadataUpdater implements IBroadcastMetadataUp
                                 }
                             }
                         }
-                    }, 0l, TimeUnit.SECONDS);
+                    });
                 }
 
                 //Fetch next metadata update to send

src/main/java/io/github/dsheirer/audio/broadcast/shoutcast/v2/ShoutcastV2AudioStreamingBroadcaster.java

@@ -1,23 +1,20 @@
 /*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 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.broadcast.shoutcast.v2;
 
@@ -43,6 +40,8 @@ import io.github.dsheirer.audio.broadcast.shoutcast.v2.ultravox.UltravoxMessageF
 import io.github.dsheirer.audio.broadcast.shoutcast.v2.ultravox.UltravoxMessageType;
 import io.github.dsheirer.audio.broadcast.shoutcast.v2.ultravox.UltravoxMetadata;
 import io.github.dsheirer.audio.broadcast.shoutcast.v2.ultravox.UltravoxProtocolFactory;
+import io.github.dsheirer.audio.convert.InputAudioFormat;
+import io.github.dsheirer.audio.convert.MP3Setting;
 import io.github.dsheirer.identifier.Form;
 import io.github.dsheirer.identifier.Identifier;
 import io.github.dsheirer.identifier.IdentifierClass;
@@ -67,7 +66,6 @@ import java.net.InetSocketAddress;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.LinkedTransferQueue;
-import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 public class ShoutcastV2AudioStreamingBroadcaster extends AudioStreamingBroadcaster implements IBroadcastMetadataUpdater
@@ -95,9 +93,10 @@ public class ShoutcastV2AudioStreamingBroadcaster extends AudioStreamingBroadcas
      *
      * @param configuration for the Shoutcast V2 stream
      */
-    public ShoutcastV2AudioStreamingBroadcaster(ShoutcastV2Configuration configuration, AliasModel aliasModel)
+    public ShoutcastV2AudioStreamingBroadcaster(ShoutcastV2Configuration configuration, InputAudioFormat inputAudioFormat,
+                                                MP3Setting mp3Setting, AliasModel aliasModel)
     {
-        super(configuration);
+        super(configuration, inputAudioFormat, mp3Setting);
         mAliasModel = aliasModel;
     }
 
@@ -225,7 +224,7 @@ public class ShoutcastV2AudioStreamingBroadcaster extends AudioStreamingBroadcas
                 }
             };
 
-            ThreadPool.SCHEDULED.schedule(runnable, 0l, TimeUnit.SECONDS);
+            ThreadPool.CACHED.submit(runnable);
         }
 
         return connected();

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

@@ -1,23 +1,20 @@
 /*
+ * *****************************************************************************
+ * Copyright (C) 2014-2021 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;
@@ -27,6 +24,7 @@ import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.annotation.JsonPropertyOrder;
 import com.fasterxml.jackson.annotation.JsonRootName;
+import io.github.dsheirer.identifier.Identifier;
 import io.github.dsheirer.identifier.encryption.EncryptionKey;
 import io.github.dsheirer.module.decode.p25.audio.VoiceFrame;
 
@@ -132,6 +130,18 @@ public class MBECallSequence
         }
     }
 
+    /**
+     * Sets the from radio identifier
+     * @param identifier for from entity
+     */
+    public void setFromIdentifier(Identifier identifier)
+    {
+        if(identifier != null)
+        {
+            setFromIdentifier(identifier.toString());
+        }
+    }
+
     /**
      * Radio identifier that originated the call
      *
@@ -156,6 +166,18 @@ public class MBECallSequence
         }
     }
 
+    /**
+     * Sets the TO identifier
+     * @param identifier for the TO entity
+     */
+    public void setToIdentifier(Identifier identifier)
+    {
+        if(identifier != null)
+        {
+            setToIdentifier(identifier.toString());
+        }
+    }
+
     /**
      * Radio identifier that received the call
      *

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

@@ -0,0 +1,62 @@
+/*
+ * *****************************************************************************
+ * 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;
+
+/**
+ * MP3 Channel Mode
+ *
+ * see: http://www.mp3-tech.org/programmer/frame_header.html
+ */
+public enum ChannelMode
+{
+    STEREO("STEREO"),
+    JOINT_STEREO("JOINT STEREO"),
+    DUAL_CHANNEL("DUAL CHANNEL"),
+    MONO("MONO");
+
+    private String mLabel;
+
+    ChannelMode(String label)
+    {
+        mLabel = label;
+    }
+
+    public static ChannelMode fromValue(int value)
+    {
+        switch(value)
+        {
+            case 0:
+                return STEREO;
+            case 1:
+                return JOINT_STEREO;
+            case 2:
+                return DUAL_CHANNEL;
+            case 3:
+            default:
+                return MONO;
+        }
+    }
+
+    @Override
+    public String toString()
+    {
+        return mLabel;
+    }
+}

src/main/java/io/github/dsheirer/audio/convert/IAudioConverter.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.convert;
 
 import java.util.List;
@@ -25,11 +25,11 @@ public interface IAudioConverter
     /**
      * Converts the PCM audio packets to converted audio format.  May produce partial audio frame data.
      */
-    public byte[] convert(List<float[]> audioBuffers);
+    List<byte[]> convert(List<float[]> audioBuffers);
 
     /**
      * Finalizes audio conversion by fully converting any partial frames left in the buffer and returning the
      * remaining bytes to produce a full frame.
      */
-    public byte[] flush();
+    List<byte[]> flush();
 }

src/main/java/io/github/dsheirer/audio/convert/ISilenceGenerator.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,11 +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.audio.convert;
 
+import java.util.List;
+
 public interface ISilenceGenerator
 {
-    byte[] generate(long duration);
+    List<byte[]> generate(long duration);
 }

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

@@ -0,0 +1,84 @@
+/*
+ * *****************************************************************************
+ * 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 io.github.dsheirer.audio.AudioFormats;
+
+import javax.sound.sampled.AudioFormat;
+
+/**
+ * Enumeration of MP3 input audio formats for mono audio.
+ */
+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_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)"),
+    SR_32_16000(AudioFormats.PCM_SIGNED_16000_HZ_32_BIT_MONO, "32-Bit 16000 Hz"),
+    SR_32_22050(AudioFormats.PCM_SIGNED_22050_HZ_32_BIT_MONO, "32-Bit 22050 Hz"),
+    SR_32_44100(AudioFormats.PCM_SIGNED_44100_HZ_32_BIT_MONO, "32-Bit 44100 Hz");
+
+    private AudioFormat mAudioFormat;
+    private String mLabel;
+
+    /**
+     * Constructs an instance
+     * @param audioFormat for the specified sample rate
+     */
+    InputAudioFormat(AudioFormat audioFormat, String label)
+    {
+        mAudioFormat = audioFormat;
+        mLabel = label;
+    }
+
+    /**
+     * Default sample rate
+     */
+    public static InputAudioFormat getDefault()
+    {
+        return SR_22050;
+    }
+
+    /**
+     * Audio format for the specified sample rate entry
+     */
+    public AudioFormat getAudioFormat()
+    {
+        return mAudioFormat;
+    }
+
+    /**
+     * Sample rate for the format
+     */
+    public double getSampleRate()
+    {
+        return getAudioFormat().getSampleRate();
+    }
+
+
+    @Override
+    public String toString()
+    {
+        return mLabel;
+    }
+}

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

@@ -0,0 +1,65 @@
+/*
+ * *****************************************************************************
+ * 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 io.github.dsheirer.dsp.filter.resample.RealResampler;
+import net.sourceforge.lame.lowlevel.LameEncoder;
+import net.sourceforge.lame.mp3.MPEGMode;
+
+/**
+ * Factory class to create and configure LAME MP3 encoder
+ */
+public class LameFactory
+{
+    /**
+     * Creates a LAME MP3 encoder using the specified input sample rate and MP3 settings
+     * @param input sample rate
+     * @param setting to apply to the encoder
+     * @return lame encoder
+     */
+    public static LameEncoder getLameEncoder(InputAudioFormat input, MP3Setting setting)
+    {
+        return switch(setting)
+        {
+            case CBR_16 -> new LameEncoder(input.getAudioFormat(), 16, MPEGMode.MONO, LameEncoder.DEFAULT_QUALITY, false);
+            case CBR_32 -> new LameEncoder(input.getAudioFormat(), 32, MPEGMode.MONO, LameEncoder.DEFAULT_QUALITY, false);
+            case ABR_56 -> new LameEncoder(input.getAudioFormat(), 56, MPEGMode.MONO, LameEncoder.DEFAULT_QUALITY, true);
+            case VBR_5 -> new LameEncoder(input.getAudioFormat(), LameEncoder.DEFAULT_BITRATE, MPEGMode.MONO, 5, true);
+            case VBR_7 -> new LameEncoder(input.getAudioFormat(), LameEncoder.DEFAULT_BITRATE, MPEGMode.MONO, 7, true);
+            default -> throw new IllegalArgumentException("Unrecognized MP3 setting: " + setting);
+        };
+    }
+
+    /**
+     * Creates a resampler to resample from 8 kHz default audio sample rate to the specified sample rate.
+     * @param sampleRate to resample to
+     * @return resampler.
+     */
+    public static RealResampler getResampler(InputAudioFormat sampleRate)
+    {
+        return switch(sampleRate)
+        {
+            case SR_16000, SR_32_16000 -> new RealResampler(8000, 16000, 4096, 512);
+            case SR_22050, SR_32_22050 -> new RealResampler(8000, 22050, 4096, 512);
+            case SR_44100, SR_32_44100 -> new RealResampler(8000, 44100, 4096, 512);
+            default -> throw new IllegalArgumentException("Unrecognized sample rate for resampling: " + sampleRate);
+        };
+    }
+}

src/main/java/io/github/dsheirer/audio/convert/MP3AudioConverter.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,113 +14,133 @@
  *
  * 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 io.github.dsheirer.audio.AudioFormats;
-import io.github.dsheirer.audio.AudioUtils;
+import io.github.dsheirer.dsp.filter.resample.RealResampler;
+import io.github.dsheirer.sample.ConversionUtils;
 import net.sourceforge.lame.lowlevel.LameEncoder;
 import net.sourceforge.lame.mp3.Lame;
-import net.sourceforge.lame.mp3.MPEGMode;
 import org.apache.commons.math3.util.FastMath;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.ByteArrayOutputStream;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 
+/**
+ * Converts PCM audio packets to Mono, MP3 encoded audio
+ */
 public class MP3AudioConverter implements IAudioConverter
 {
     private final static Logger mLog = LoggerFactory.getLogger( MP3AudioConverter.class );
     public static final int AUDIO_QUALITY = Lame.QUALITY_LOW;
     private LameEncoder mEncoder;
-    private ByteArrayOutputStream mMP3Stream = new ByteArrayOutputStream();
-    private byte[] mMP3Buffer;
+    private RealResampler mResampler;
+    private ByteArrayOutputStream mMP3EncodedFramesStream = new ByteArrayOutputStream();
+    private byte[] mOutputFramesBuffer;
+    private InputAudioFormat mInputAudioFormat;
 
     /**
-     * Converts PCM 8kHz 16-bit Little Endian audio packets to Mono, Low Quality MP3 compressed audio.
+     * Constructs an instance.
      *
-     * @param bitRate for converted MP3 audio
-     * @param variableBitRate (VBR) true or false for constant bit rate (CBR)
+     * @param inputAudioFormat for the desired input sample rate and bit size (resampled from default 8 kHz as needed)
+     * @param setting to configure the LAME encoder
      */
-    public MP3AudioConverter(int bitRate, boolean variableBitRate)
+    public MP3AudioConverter(InputAudioFormat inputAudioFormat, MP3Setting setting)
     {
-        mEncoder = new LameEncoder(AudioFormats.PCM_SIGNED_8KHZ_16BITS_MONO,
-                bitRate, MPEGMode.MONO, AUDIO_QUALITY, variableBitRate);
+        mInputAudioFormat = inputAudioFormat;
+        mEncoder = LameFactory.getLameEncoder(inputAudioFormat, setting);
 
-        mMP3Buffer = new byte[mEncoder.getPCMBufferSize()];
+        //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)
+        {
+            mResampler = LameFactory.getResampler(inputAudioFormat);
+        }
+
+        mOutputFramesBuffer = new byte[mEncoder.getPCMBufferSize()];
+    }
+
+    /**
+     * Converts the list of PCM audio packets to MP3 encoded.
+     * @param audioPackets of PCM audio sampled at 8 kHz
+     * @return encoded MP3 audio
+     */
+    public List<byte[]> convert(List<float[]> audioPackets)
+    {
+        List<byte[]> converted = new ArrayList<>();
+
+        if(mResampler != null)
+        {
+            audioPackets = mResampler.resample(audioPackets);
+        }
+
+        for(int x = 0; x < audioPackets.size(); x++)
+        {
+            byte[] bytesToEncode = null;
+
+            if(mInputAudioFormat.getAudioFormat().getSampleSizeInBits() == 16)
+            {
+                bytesToEncode = ConversionUtils.convertToSigned16BitSamples(audioPackets.get(x)).array();
+            }
+            else
+            {
+                bytesToEncode = ConversionUtils.convertToSigned32BitSamples(audioPackets.get(x)).array();
+            }
+
+            int bytesToEncodePointer = 0;
+
+            int inputChunkSize = FastMath.min(mOutputFramesBuffer.length, bytesToEncode.length);
+            int outputChunkSize = 0;
+
+            try
+            {
+                while(bytesToEncodePointer < bytesToEncode.length)
+                {
+                    outputChunkSize = mEncoder.encodeBuffer(bytesToEncode, bytesToEncodePointer, inputChunkSize, mOutputFramesBuffer);
+                    bytesToEncodePointer += inputChunkSize;
+                    inputChunkSize = FastMath.min(mOutputFramesBuffer.length, bytesToEncode.length - bytesToEncodePointer);
+
+                    if(outputChunkSize > 0)
+                    {
+                        converted.add(Arrays.copyOf(mOutputFramesBuffer, outputChunkSize));
+                    }
+                }
+            }
+            catch(Exception e)
+            {
+                mLog.error("There was an error converting audio to MP3: " + e.getMessage());
+            }
+        }
+
+        int finalChunkSize = mEncoder.encodeFinish(mOutputFramesBuffer);
+
+        if(finalChunkSize > 0)
+        {
+            converted.add(Arrays.copyOf(mOutputFramesBuffer, finalChunkSize));
+        }
+
+        return converted;
     }
 
     @Override
-    public byte[] convert(List<float[]> audioPackets)
-    {
-        mMP3Stream.reset();
-
-        byte[] pcmBytes = AudioUtils.convertTo16BitSamples(audioPackets);
-
-        int pcmBufferSize = FastMath.min(mMP3Buffer.length, pcmBytes.length);
-
-        int mp3BufferSize = 0;
-
-        int pcmBytesPosition = 0;
-
-        try
-        {
-            while (0 < (mp3BufferSize = mEncoder.encodeBuffer(pcmBytes, pcmBytesPosition, pcmBufferSize, mMP3Buffer)))
-            {
-                pcmBytesPosition += pcmBufferSize;
-                pcmBufferSize = FastMath.min(mMP3Buffer.length, pcmBytes.length - pcmBytesPosition);
-                mMP3Stream.write(mMP3Buffer, 0, mp3BufferSize);
-            }
-
-            return mMP3Stream.toByteArray();
-        }
-        catch(Exception e)
-        {
-            mLog.error("There was an error converting audio to MP3: " + e.getMessage());
-            return new byte[0];
-        }
-    }
-
-    public byte[] convertAudio(List<float[]> audioBuffers)
-    {
-        mMP3Stream.reset();
-
-        byte[] pcmBytes = AudioUtils.convert(audioBuffers);
-
-        int pcmBufferSize = FastMath.min(mMP3Buffer.length, pcmBytes.length);
-
-        int mp3BufferSize = 0;
-
-        int pcmBytesPosition = 0;
-
-        try
-        {
-            while (0 < (mp3BufferSize = mEncoder.encodeBuffer(pcmBytes, pcmBytesPosition, pcmBufferSize, mMP3Buffer)))
-            {
-                pcmBytesPosition += pcmBufferSize;
-                pcmBufferSize = FastMath.min(mMP3Buffer.length, pcmBytes.length - pcmBytesPosition);
-                mMP3Stream.write(mMP3Buffer, 0, mp3BufferSize);
-            }
-
-            return mMP3Stream.toByteArray();
-        }
-        catch(Exception e)
-        {
-            mLog.error("There was an error converting audio to MP3: " + e.getMessage());
-            return new byte[0];
-        }
-    }
-
-    @Override
-    public byte[] flush()
+    public List<byte[]> flush()
     {
         byte[] lastPartialFrame = new byte[mEncoder.getMP3BufferSize()];
 
         int length = mEncoder.encodeFinish(lastPartialFrame);
 
-        return Arrays.copyOf(lastPartialFrame, length);
+        byte[] frame = Arrays.copyOf(lastPartialFrame, length);
+
+        if(frame.length == 0)
+        {
+            return Collections.emptyList();
+        }
+
+        return Collections.singletonList(frame);
     }
 }

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

@@ -0,0 +1,55 @@
+/*
+ * *****************************************************************************
+ * 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;
+
+public class MP3BitRate
+{
+    private final static int[] MPEG_1_L3 = new int[]{0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320};
+    private final static int[] MPEG_2_L3 = new int[]{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160};
+    private final static int[] MPEG_2_5_L3 = new int[]{0, 8, 16, 24, 32, 40, 48, 56, 64};
+
+    public static int getLayer3BitRate(MPEGVersion version, int value)
+    {
+        switch(version)
+        {
+            case V_1:
+                if(0 <= value && value < MPEG_1_L3.length)
+                {
+                    return MPEG_1_L3[value];
+                }
+                break;
+            case V_2:
+                if(0 <= value && value < MPEG_2_L3.length)
+                {
+                    return MPEG_2_L3[value];
+                }
+                break;
+            case V_2_5:
+                if(0 <= value && value < MPEG_2_5_L3.length)
+                {
+                    return MPEG_2_5_L3[value];
+                }
+                break;
+            default:
+        }
+
+        return 0;
+    }
+}

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

@@ -1,6 +1,6 @@
-/*******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2017 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,73 +14,53 @@
  *
  * 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 org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.List;
+
 public class MP3FrameInspector
 {
     private final static Logger mLog = LoggerFactory.getLogger(MP3FrameInspector.class);
 
-    public static void inspect(byte[] frames)
+    public static void inspect(List<byte[]> frames)
     {
-        if(frames == null || frames.length == 0)
+        if(frames.isEmpty())
         {
+            mLog.info("No Frame Data!");
             return;
         }
 
-        if(frames.length % 144 != 0)
+        for(byte[] frame: frames)
         {
-            log("Frame byte array not multiple of 144 byte frame size - length:" + frames.length, frames);
-            return;
-        }
+            StringBuilder sb = new StringBuilder();
+            int frameCounter = 0;
 
-        //Check for erroneous frame sync
-        for(int x = 0; x < frames.length - 1; x++)
-        {
-            if(frames[x] == (byte)0xFF && (frames[x + 1] & 0xE0) == 0xE0 && (x % 144) != 0)
+            for(int x = 0; x < frame.length; x++)
             {
-                log("Bad frame sync detected at byte " + x + " in frame " + (x / 144), frames);
-                return;
-            }
-        }
+                if(MP3Header.isValid(frame, x))
+                {
+                    sb.append("\n").append(++frameCounter).append(": ");
+                    sb.append(MP3Header.inspect(frame, x)).append(" - ");
+                }
 
-        //Check MP3 headers
-
-//        log("Frames ...", frames);
-    }
-
-    private static void log(String message, byte[] frames)
-    {
-        StringBuilder sb = new StringBuilder();
-        sb.append(message).append("\n");
-
-        int frameCounter = 0;
-        sb.append(frameCounter++).append(" ");
-
-        for(int x = 0; x < frames.length; x++)
-        {
-            if(x > 0 && x % 144 == 0)
-            {
-                sb.append("\n");
-                sb.append(frameCounter++).append(" ");
+                sb.append(String.format("%02X ", frame[x]));
             }
 
-            sb.append(String.format("%02X ", frames[x]));
+            mLog.info(sb.toString());
         }
-
-        mLog.info(sb.toString());
     }
 
     public static void main(String[] args)
     {
         mLog.info("Starting ...");
-        MP3SilenceGenerator gen = new MP3SilenceGenerator();
+        MP3SilenceGenerator gen = new MP3SilenceGenerator(InputAudioFormat.SR_8000, MP3Setting.getDefault());
 
-        byte[] audio = gen.generate(173);
+        List<byte[]> audio = gen.generate(173);
 
         inspect(audio);
 

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

@@ -0,0 +1,115 @@
+/*
+ * *****************************************************************************
+ * 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;
+
+/**
+ * Utility class for inspecting/parsing MP3 frames
+ */
+public class MP3Header
+{
+    private MP3Header() {}
+
+    /**
+     * Indicates if the byte array at the offset has a valid MP3 frame sync and is at least 4 bytes long
+     * @param frame array of bytes
+     * @param offset into the array
+     * @return true if the first two offset bytes contain a frame sync and length from offset is at least 4
+     */
+    public static boolean isValid(byte[] frame, int offset)
+    {
+        return frame.length >= (offset + 4) && hasSync(frame, offset);
+    }
+
+    /**
+     * Indicates if the byte array at the offset has a valid MP3 frame sync
+     * @param frame array of bytes
+     * @param offset into the array
+     * @return true if the first two offset bytes contain a frame sync
+     */
+    public static boolean hasSync(byte[] frame, int offset)
+    {
+        return (frame[offset] & 0xFF) == 0xFF && (frame[offset + 1] & 0xE0) == 0xE0;
+    }
+
+    /**
+     * MPEG version for the frame
+     */
+    public static MPEGVersion getMPEGVersion(byte[] frame, int offset)
+    {
+        return MPEGVersion.fromValue((frame[offset + 1] & 0x18) >> 3);
+    }
+
+    /**
+     * MPEG layer for the frame.  Normally layer 3 for audio.
+     */
+    public static MPEGLayer getMPEGLayer(byte[] frame, int offset)
+    {
+        return MPEGLayer.fromValue((frame[offset + 1] & 0x6) >> 1);
+    }
+
+    /**
+     * MP3 bit rate
+     */
+    public static int getBitRate(byte[] frame, int offset)
+    {
+        return MP3BitRate.getLayer3BitRate(getMPEGVersion(frame, offset), (frame[offset + 2] & 0xF0) >> 4);
+    }
+
+    /**
+     * Input audio sample rate.
+     */
+    public static int getSampleRate(byte[] frame, int offset)
+    {
+        return MP3SampleRate.getSampleRate(getMPEGVersion(frame, offset), (frame[offset + 2] & 0x0C) >> 2);
+    }
+
+    /**
+     * Channel mode
+     */
+    public static ChannelMode getChannelMode(byte[] frame, int offset)
+    {
+        return ChannelMode.fromValue((frame[offset + 3] & 0xC0) >> 6);
+    }
+
+    /**
+     * Inspects the frame bytes and provides details about the header.
+     */
+    public static String inspect(byte[] frame, int offset)
+    {
+        StringBuilder sb = new StringBuilder();
+        sb.append("MP3 FRAME");
+
+        if(!isValid(frame, offset))
+        {
+            sb.append(" INVALID");
+            return sb.toString();
+        }
+
+        sb.append(" VER:").append(getMPEGVersion(frame, offset));
+        sb.append(" MODE:").append(getChannelMode(frame, offset));
+        sb.append(" ").append(getMPEGLayer(frame, offset));
+        sb.append(" BR:").append(getBitRate(frame, offset));
+        sb.append(" SR:").append(getSampleRate(frame, offset));
+
+        //TODO: add MONO/STEREO
+        
+        return sb.toString();
+    }
+}

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

@@ -0,0 +1,55 @@
+/*
+ * *****************************************************************************
+ * 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;
+
+public class MP3SampleRate
+{
+    private final static int[] MPEG_1 = new int[]{44100, 48000, 32000};
+    private final static int[] MPEG_2 = new int[]{22050, 24000, 16000};
+    private final static int[] MPEG2_5 = new int[]{11025, 12000, 8000};
+
+    public static int getSampleRate(MPEGVersion version, int value)
+    {
+        switch(version)
+        {
+            case V_1:
+                if(0 <= value && value < MPEG_1.length)
+                {
+                    return MPEG_1[value];
+                }
+                break;
+            case V_2:
+                if(0 <= value && value < MPEG_2.length)
+                {
+                    return MPEG_2[value];
+                }
+                break;
+            case V_2_5:
+                if(0 <= value && value < MPEG2_5.length)
+                {
+                    return MPEG2_5[value];
+                }
+                break;
+            default:
+        }
+
+        return 0;
+    }
+}

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

@@ -0,0 +1,87 @@
+/*
+ * *****************************************************************************
+ * 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 net.sourceforge.lame.mp3.Lame;
+
+/**
+ * MP3 encoder settings.
+ *
+ * A curated list of LAME audio encoder settings that are optimized for mono-channel voice that is originally
+ * sampled at 8,000 Hz.
+ *
+ * See: https://svn.code.sf.net/p/lame/svn/trunk/lame/doc/html/usage.html
+ */
+public enum MP3Setting
+{
+    CBR_16(false, 16, "CBR - Constant Bit Rate 16 kbps (default)"),
+    CBR_32(false, 32, "CBR - Constant Bit Rate 32 kbps"),
+    ABR_56(true, 56, "ABR - Average Bit Rate 56 kbps"),
+    VBR_5(true, Lame.QUALITY_MIDDLE, "VBR - Middle Quality (5)"),
+    VBR_7(true, Lame.QUALITY_LOW, "VBR - Low Quality (7)");
+
+    private boolean mVariableBitRate;
+    private int mSetting;
+    private String mLabel;
+
+    /**
+     * Constructs an instance
+     * @param variableBitRate flag
+     * @param setting for the entry
+     * @param label to display
+     */
+    MP3Setting(boolean variableBitRate, int setting, String label)
+    {
+        mVariableBitRate = variableBitRate;
+        mSetting = setting;
+        mLabel = label;
+    }
+
+    /**
+     * Default setting
+     */
+    public static MP3Setting getDefault()
+    {
+        return MP3Setting.CBR_16;
+    }
+
+    /**
+     * Indicates if the entry is Constant Bit Rate (CBR), or Average/Variable Bit Rate (ABR or VBR)
+     * @return true if CBR
+     */
+    public boolean isVariableBitRate()
+    {
+        return mVariableBitRate;
+    }
+
+    /**
+     * LAME encoder quality value
+     */
+    public int getSetting()
+    {
+        return mSetting;
+    }
+
+    @Override
+    public String toString()
+    {
+        return mLabel;
+    }
+}

src/main/java/io/github/dsheirer/audio/convert/MP3SilenceGenerator.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,15 +14,14 @@
  *
  * 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 org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 
 public class MP3SilenceGenerator implements ISilenceGenerator
@@ -31,47 +30,42 @@ public class MP3SilenceGenerator implements ISilenceGenerator
     public static final int MP3_BIT_RATE = 16;
     public static final boolean CONSTANT_BIT_RATE = false;
 
-    private MP3AudioConverter mGenerator = new MP3AudioConverter(MP3_BIT_RATE, CONSTANT_BIT_RATE);
+    private MP3AudioConverter mMP3AudioConverter;
+    private InputAudioFormat mInputAudioFormat;
     private byte[] mPreviousPartialFrameData;
 
     /**
      * Generates MP3 audio silence frames
      */
-    public MP3SilenceGenerator()
+    public MP3SilenceGenerator(InputAudioFormat inputAudioFormat, MP3Setting setting)
     {
+        mInputAudioFormat = inputAudioFormat;
+        mMP3AudioConverter = new MP3AudioConverter(inputAudioFormat, setting);
     }
 
-    public byte[] generate(long duration)
+    /**
+     * Generates silence frames
+     * @param duration_ms in milliseconds
+     * @return
+     */
+    public List<byte[]> generate(long duration_ms)
     {
-        int length = (int)(duration * 8);   //8000 Hz sample rate
+        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());
 
         List<float[]> silenceBuffers = new ArrayList<>();
-        silenceBuffers.add(new float[length]);
-        byte[] frameData = mGenerator.convert(silenceBuffers);
 
-        frameData = merge(mPreviousPartialFrameData, frameData);
-
-        if(frameData != null && frameData.length > 0)
+        int added = 0;
+        while(added < length)
         {
-            if(frameData.length < 144)
-            {
-                mPreviousPartialFrameData = frameData;
-                return null;
-            }
-            else if((frameData.length % 144) == 0)
-            {
-                mPreviousPartialFrameData = null;
-                return frameData;
-            }
-            else
-            {
-                int integralFrameLength = (int)(frameData.length / 144) * 144;
-                mPreviousPartialFrameData = Arrays.copyOfRange(frameData, integralFrameLength, frameData.length);
-                return Arrays.copyOf(frameData, integralFrameLength);
-            }
+            int chunk = Math.min(length - added, 256);
+            silenceBuffers.add(new float[chunk]);
+            added += chunk;
         }
 
-        return null;
+        return mMP3AudioConverter.convert(silenceBuffers);
     }
 
     private static byte[] merge(byte[] a, byte[] b)
@@ -100,19 +94,24 @@ public class MP3SilenceGenerator implements ISilenceGenerator
     {
         mLog.debug("Starting ...");
 
-        for(long x = 243; x < 500; x ++)
+        MP3SilenceGenerator generator = new MP3SilenceGenerator(InputAudioFormat.SR_44100, MP3Setting.VBR_7);
+
+        int x = 100;
+
+//        for(; x < 1000; x += 10)
+//        {
+        List<byte[]> silenceFrames = generator.generate(x);
+
+        mLog.debug("Generated [" + silenceFrames.size() + "] silence frames");
+
+        for(byte[] silence: silenceFrames)
         {
-            MP3SilenceGenerator generator = new MP3SilenceGenerator();
-
-            byte[] silence = generator.generate(x);
-
-            if(silence != null && silence.length > 0)
-            {
-                mLog.debug("Silence:" + x + " Length:" + silence.length);
-                MP3FrameInspector.inspect(silence);
-            }
+            mLog.debug("Silence:" + x + " Length:" + silence.length);
         }
 
+        MP3FrameInspector.inspect(silenceFrames);
+//        }
+
         mLog.debug("Finished");
     }
 }

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

@@ -0,0 +1,62 @@
+/*
+ * *****************************************************************************
+ * 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;
+
+/**
+ * MPEG Layer
+ *
+ * see: http://www.mp3-tech.org/programmer/frame_header.html
+ */
+public enum MPEGLayer
+{
+    RESERVED("LAYER-RESERVED"),
+    LAYER3("LAYER-3"),
+    LAYER2("LAYER-2"),
+    LAYER1("LAYER-1");
+
+    private String mLabel;
+
+    MPEGLayer(String label)
+    {
+        mLabel = label;
+    }
+
+    public static MPEGLayer fromValue(int value)
+    {
+        switch(value)
+        {
+            case 1:
+                return LAYER3;
+            case 2:
+                return LAYER2;
+            case 3:
+                return LAYER1;
+            default:
+            case 0:
+                return RESERVED;
+        }
+    }
+
+    @Override
+    public String toString()
+    {
+        return mLabel;
+    }
+}

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

@@ -0,0 +1,61 @@
+/*
+ * *****************************************************************************
+ * 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;
+
+/**
+ * MPEG Version
+ *
+ * see: http://www.mp3-tech.org/programmer/frame_header.html
+ */
+public enum MPEGVersion
+{
+    V_2_5("2.5"),
+    RESERVED("RESERVED"),
+    V_2("2"),
+    V_1("1");
+
+    private String mLabel;
+
+    MPEGVersion(String label)
+    {
+        mLabel = label;
+    }
+
+    public static MPEGVersion fromValue(int value)
+    {
+        switch(value)
+        {
+            case 0:
+                return V_2_5;
+            case 2:
+                return V_2;
+            case 3:
+                return V_1;
+            default:
+                return RESERVED;
+        }
+    }
+
+    @Override
+    public String toString()
+    {
+        return mLabel;
+    }
+}

src/main/java/io/github/dsheirer/audio/convert/thumbdv/ThumbDv.java

@@ -1,23 +1,20 @@
 /*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 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.convert.thumbdv;
@@ -36,8 +33,6 @@ import io.github.dsheirer.audio.convert.thumbdv.message.response.DecodeSpeechRes
 import io.github.dsheirer.audio.convert.thumbdv.message.response.ReadyResponse;
 import io.github.dsheirer.audio.convert.thumbdv.message.response.SetVocoderParameterResponse;
 import io.github.dsheirer.sample.Listener;
-import io.github.dsheirer.sample.buffer.ReusableBufferQueue;
-import io.github.dsheirer.sample.buffer.ReusableFloatBuffer;
 import io.github.dsheirer.util.ThreadPool;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -82,11 +77,10 @@ public class ThumbDv implements AutoCloseable
     private ScheduledFuture mAudioDecodeProcessorHandle;
     private LinkedTransferQueue<DecodeSpeechRequest> mDecodeSpeechRequests = new LinkedTransferQueue<>();
     private AudioProtocol mAudioProtocol;
-    private Listener<ReusableFloatBuffer> mAudioBufferListener;
-    private ReusableBufferQueue mReusableBufferQueue = new ReusableBufferQueue("ThumbDv");
+    private Listener<float[]> mAudioBufferListener;
     private boolean mStarted;
 
-    public ThumbDv(AudioProtocol audioProtocol, Listener<ReusableFloatBuffer> listener)
+    public ThumbDv(AudioProtocol audioProtocol, Listener<float[]> listener)
     {
         mAudioProtocol = audioProtocol;
         mAudioBufferListener = listener;
@@ -209,8 +203,7 @@ public class ThumbDv implements AutoCloseable
         if(message instanceof DecodeSpeechResponse && mAudioBufferListener != null)
         {
             float[] samples = ((DecodeSpeechResponse)message).getSamples();
-            ReusableFloatBuffer audioBuffer = mReusableBufferQueue.getBuffer(samples, System.currentTimeMillis());
-            mAudioBufferListener.receive(audioBuffer);
+            mAudioBufferListener.receive(samples);
         }
         else if(message instanceof ReadyResponse && mAudioDecodeProcessorHandle == null)
         {
@@ -456,9 +449,8 @@ public class ThumbDv implements AutoCloseable
 
         mLog.debug("Starting thumb dv thread(s)");
 
-        final Listener<ReusableFloatBuffer> listener = reusableAudioPacket -> {
+        final Listener<float[]> listener = packet -> {
             mLog.info("Got an audio packet!");
-            reusableAudioPacket.decrementUserCount();
         };
 
         try(ThumbDv thumbDv = new ThumbDv(AudioProtocol.P25_PHASE2, listener))

src/main/java/io/github/dsheirer/audio/invert/AudioAdapter.java

@@ -1,27 +1,28 @@
-/*******************************************************************************
- *     SDR Trunk 
- *     Copyright (C) 2014 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/>
- ******************************************************************************/
+/*
+ * *****************************************************************************
+ * 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.invert;
 
 import io.github.dsheirer.dsp.filter.FilterFactory;
 import io.github.dsheirer.dsp.filter.FloatFIRFilter;
-import io.github.dsheirer.dsp.filter.Window.WindowType;
-import io.github.dsheirer.dsp.mixer.IOscillator;
-import io.github.dsheirer.dsp.mixer.Oscillator;
+import io.github.dsheirer.dsp.oscillator.IRealOscillator;
+import io.github.dsheirer.dsp.oscillator.OscillatorFactory;
+import io.github.dsheirer.dsp.window.WindowType;
 
 /**
  * Based on the AudioType applied, produces normal, muted, or audio invert
@@ -30,7 +31,7 @@ import io.github.dsheirer.dsp.mixer.Oscillator;
 public class AudioAdapter
 {
 	private static int mGain = 5;
-	private IOscillator mSineWaveGenerator;
+	private IRealOscillator mSineWaveGenerator;
 	private FloatFIRFilter mPostInversionFilter;
 	private FloatFIRFilter mAudioHighPassFilter;
 	private AudioType mAudioType = AudioType.NORMAL;
@@ -39,7 +40,7 @@ public class AudioAdapter
 	public AudioAdapter( int sampleRate )
 	{
 		mSampleRate = sampleRate;
-		mSineWaveGenerator = new Oscillator( 3000, mSampleRate );
+		mSineWaveGenerator = OscillatorFactory.getRealOscillator(3000, mSampleRate );
 		mAudioHighPassFilter = new FloatFIRFilter( 
 				FilterFactory.getHighPass( mSampleRate, 200, 1600, 48, 
 						WindowType.HAMMING, true ), mGain );
@@ -58,7 +59,7 @@ public class AudioAdapter
 			
 			if( inversionFrequency != 0 )
 			{
-				mSineWaveGenerator.setFrequency( inversionFrequency );;
+				mSineWaveGenerator.setFrequency( inversionFrequency );
 			}
 		}
 	}
@@ -89,9 +90,7 @@ public class AudioAdapter
 			default:
 				retVal = (float)( mPostInversionFilter.get( 
 						mAudioHighPassFilter.get( sample ) * 
-						mSineWaveGenerator.inphase() ) );
-				
-				mSineWaveGenerator.rotate();
+						mSineWaveGenerator.generate(1)[0] ) );
 				break;
 		}
 		

src/main/java/io/github/dsheirer/audio/invert/AudioInverter.java

@@ -1,26 +1,26 @@
-/*******************************************************************************
- *     SDR Trunk 
- *     Copyright (C) 2014 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/>
- ******************************************************************************/
+/*
+ * *****************************************************************************
+ * 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.invert;
 
-import io.github.dsheirer.dsp.filter.Filters;
 import io.github.dsheirer.dsp.filter.FloatFIRFilter;
-import io.github.dsheirer.dsp.mixer.IOscillator;
-import io.github.dsheirer.dsp.mixer.Oscillator;
+import io.github.dsheirer.dsp.oscillator.IRealOscillator;
+import io.github.dsheirer.dsp.oscillator.OscillatorFactory;
 import io.github.dsheirer.sample.real.RealSampleListener;
 
 /**
@@ -29,17 +29,33 @@ import io.github.dsheirer.sample.real.RealSampleListener;
  */
 public class AudioInverter implements RealSampleListener
 {
-	private IOscillator mSineWaveGenerator;
+	private static final float[] LOW_PASS_FILTER = new float[] { -0.0052419787903715655f,
+			-0.0003789909443307852f,  0.0012970137854134386f,  0.004210460544067679f,
+			0.008221266221665309f,   0.012951576579356689f,   0.017794312853913318f,
+			0.021959871931790928f,   0.024583800118549094f,   0.024878144443784132f,
+			0.022296319647647538f,   0.016685495012933472f,   0.008390268267799136f,
+			-0.001718264469387386f,  -0.012288389660616603f,  -0.02161633130497537f,
+			-0.027882128567957774f, 	-0.02943377233328899f,	-0.025006516193566884f,
+			-0.014040074880106284f,   0.0032217508351258103f,  0.025660031586092195f,
+			0.05136009984280478f,    0.0778336106888181f,     0.10230926486919244f,
+			0.12209961841343948f,    0.13496813439824185f,    0.13943117253534673f,
+			0.13496813439824185f,    0.12209961841343948f,    0.10230926486919244f,
+			0.0778336106888181f,     0.05136009984280478f,    0.025660031586092195f,
+			0.0032217508351258103f, -0.014040074880106284f,  -0.025006516193566884f,
+			-0.02943377233328899f,   -0.027882128567957774f,  -0.02161633130497537f,
+			-0.012288389660616603f, 	-0.001718264469387386f,   0.008390268267799136f,
+			0.016685495012933472f,   0.022296319647647538f,   0.024878144443784132f,
+			0.024583800118549094f,   0.021959871931790928f,   0.017794312853913318f,
+			0.012951576579356689f,   0.008221266221665309f,   0.004210460544067679f,
+			0.0012970137854134386f, -0.0003789909443307852f, -0.0052419787903715655f };
+	private IRealOscillator mSineWaveGenerator;
 	private FloatFIRFilter mPostInversionLowPassFilter;
 	private RealSampleListener mListener;
 	
 	public AudioInverter( int inversionFrequency, int sampleRate )
 	{
-		mSineWaveGenerator = new Oscillator( inversionFrequency, sampleRate );
-		
-		mPostInversionLowPassFilter = new FloatFIRFilter( 
-				Filters.FIRLP_55TAP_48000FS_3000FC.getCoefficients(), 1.04f );
-
+		mSineWaveGenerator = OscillatorFactory.getRealOscillator( inversionFrequency, sampleRate );
+		mPostInversionLowPassFilter = new FloatFIRFilter(LOW_PASS_FILTER, 1.04f );
 		mPostInversionLowPassFilter.setListener( new FilteredSampleProcessor() );
 	}
 	
@@ -60,10 +76,7 @@ public class AudioInverter implements RealSampleListener
 		//the low pass filter
 		if( mPostInversionLowPassFilter != null )
 		{
-			mPostInversionLowPassFilter.receive( 
-					sample * mSineWaveGenerator.inphase() );
-			
-			mSineWaveGenerator.rotate();
+			mPostInversionLowPassFilter.receive(sample * mSineWaveGenerator.generate(1)[0] );
 		}
     }
 	

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

@@ -1,6 +1,6 @@
-/*******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2017 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.playback;
 
 import io.github.dsheirer.audio.AudioFormats;
@@ -36,7 +36,7 @@ public class MonoAudioOutput extends AudioOutput
 
     public MonoAudioOutput(Mixer mixer, UserPreferences userPreferences)
     {
-        super(mixer, MixerChannel.MONO, AudioFormats.PCM_SIGNED_8KHZ_16BITS_MONO,
+        super(mixer, MixerChannel.MONO, AudioFormats.PCM_SIGNED_8000_HZ_16_BIT_MONO,
             AudioFormats.MONO_SOURCE_DATALINE_INFO, BUFFER_SIZE, userPreferences);
     }
 

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

@@ -1,6 +1,6 @@
-/*******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2017 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.playback;
 
 import io.github.dsheirer.audio.AudioFormats;
@@ -36,7 +36,7 @@ public class StereoAudioOutput extends AudioOutput
 
     public StereoAudioOutput(Mixer mixer, MixerChannel channel, UserPreferences userPreferences)
     {
-        super(mixer, channel, AudioFormats.PCM_SIGNED_8KHZ_16BITS_STEREO, AudioFormats.STEREO_SOURCE_DATALINE_INFO,
+        super(mixer, channel, AudioFormats.PCM_SIGNED_8000_HZ_16BITS_STEREO, AudioFormats.STEREO_SOURCE_DATALINE_INFO,
             BUFFER_SIZE, userPreferences);
     }
 

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

@@ -0,0 +1,154 @@
+/*
+ * *****************************************************************************
+ * 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 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
+{
+    private static final int FRAGMENT_SIZE = 2048;
+    private final static float[] LOOKUP_VALUES;
+    private float mAverageDc;
+
+    //Creates a static lookup table that converts the 8-bit valued range from 0 - 255 into scaled float values
+    //of -1.0 to 0 to 1.0
+    static
+    {
+        LOOKUP_VALUES = new float[256];
+
+        for(int x = 0; x < 256; x++)
+        {
+            LOOKUP_VALUES[x] = (float)(x - 127) / 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
+     */
+    public ByteNativeBuffer(byte[] samples, long timestamp, float averageDc)
+    {
+        //Ensure we're an even multiple of the fragment size.  Typically, this will be 64k or 128k
+        if(samples.length % FRAGMENT_SIZE != 0)
+        {
+            throw new IllegalArgumentException("Samples byte[] length [" + samples.length + "] must be an even multiple of " + FRAGMENT_SIZE);
+        }
+
+        mSamples = samples;
+        mTimestamp = timestamp;
+        mAverageDc = averageDc;
+    }
+
+    @Override
+    public int sampleCount()
+    {
+        return mSamples.length / 2;
+    }
+
+    @Override
+    public long getTimestamp()
+    {
+        return mTimestamp;
+    }
+
+    @Override
+    public Iterator<ComplexSamples> iterator()
+    {
+        return new ComplexSamplesIterator();
+    }
+
+    @Override
+    public Iterator<InterleavedComplexSamples> iteratorInterleaved()
+    {
+        return new InterleavedComplexSamplesIterator();
+    }
+
+    private class ComplexSamplesIterator implements Iterator<ComplexSamples>
+    {
+        private int mSamplesPointer = 0;
+
+        @Override
+        public boolean hasNext()
+        {
+            return mSamplesPointer < mSamples.length;
+        }
+
+        @Override
+        public ComplexSamples next()
+        {
+            float[] i = new float[FRAGMENT_SIZE];
+            float[] q = new float[FRAGMENT_SIZE];
+            int samplesOffset = mSamplesPointer;
+
+            for(int pointer = 0; pointer < i.length; pointer++)
+            {
+                i[pointer] = LOOKUP_VALUES[(0xFF & mSamples[samplesOffset++])] - mAverageDc;
+                q[pointer] = LOOKUP_VALUES[(0xFF & mSamples[samplesOffset++])] - mAverageDc;
+            }
+
+            mSamplesPointer = samplesOffset;
+
+            return new ComplexSamples(i, q);
+        }
+    }
+
+    /**
+     * Iterator of interleaved complex samples over the native byte buffer array.
+     */
+    private class InterleavedComplexSamplesIterator implements Iterator<InterleavedComplexSamples>
+    {
+        private int mSamplesPointer = 0;
+
+        @Override
+        public boolean hasNext()
+        {
+            return mSamplesPointer < mSamples.length;
+        }
+
+        @Override
+        public InterleavedComplexSamples next()
+        {
+            float[] converted = new float[FRAGMENT_SIZE * 2];
+
+            int samplesPointer = mSamplesPointer;
+
+            for(int pointer = 0; pointer < converted.length; pointer++)
+            {
+                converted[pointer] = LOOKUP_VALUES[(0xFF & mSamples[samplesPointer++])] - mAverageDc;
+            }
+
+            mSamplesPointer = samplesPointer;
+
+            return new InterleavedComplexSamples(converted, mTimestamp);
+        }
+    }
+}

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

@@ -0,0 +1,61 @@
+/*
+ * *****************************************************************************
+ * 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.nio.ByteBuffer;
+
+/**
+ * Implements a factory for creating ByteNativeBuffer instances
+ */
+public class ByteNativeBufferFactory implements INativeBufferFactory
+{
+    private static final float DC_FILTER_GAIN = 0.007f; //Normalizes DC over period of ~142 (1 / .007) buffers
+    private float mAverageDc = 0.0f;
+
+    @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);
+    }
+
+    /**
+     * Calculates the average DC in the sample stream so that it can be subtracted from the samples when the
+     * native buffer is used.
+     * @param samples containing DC offset
+     */
+    private void calculateDc(byte[] samples)
+    {
+        double dcAccumulator = 0;
+
+        for(byte sample: samples)
+        {
+            dcAccumulator += (sample & 0xFF);
+        }
+
+        dcAccumulator /= samples.length;
+        dcAccumulator -= 127.0f;
+        dcAccumulator /= 128.0f;
+        dcAccumulator -= mAverageDc;
+        mAverageDc += (dcAccumulator * DC_FILTER_GAIN);
+    }
+}

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

@@ -1,20 +1,21 @@
-/*******************************************************************************
- *     SDR Trunk 
- *     Copyright (C) 2014 Dennis Sheirer
+/*
+ * *****************************************************************************
+ * Copyright (C) 2014-2021 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.buffer;
 
 import java.util.Arrays;
@@ -25,13 +26,12 @@ import java.util.Arrays;
  * fills buffer with 0-valued samples
  *
  * Can be used as a delay-type buffer, to delay samples by the 'size' amount
- *
- * @author denny
  */
 public class FloatCircularBuffer
 {
-    float[] mBuffer;
-    int mBufferPointer = 0;
+    private float[] mBuffer;
+    private int mBufferPointer = 0;
+    private float mOldestSample;
 
     /**
      * Creates a circular double buffer of the specified size and all entries filled with the specified initial value.
@@ -61,25 +61,27 @@ public class FloatCircularBuffer
     }
 
     /**
-     * Puts the new value into the buffer and returns the oldest buffer value that it replaced
+     * Gets the current buffer value and overwrites that value position in the buffer with the new value.
      *
      * @param newValue to add to the buffer
      * @return oldest value that was overwritten by the new value
      */
-    public float get(float newValue)
+    public float getAndPut(float newValue)
     {
-        float oldestSample = mBuffer[mBufferPointer];
+        mOldestSample = mBuffer[mBufferPointer];
+        put(newValue);
+        return mOldestSample;
+    }
 
-        mBuffer[mBufferPointer] = newValue;
-
-        mBufferPointer++;
-
-        if(mBufferPointer >= mBuffer.length)
-        {
-            mBufferPointer = 0;
-        }
-
-        return oldestSample;
+    /**
+     * Puts the value into the buffer, updates the pointer and returns the buffer value at the pointer position.
+     * @param sample to add
+     * @return next pointed sample.
+     */
+    public float putAndGet(float sample)
+    {
+        put(sample);
+        return mBuffer[mBufferPointer];
     }
 
     public float[] getAll()
@@ -109,12 +111,7 @@ public class FloatCircularBuffer
     public void put(float newValue)
     {
         mBuffer[mBufferPointer] = newValue;
-
         mBufferPointer++;
-
-        if(mBufferPointer >= mBuffer.length)
-        {
-            mBufferPointer = 0;
-        }
+        mBufferPointer %= mBuffer.length;
     }
 }

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

@@ -0,0 +1,145 @@
+/*
+ * *****************************************************************************
+ * 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 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
+{
+    private float[] mInterleavedComplexSamples;
+    private long mTimestamp;
+
+    /**
+     * Constructs an instance
+     * @param complexSamples to wrap
+     * @param timestamp for the buffer
+     */
+    public FloatNativeBuffer(float[] complexSamples, long timestamp)
+    {
+        mInterleavedComplexSamples = complexSamples;
+        mTimestamp = timestamp;
+    }
+
+    /**
+     * Constructs an instance
+     * @param complexSamples to wrap
+     */
+    public FloatNativeBuffer(float[] complexSamples)
+    {
+        this(complexSamples, System.currentTimeMillis());
+    }
+
+    /**
+     * Constructs an instance
+     * @param samples to wrap
+     * @param timestamp for the buffer
+     */
+    public FloatNativeBuffer(ComplexSamples samples, long timestamp)
+    {
+        this(SampleUtils.interleave(samples), timestamp);
+    }
+
+    /**
+     * Constructs an instance
+     * @param samples to wrap
+     */
+    public FloatNativeBuffer(InterleavedComplexSamples samples)
+    {
+        this(samples.samples(), samples.timestamp());
+    }
+
+    @Override
+    public Iterator<ComplexSamples> iterator()
+    {
+        return new ComplexSamplesIterator();
+    }
+
+    @Override
+    public Iterator<InterleavedComplexSamples> iteratorInterleaved()
+    {
+        return new InterleavedComplexSamplesIterator();
+    }
+
+    @Override
+    public int sampleCount()
+    {
+        return mInterleavedComplexSamples.length / 2;
+    }
+
+    @Override
+    public long getTimestamp()
+    {
+        return mTimestamp;
+    }
+
+    private class ComplexSamplesIterator implements  Iterator<ComplexSamples>
+    {
+        private boolean mEmpty;
+
+        @Override
+        public boolean hasNext()
+        {
+            return !mEmpty;
+        }
+
+        @Override
+        public ComplexSamples next()
+        {
+            if(mEmpty)
+            {
+                throw new IllegalStateException("No more samples");
+            }
+
+            mEmpty = true;
+            return SampleUtils.deinterleave(mInterleavedComplexSamples);
+        }
+    }
+
+    private class InterleavedComplexSamplesIterator implements Iterator<InterleavedComplexSamples>
+    {
+        private boolean mEmpty;
+
+
+        @Override
+        public boolean hasNext()
+        {
+            return !mEmpty;
+        }
+
+        @Override
+        public InterleavedComplexSamples next()
+        {
+            if(mEmpty)
+            {
+                throw new IllegalStateException("No more samples");
+            }
+
+            mEmpty = true;
+            return new InterleavedComplexSamples(mInterleavedComplexSamples, mTimestamp);
+        }
+    }
+}

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

@@ -0,0 +1,53 @@
+/*
+ * *****************************************************************************
+ * 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 io.github.dsheirer.sample.complex.ComplexSamples;
+import io.github.dsheirer.sample.complex.InterleavedComplexSamples;
+
+import java.util.Iterator;
+
+/**
+ * A buffer of raw samples copied from native (ie outside of the JVM) memory into the JVM heap and
+ * convertible to an iterable stream of interleaved or non-interleaved sample instances.
+ */
+public interface INativeBuffer
+{
+    /**
+     * Provides an iterator that converts the raw samples to complex samples format with separate (non-interleaved) I and Q sample arrays.
+     */
+    Iterator<ComplexSamples> iterator();
+
+    /**
+     * Provides an iterator that converts the raw samples to interleaved complex samples format.
+     */
+    Iterator<InterleavedComplexSamples> iteratorInterleaved();
+
+    /**
+     * Total number of complex samples for this buffer
+     */
+    int sampleCount();
+
+    /**
+     * Timestamp for this buffer
+     * @return millis since epoch
+     */
+    long getTimestamp();
+}

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

@@ -0,0 +1,39 @@
+/*
+ * *****************************************************************************
+ * 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.nio.ByteBuffer;
+
+/**
+ * Factory for creating native buffer wrapper instances
+ */
+public interface INativeBufferFactory
+{
+    /**
+     * Create a native buffer implementation that wraps the samples argument.
+     *
+     * Note: implementations of this factory should treat the samples argument as read-only and only make data copies.
+     *
+     * @param samples byte array copied from native memory
+     * @param timestamp of the samples
+     * @return instance
+     */
+    INativeBuffer getBuffer(ByteBuffer samples, long timestamp);
+}

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

@@ -0,0 +1,42 @@
+/*
+ * *****************************************************************************
+ * 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 io.github.dsheirer.sample.Listener;
+
+/**
+ * Interface for a provider of interleaved complex samples
+ */
+public interface INativeBufferProvider
+{
+    /**
+     * Adds the listener to receive buffers
+     */
+    void addBufferListener(Listener<INativeBuffer> listener);
+
+    /**
+     * Removes the listener from receiving buffers
+     */
+    void removeBufferListener(Listener<INativeBuffer> listener);
+
+    /**
+     * Indicates if there are any buffer listeners registered
+     */
+    boolean hasBufferListeners();
+}

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

@@ -0,0 +1,55 @@
+/*
+ * *****************************************************************************
+ * 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 io.github.dsheirer.sample.complex.ComplexSamples;
+import io.github.dsheirer.sample.complex.InterleavedComplexSamples;
+
+import java.util.Iterator;
+
+/**
+ * Poison pill implementation for use with Dispatcher.
+ */
+public class NativeBufferPoisonPill implements INativeBuffer
+{
+    @Override
+    public Iterator<ComplexSamples> iterator()
+    {
+        return null;
+    }
+
+    @Override
+    public Iterator<InterleavedComplexSamples> iteratorInterleaved()
+    {
+        return null;
+    }
+
+    @Override
+    public int sampleCount()
+    {
+        return 0;
+    }
+
+    @Override
+    public long getTimestamp()
+    {
+        return 0;
+    }
+}

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

@@ -1,20 +1,24 @@
-/*******************************************************************************
- * sdr-trunk
- * Copyright (C) 2014-2018 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  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/>
- *
- ******************************************************************************/
-package io.github.dsheirer.sample.buffer;
+ * 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 io.github.dsheirer.sample.Broadcaster;
 import io.github.dsheirer.sample.Listener;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -22,7 +26,7 @@ import org.slf4j.LoggerFactory;
 import java.util.concurrent.LinkedTransferQueue;
 
 /**
- * Delay buffer/queue for reusable complex buffers with support for pre-loading new buffer listeners (ie channels)
+ * Delay buffer/queue with support for pre-loading new listeners (ie channels)
  * with delayed sample buffers and broadcasting of incoming sample buffers to a list of listeners.
  *
  * This class is designed to compensate/account for any delays in processing of a control channel and subsequent
@@ -39,15 +43,13 @@ import java.util.concurrent.LinkedTransferQueue;
  * so as not to delay the stream of sample buffers.  Channel listeners are expected to implement buffer queue processing
  * on another thread.
  */
-public class ReusableComplexDelayBuffer implements Listener<ReusableComplexBuffer>
+public class NativeSampleDelayBuffer implements Listener<INativeBuffer>
 {
-    private final static Logger mLog = LoggerFactory.getLogger(ReusableComplexDelayBuffer.class);
+    private final static Logger mLog = LoggerFactory.getLogger(NativeSampleDelayBuffer.class);
 
-    private ReusableBufferBroadcaster<ReusableComplexBuffer> mBroadcaster = new ReusableBufferBroadcaster<>();
-    private LinkedTransferQueue<ActionRequest> mActionRequestQueue = new LinkedTransferQueue<>();
-    private ActionRequest mActionRequest;
-
-    private ReusableComplexBuffer[] mDelayBuffer;
+    private Broadcaster<INativeBuffer> mBroadcaster = new Broadcaster<>();
+    private LinkedTransferQueue<ActionRequest> mActionQueue = new LinkedTransferQueue<>();
+    private INativeBuffer[] mDelayBuffer;
     private int mDelayBufferPointer = 0;
     private long mBufferDuration;
 
@@ -57,9 +59,9 @@ public class ReusableComplexDelayBuffer implements Listener<ReusableComplexBuffe
      * @param size of the delay queue
      * @param bufferDuration in milliseconds for each complex buffer processed by this instance
      */
-    public ReusableComplexDelayBuffer(int size, long bufferDuration)
+    public NativeSampleDelayBuffer(int size, long bufferDuration)
     {
-        mDelayBuffer = new ReusableComplexBuffer[size];
+        mDelayBuffer = new INativeBuffer[size];
         mBufferDuration = bufferDuration;
     }
 
@@ -69,12 +71,13 @@ public class ReusableComplexDelayBuffer implements Listener<ReusableComplexBuffe
     public void dispose()
     {
         clearBuffer();
+        mBroadcaster.clear();
     }
 
     public void clear()
     {
         //Submit a clear buffer request to be processed upon the next buffer that arrives
-        mActionRequestQueue.offer(new ActionRequest());
+        mActionQueue.offer(new ActionRequest());
     }
 
     /**
@@ -84,59 +87,42 @@ public class ReusableComplexDelayBuffer implements Listener<ReusableComplexBuffe
     {
         for(int x = 0; x < mDelayBuffer.length; x++)
         {
-            if(mDelayBuffer[x] != null)
-            {
-                mDelayBuffer[x].decrementUserCount();
-                mDelayBuffer[x] = null;
-            }
+            mDelayBuffer[x] = null;
         }
 
         mDelayBufferPointer = 0;
     }
 
     @Override
-    public synchronized void receive(ReusableComplexBuffer reusableComplexBuffer)
+    public synchronized void receive(INativeBuffer samples)
     {
-        mActionRequest = mActionRequestQueue.poll();
+        ActionRequest actionRequest = mActionQueue.poll();
 
-        while(mActionRequest != null)
+        while(actionRequest != null)
         {
-            switch(mActionRequest.getAction())
+            switch(actionRequest.getAction())
             {
-                case ADD_USER:
-                    processNewListener(mActionRequest);
+                case ADD_LISTENER:
+                    processNewListener(actionRequest);
                     break;
-                case REMOVE_USER:
-                    mBroadcaster.removeListener(mActionRequest.getListener());
+                case REMOVE_LISTENER:
+                    mBroadcaster.removeListener(actionRequest.getListener());
                     break;
                 case CLEAR_BUFFER:
                     clearBuffer();
                     break;
             }
 
-            mActionRequest = mActionRequestQueue.poll();
+            actionRequest = mActionQueue.poll();
         }
 
-        //Increment user count before we hand it to the broadcaster so that we can keep it as a copy for the
-        //delay buffer
-        reusableComplexBuffer.incrementUserCount();
-
-        mBroadcaster.receive(reusableComplexBuffer);
-
-        //Decrement the user count on the oldest buffer before we replace it in the delay queue
-        if(mDelayBuffer[mDelayBufferPointer] != null)
-        {
-            mDelayBuffer[mDelayBufferPointer].decrementUserCount();
-        }
+        mBroadcaster.receive(samples);
 
         //Store the new buffer in the delay queue and increment the pointer
-        mDelayBuffer[mDelayBufferPointer++] = reusableComplexBuffer;
+        mDelayBuffer[mDelayBufferPointer++] = samples;
 
         //Wrap the delay buffer pointer as needed
-        if(mDelayBufferPointer >= mDelayBuffer.length)
-        {
-            mDelayBufferPointer = 0;
-        }
+        mDelayBufferPointer %= mDelayBuffer.length;
     }
 
     /**
@@ -153,23 +139,18 @@ public class ReusableComplexDelayBuffer implements Listener<ReusableComplexBuffe
      */
     private void processNewListener(ActionRequest listenerToAdd)
     {
-        ReusableComplexBuffer bufferToEvaluate;
+        INativeBuffer toEvaluate;
 
         int pointer = mDelayBufferPointer;
 
-        int preloadedBufferCount = 0;
-
         for(int x = 0; x < mDelayBuffer.length; x++)
         {
-            bufferToEvaluate = mDelayBuffer[pointer];
+            toEvaluate = mDelayBuffer[pointer];
 
-            if(bufferToEvaluate != null &&
-                (bufferToEvaluate.getTimestamp() >= listenerToAdd.getTimestamp() ||
-                    bufferToEvaluate.getTimestamp() + mBufferDuration >= listenerToAdd.getTimestamp()))
+            if(toEvaluate != null &&
+                ((toEvaluate.getTimestamp() + mBufferDuration) >= listenerToAdd.getTimestamp()))
             {
-                bufferToEvaluate.incrementUserCount();
-                listenerToAdd.getListener().receive(bufferToEvaluate);
-                preloadedBufferCount++;
+                listenerToAdd.getListener().receive(toEvaluate);
             }
 
             pointer++;
@@ -190,28 +171,28 @@ public class ReusableComplexDelayBuffer implements Listener<ReusableComplexBuffe
      * @param listener to add
      * @param timestamp of the oldest sample buffers to preload to the listener
      */
-    public void addListener(Listener<ReusableComplexBuffer> listener, long timestamp)
+    public void addListener(Listener<INativeBuffer> listener, long timestamp)
     {
-        mActionRequestQueue.add(new ActionRequest(listener, timestamp));
+        mActionQueue.add(new ActionRequest(listener, timestamp));
     }
 
     /**
      * Removes the listener from receiving sample buffers
      */
-    public void removeListener(Listener<ReusableComplexBuffer> listener)
+    public void removeListener(Listener<INativeBuffer> listener)
     {
-        mActionRequestQueue.add(new ActionRequest(listener));
+        mActionQueue.add(new ActionRequest(listener));
     }
 
-    private enum Action{ADD_USER, REMOVE_USER, CLEAR_BUFFER};
+    private enum Action{ADD_LISTENER, REMOVE_LISTENER, CLEAR_BUFFER};
 
     /**
      * Actions that must be completed on the incoming sample stream thread.
      */
-    public class ActionRequest
+    public class ActionRequest<T extends INativeBuffer>
     {
         private Action mAction;
-        private Listener<ReusableComplexBuffer> mListener;
+        private Listener<T> mListener;
         private long mTimestamp;
 
         /**
@@ -219,9 +200,9 @@ public class ReusableComplexDelayBuffer implements Listener<ReusableComplexBuffe
          * @param listener to add
          * @param timestamp for the preloading buffers to the listener from the delay queue
          */
-        public ActionRequest(Listener<ReusableComplexBuffer> listener, long timestamp)
+        public ActionRequest(Listener<T> listener, long timestamp)
         {
-            mAction = Action.ADD_USER;
+            mAction = Action.ADD_LISTENER;
             mListener = listener;
             mTimestamp = timestamp;
         }
@@ -230,9 +211,9 @@ public class ReusableComplexDelayBuffer implements Listener<ReusableComplexBuffe
          * Creates a remove listener request
          * @param listener
          */
-        public ActionRequest(Listener<ReusableComplexBuffer> listener)
+        public ActionRequest(Listener<T> listener)
         {
-            mAction = Action.REMOVE_USER;
+            mAction = Action.REMOVE_LISTENER;
             mListener = listener;
         }
 
@@ -252,7 +233,7 @@ public class ReusableComplexDelayBuffer implements Listener<ReusableComplexBuffe
         /**
          * Listener to be added/removed
          */
-        public Listener<ReusableComplexBuffer> getListener()
+        public Listener<T> getListener()
         {
             return mListener;
         }

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

@@ -0,0 +1,161 @@
+/*
+ * *****************************************************************************
+ * 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 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
+{
+    private static final int FRAGMENT_SIZE = 2048;
+    private final static float[] LOOKUP_VALUES;
+
+    //Creates a static lookup table that converts the signed byte values as:
+    // Index   0 - 127: 0.0f to 1.0f
+    // Index 128 - 255: -1.0f to -0.0f
+    static
+    {
+        LOOKUP_VALUES = new float[256];
+
+        for(int x = 0; x < 256; x++)
+        {
+            LOOKUP_VALUES[x] = (float)((byte)x) / 128.0f;
+        }
+    }
+
+    private byte[] mSamples;
+    private long mTimestamp;
+    private float mIAverageDc;
+    private float mQAverageDc;
+
+    /**
+     * Constructs an instance
+     * @param samples to process
+     * @param timestamp of the samples
+     * @param iAverageDc of the sample stream
+     * @param qAverageDc of the sample stream
+     */
+    public SignedByteNativeBuffer(byte[] samples, long timestamp, float iAverageDc, float qAverageDc)
+    {
+        //Ensure we're an even multiple of the fragment size.  Typically, this will be 64k or 128k
+        if(samples.length % FRAGMENT_SIZE != 0)
+        {
+            throw new IllegalArgumentException("Samples byte[] length [" + samples.length + "] must be an even multiple of " + FRAGMENT_SIZE);
+        }
+
+        mSamples = samples;
+        mTimestamp = timestamp;
+        mIAverageDc = iAverageDc;
+        mQAverageDc = qAverageDc;
+    }
+
+    @Override
+    public long getTimestamp()
+    {
+        return mTimestamp;
+    }
+
+    @Override
+    public int sampleCount()
+    {
+        return mSamples.length / 2;
+    }
+
+    @Override
+    public Iterator<ComplexSamples> iterator()
+    {
+        return new ComplexSamplesIterator();
+    }
+
+    @Override
+    public Iterator<InterleavedComplexSamples> iteratorInterleaved()
+    {
+        return new InterleavedComplexSamplesIterator();
+    }
+
+    /**
+     * Iterator of complex samples over the native byte buffer array
+     */
+    private class ComplexSamplesIterator implements Iterator<ComplexSamples>
+    {
+        private int mSamplesPointer = 0;
+
+        @Override
+        public boolean hasNext()
+        {
+            return mSamplesPointer < mSamples.length;
+        }
+
+        @Override
+        public ComplexSamples next()
+        {
+            float[] i = new float[FRAGMENT_SIZE];
+            float[] q = new float[FRAGMENT_SIZE];
+            int samplesOffset = mSamplesPointer;
+
+            for(int pointer = 0; pointer < i.length; pointer++)
+            {
+                i[pointer] = LOOKUP_VALUES[(0xFF & mSamples[samplesOffset++])] - mIAverageDc;
+                q[pointer] = LOOKUP_VALUES[(0xFF & mSamples[samplesOffset++])] - mQAverageDc;
+            }
+
+            mSamplesPointer = samplesOffset;
+            return new ComplexSamples(i, q);
+        }
+    }
+
+    /**
+     * Iterator of interleaved complex samples over the native byte buffer array.
+     */
+    private class InterleavedComplexSamplesIterator implements Iterator<InterleavedComplexSamples>
+    {
+        private int mSamplesPointer = 0;
+
+        @Override
+        public boolean hasNext()
+        {
+            return mSamplesPointer < mSamples.length;
+        }
+
+        @Override
+        public InterleavedComplexSamples next()
+        {
+            float[] converted = new float[FRAGMENT_SIZE * 2];
+
+            int samplesOffset = mSamplesPointer;
+
+            for(int pointer = 0; pointer < converted.length; pointer += 2)
+            {
+                converted[pointer] = LOOKUP_VALUES[(0xFF & mSamples[samplesOffset++])] - mIAverageDc;
+                converted[pointer + 1] = LOOKUP_VALUES[(0xFF & mSamples[samplesOffset++])] - mQAverageDc;
+            }
+
+            mSamplesPointer = samplesOffset;
+
+            return new InterleavedComplexSamples(converted, mTimestamp);
+        }
+    }
+}

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

@@ -0,0 +1,68 @@
+/*
+ * *****************************************************************************
+ * 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.nio.ByteBuffer;
+
+/**
+ * Implements a factory for creating SignedByteNativeBuffer instances
+ */
+public class SignedByteNativeBufferFactory implements INativeBufferFactory
+{
+    private static final float DC_FILTER_GAIN = 0.02f; //Normalizes DC over period of ~50 (1 / .02) buffers
+    private float mIAverageDc = 0.0f;
+    private float mQAverageDc = 0.0f;
+
+    @Override
+    public INativeBuffer getBuffer(ByteBuffer samples, long timestamp)
+    {
+        byte[] copy = new byte[samples.capacity()];
+        samples.get(copy);
+        calculateDc(copy);
+        return new SignedByteNativeBuffer(copy, timestamp, mIAverageDc, mQAverageDc);
+    }
+
+    /**
+     * Calculates the average DC in the sample stream so that it can be subtracted from the samples when the
+     * native buffer is used.
+     * @param samples containing DC offset
+     */
+    private void calculateDc(byte[] samples)
+    {
+        double iDcAccumulator = 0;
+        double qDcAccumulator = 0;
+
+        for(int x = 0; x < samples.length; x += 2)
+        {
+            iDcAccumulator += samples[x];
+            qDcAccumulator += samples[x + 1];
+        }
+
+        iDcAccumulator /= (samples.length / 2);
+        iDcAccumulator /= 128.0f;
+        iDcAccumulator -= mIAverageDc;
+        mIAverageDc += (iDcAccumulator * DC_FILTER_GAIN);
+
+        qDcAccumulator /= (samples.length / 2);
+        qDcAccumulator /= 128.0f;
+        qDcAccumulator -= mQAverageDc;
+        mQAverageDc += (qDcAccumulator * DC_FILTER_GAIN);
+    }
+}

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

@@ -0,0 +1,105 @@
+/*
+ * *****************************************************************************
+ * 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.airspy;
+
+import io.github.dsheirer.dsp.filter.hilbert.HilbertTransform;
+
+import java.util.Iterator;
+
+/**
+ * Base complex samples iterator for raw Airspy sample buffers.  Incorporates a Hilbert transform filter
+ * for converting the real sample array to complex samples.
+ * @param <T> either ComplexSamples or InterleavedComplexSamples
+ */
+public abstract class AirspyBufferIterator<T> implements Iterator<T>
+{
+    protected static final float SCALE_SIGNED_12_BIT_TO_FLOAT = 1.0f / 2048.0f;
+    protected static final int FRAGMENT_SIZE = 2048;
+    protected static final float[] COEFFICIENTS =
+            HilbertTransform.convertHalfBandToHilbert(HilbertTransform.HALF_BAND_FILTER_47_TAP);
+
+    public static final int I_OVERLAP = 11;
+    public static final int Q_OVERLAP = 23;
+
+    protected float[] mIBuffer = new float[FRAGMENT_SIZE + I_OVERLAP];
+    protected float[] mQBuffer = new float[FRAGMENT_SIZE + Q_OVERLAP];
+    protected short[] mSamples;
+    protected int mSamplesPointer = 0;
+    protected long mTimestamp;
+    protected float mAverageDc;
+
+    /**
+     * Constructs an instance
+     * @param samples from the airspy.
+     * @param residualI samples from previous buffer
+     * @param residualQ samples from previous buffer
+     * @param averageDc as measured
+     * @param timestamp of the buffer
+     */
+    public AirspyBufferIterator(short[] samples, short[] residualI, short[] residualQ, float averageDc, long timestamp)
+    {
+        if(residualI.length != I_OVERLAP || residualQ.length != Q_OVERLAP)
+        {
+            throw new IllegalArgumentException("Residual I length [" + residualI.length +
+                    "] must be " + I_OVERLAP + " and Residual Q length [" + residualQ.length +
+                    "] must be " + Q_OVERLAP);
+        }
+
+        int requiredInterval = FRAGMENT_SIZE * 2; //requires 4 bytes (2 samples) per fragment
+
+        if(samples.length % requiredInterval != 0)
+        {
+            throw new IllegalArgumentException("Samples short array length [" + mSamples.length +
+                    "]must be an integer multiple of " + requiredInterval);
+        }
+
+        mAverageDc = averageDc;
+        mSamples = samples;
+        mTimestamp = timestamp;
+
+        //Transfer and scale the residual I & Q samples from the previous buffer
+        for(int i = 0; i < residualI.length; i++)
+        {
+            mIBuffer[i] = scale(residualI[i], averageDc);
+        }
+
+        for(int q = 0; q < residualQ.length; q++)
+        {
+            mQBuffer[q] = scale(residualQ[q], averageDc);
+        }
+    }
+
+    @Override
+    public boolean hasNext()
+    {
+        return mSamplesPointer < mSamples.length;
+    }
+
+    /**
+     * Scales the short sample value to a 12-bit floating point and subtracts the average DC offset
+     * @param value to scale
+     * @param averageDc detected
+     * @return scaled and normalized sample
+     */
+    public static float scale(short value, float averageDc)
+    {
+        return ((float)value - 2048) * SCALE_SIGNED_12_BIT_TO_FLOAT - averageDc;
+    }
+}

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

@@ -0,0 +1,96 @@
+/*
+ * *****************************************************************************
+ * 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.airspy;
+
+import io.github.dsheirer.sample.complex.ComplexSamples;
+
+import java.util.Arrays;
+
+/**
+ * Scalar implementation for non-packed Airspy native buffers
+ */
+public class AirspyBufferIteratorScalar extends AirspyBufferIterator<ComplexSamples>
+{
+    /**
+     * Constructs an instance
+     *
+     * @param samples from the airspy, either packed or unpacked.
+     * @param residualI samples from last buffer
+     * @param residualQ samples from last buffer
+     * @param averageDc measured
+     * @param timestamp of the buffer
+     */
+    public AirspyBufferIteratorScalar(short[] samples, short[] residualI, short[] residualQ, float averageDc, long timestamp)
+    {
+        super(samples, residualI, residualQ, averageDc, timestamp);
+    }
+
+    @Override
+    public ComplexSamples next()
+    {
+        if(mSamplesPointer >= mSamples.length)
+        {
+            throw new IllegalStateException("End of buffer exceeded");
+        }
+
+        int offset = mSamplesPointer;
+
+        for(int x = 0; x < FRAGMENT_SIZE; x++)
+        {
+            mIBuffer[x + I_OVERLAP] = scale(mSamples[offset++], mAverageDc);
+            mQBuffer[x + Q_OVERLAP] = scale(mSamples[offset++], mAverageDc);
+        }
+
+        mSamplesPointer = offset;
+
+        //The i line is a simple delay line, so we'll just copy those as a new array here.
+        float[] i = Arrays.copyOf(mIBuffer, FRAGMENT_SIZE);
+        float[] q = new float[FRAGMENT_SIZE];
+
+        float accumulator;
+
+        for(int x = 0; x < FRAGMENT_SIZE; x++)
+        {
+            accumulator = 0;
+
+            for(int tap = 0; tap < COEFFICIENTS.length; tap++)
+            {
+                accumulator += COEFFICIENTS[tap] * mQBuffer[x + tap];
+            }
+
+            //Perform FS/2 frequency translation on final filtered values ... multiply sequence by 1, -1, etc.
+            if(x % 2 == 0)
+            {
+                q[x] = accumulator;
+            }
+            else
+            {
+                i[x] = -i[x];
+                q[x] = -accumulator;
+            }
+        }
+
+        //Copy residual end samples to beginning of buffers for the next iteration
+        System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
+        System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
+
+        return new ComplexSamples(i, q);
+    }
+}

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

@@ -0,0 +1,126 @@
+/*
+ * *****************************************************************************
+ * 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.airspy;
+
+import io.github.dsheirer.sample.complex.ComplexSamples;
+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
+ */
+public class AirspyBufferIteratorVector128Bits extends AirspyBufferIterator<ComplexSamples>
+{
+    private static final VectorSpecies<Float> VECTOR_SPECIES = FloatVector.SPECIES_128;
+
+    /**
+     * Constructs an instance
+     *
+     * @param samples from the airspy, either packed or unpacked.
+     * @param residualI samples from last buffer
+     * @param residualQ samples from last buffer
+     * @param averageDc measured
+     * @param timestamp of the buffer
+     */
+    public AirspyBufferIteratorVector128Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc, long timestamp)
+    {
+        super(samples, residualI, residualQ, averageDc, timestamp);
+    }
+
+    @Override
+    public ComplexSamples next()
+    {
+        if(mSamplesPointer >= mSamples.length)
+        {
+            throw new IllegalStateException("End of buffer exceeded");
+        }
+
+        int offset = mSamplesPointer;
+        int fragmentPointer = 0;
+        float[] scaledSamples = new float[VECTOR_SPECIES.length()];
+
+        while(fragmentPointer < FRAGMENT_SIZE)
+        {
+            for(int y = 0; y < VECTOR_SPECIES.length(); y++)
+            {
+                //Couldn't figure out an easy way to load as a short vector and recast to a float vector
+                scaledSamples[y] = mSamples[offset++];
+            }
+
+            //SIMD scaling operation
+            FloatVector.fromArray(VECTOR_SPECIES, scaledSamples, 0)
+                    .sub(2048.0f)
+                    .mul(SCALE_SIGNED_12_BIT_TO_FLOAT)
+                    .sub(mAverageDc)
+                    .intoArray(scaledSamples, 0);
+
+            for(int y = 0; y < VECTOR_SPECIES.length(); y += 2)
+            {
+                mIBuffer[fragmentPointer + I_OVERLAP] = scaledSamples[y];
+                mQBuffer[fragmentPointer++ + Q_OVERLAP] = scaledSamples[y + 1];
+            }
+        }
+
+        mSamplesPointer = offset;
+
+        //The i line is a simple delay line, so we'll just copy those as a new array here.
+        float[] i = Arrays.copyOf(mIBuffer, FRAGMENT_SIZE);
+        float[] q = new float[FRAGMENT_SIZE];
+
+        FloatVector accumulator;
+        FloatVector f1 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 0);
+        FloatVector f2 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 4);
+        FloatVector f3 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 8);
+        FloatVector f4 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 12);
+        FloatVector f5 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 16);
+        FloatVector f6 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 20);
+
+        for(int x = 0; x < FRAGMENT_SIZE; x++)
+        {
+            accumulator = FloatVector.zero(VECTOR_SPECIES);
+            accumulator = f1.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x), accumulator);
+            accumulator = f2.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 4), accumulator);
+            accumulator = f3.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 8), accumulator);
+            accumulator = f4.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 12), accumulator);
+            accumulator = f5.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 16), accumulator);
+            accumulator = f6.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 20), accumulator);
+
+            //Perform FS/2 frequency translation on final filtered values ... multiply sequence by 1, -1, etc.
+            if(x % 2 == 0)
+            {
+                q[x] = accumulator.reduceLanes(VectorOperators.ADD);
+            }
+            else
+            {
+                i[x] = -i[x];
+                q[x] = -accumulator.reduceLanes(VectorOperators.ADD);
+            }
+        }
+
+        //Copy residual end samples to beginning of buffers for the next iteration
+        System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
+        System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
+
+        return new ComplexSamples(i, q);
+    }
+}

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

@@ -0,0 +1,120 @@
+/*
+ * *****************************************************************************
+ * 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.airspy;
+
+import io.github.dsheirer.sample.complex.ComplexSamples;
+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
+ */
+public class AirspyBufferIteratorVector256Bits extends AirspyBufferIterator<ComplexSamples>
+{
+    private static final VectorSpecies<Float> VECTOR_SPECIES = FloatVector.SPECIES_256;
+
+    /**
+     * Constructs an instance
+     *
+     * @param samples from the airspy, either packed or unpacked.
+     * @param residualI samples from last buffer
+     * @param residualQ samples from last buffer
+     * @param averageDc measured
+     * @param timestamp of the buffer
+     */
+    public AirspyBufferIteratorVector256Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc, long timestamp)
+    {
+        super(samples, residualI, residualQ, averageDc, timestamp);
+    }
+
+    @Override
+    public ComplexSamples next()
+    {
+        if(mSamplesPointer >= mSamples.length)
+        {
+            throw new IllegalStateException("End of buffer exceeded");
+        }
+
+        int offset = mSamplesPointer;
+        int fragmentPointer = 0;
+        float[] scaledSamples = new float[VECTOR_SPECIES.length()];
+
+        while(fragmentPointer < FRAGMENT_SIZE)
+        {
+            for(int y = 0; y < VECTOR_SPECIES.length(); y++)
+            {
+                //Couldn't figure out an easy way to load as a short vector and recast to a float vector
+                scaledSamples[y] = mSamples[offset++];
+            }
+
+            //SIMD scaling operation
+            FloatVector.fromArray(VECTOR_SPECIES, scaledSamples, 0)
+                    .sub(2048.0f)
+                    .mul(SCALE_SIGNED_12_BIT_TO_FLOAT)
+                    .sub(mAverageDc)
+                    .intoArray(scaledSamples, 0);
+
+            for(int y = 0; y < VECTOR_SPECIES.length(); y += 2)
+            {
+                mIBuffer[fragmentPointer + I_OVERLAP] = scaledSamples[y];
+                mQBuffer[fragmentPointer++ + Q_OVERLAP] = scaledSamples[y + 1];
+            }
+        }
+
+        mSamplesPointer = offset;
+
+        //The i line is a simple delay line, so we'll just copy those as a new array here.
+        float[] i = Arrays.copyOf(mIBuffer, FRAGMENT_SIZE);
+        float[] q = new float[FRAGMENT_SIZE];
+
+        FloatVector accumulator;
+        FloatVector f1 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 0);
+        FloatVector f2 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 8);
+        FloatVector f3 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 16);
+
+        for(int x = 0; x < FRAGMENT_SIZE; x++)
+        {
+            accumulator = FloatVector.zero(VECTOR_SPECIES);
+            accumulator = f1.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x), accumulator);
+            accumulator = f2.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 8), accumulator);
+            accumulator = f3.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 16), accumulator);
+
+            //Perform FS/2 frequency translation on final filtered values ... multiply sequence by 1, -1, etc.
+            if(x % 2 == 0)
+            {
+                q[x] = accumulator.reduceLanes(VectorOperators.ADD);
+            }
+            else
+            {
+                i[x] = -i[x];
+                q[x] = -accumulator.reduceLanes(VectorOperators.ADD);
+            }
+        }
+
+        //Copy residual end samples to beginning of buffers for the next iteration
+        System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
+        System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
+
+        return new ComplexSamples(i, q);
+    }
+}

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

@@ -0,0 +1,122 @@
+/*
+ * *****************************************************************************
+ * 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.airspy;
+
+import io.github.dsheirer.sample.complex.ComplexSamples;
+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
+ */
+public class AirspyBufferIteratorVector512Bits extends AirspyBufferIterator<ComplexSamples>
+{
+    private static final VectorSpecies<Float> VECTOR_SPECIES = FloatVector.SPECIES_512;
+    private float[] mFilterPart2;
+
+    /**
+     * Constructs an instance
+     *
+     * @param samples from the airspy, either packed or unpacked.
+     * @param residualI samples from last buffer
+     * @param residualQ samples from last buffer
+     * @param averageDc measured
+     * @param timestamp of the buffer
+     */
+    public AirspyBufferIteratorVector512Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc, long timestamp)
+    {
+        super(samples, residualI, residualQ, averageDc, timestamp);
+        //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);
+    }
+
+    @Override
+    public ComplexSamples next()
+    {
+        if(mSamplesPointer >= mSamples.length)
+        {
+            throw new IllegalStateException("End of buffer exceeded");
+        }
+
+        int offset = mSamplesPointer;
+        int fragmentPointer = 0;
+        float[] scaledSamples = new float[VECTOR_SPECIES.length()];
+
+        while(fragmentPointer < FRAGMENT_SIZE)
+        {
+            for(int y = 0; y < VECTOR_SPECIES.length(); y++)
+            {
+                //Couldn't figure out an easy way to load as a short vector and recast to a float vector
+                scaledSamples[y] = mSamples[offset++];
+            }
+
+            //SIMD scaling operation
+            FloatVector.fromArray(VECTOR_SPECIES, scaledSamples, 0)
+                    .sub(2048.0f)
+                    .mul(SCALE_SIGNED_12_BIT_TO_FLOAT)
+                    .sub(mAverageDc)
+                    .intoArray(scaledSamples, 0);
+
+            for(int y = 0; y < VECTOR_SPECIES.length(); y += 2)
+            {
+                mIBuffer[fragmentPointer + I_OVERLAP] = scaledSamples[y];
+                mQBuffer[fragmentPointer++ + Q_OVERLAP] = scaledSamples[y + 1];
+            }
+        }
+
+        mSamplesPointer = offset;
+
+        //The i line is a simple delay line, so we'll just copy those as a new array here.
+        float[] i = Arrays.copyOf(mIBuffer, FRAGMENT_SIZE);
+        float[] q = new float[FRAGMENT_SIZE];
+
+        FloatVector accumulator;
+        FloatVector f1 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 0);
+        FloatVector f2 = FloatVector.fromArray(VECTOR_SPECIES, mFilterPart2, 0);
+
+        for(int x = 0; x < FRAGMENT_SIZE; x++)
+        {
+            accumulator = FloatVector.zero(VECTOR_SPECIES);
+            accumulator = f1.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x), accumulator);
+            accumulator = f2.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 8), accumulator);
+
+            //Perform FS/2 frequency translation on final filtered values ... multiply sequence by 1, -1, etc.
+            if(x % 2 == 0)
+            {
+                q[x] = accumulator.reduceLanes(VectorOperators.ADD);
+            }
+            else
+            {
+                i[x] = -i[x];
+                q[x] = -accumulator.reduceLanes(VectorOperators.ADD);
+            }
+        }
+
+        //Copy residual end samples to beginning of buffers for the next iteration
+        System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
+        System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
+
+        return new ComplexSamples(i, q);
+    }
+}

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

@@ -0,0 +1,138 @@
+/*
+ * *****************************************************************************
+ * 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.airspy;
+
+import io.github.dsheirer.sample.complex.ComplexSamples;
+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
+ */
+public class AirspyBufferIteratorVector64Bits extends AirspyBufferIterator<ComplexSamples>
+{
+    private static final VectorSpecies<Float> VECTOR_SPECIES = FloatVector.SPECIES_64;
+
+    /**
+     * Constructs an instance
+     *
+     * @param samples from the airspy, either packed or unpacked.
+     * @param residualI samples from last buffer
+     * @param residualQ samples from last buffer
+     * @param averageDc measured
+     * @param timestamp of the buffer
+     */
+    public AirspyBufferIteratorVector64Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc, long timestamp)
+    {
+        super(samples, residualI, residualQ, averageDc, timestamp);
+    }
+
+    @Override
+    public ComplexSamples next()
+    {
+        if(mSamplesPointer >= mSamples.length)
+        {
+            throw new IllegalStateException("End of buffer exceeded");
+        }
+
+        int offset = mSamplesPointer;
+        int fragmentPointer = 0;
+        float[] scaledSamples = new float[VECTOR_SPECIES.length()];
+
+        while(fragmentPointer < FRAGMENT_SIZE)
+        {
+            for(int y = 0; y < VECTOR_SPECIES.length(); y++)
+            {
+                //Couldn't figure out an easy way to load as a short vector and recast to a float vector
+                scaledSamples[y] = mSamples[offset++];
+            }
+
+            //SIMD scaling operation
+            FloatVector.fromArray(VECTOR_SPECIES, scaledSamples, 0)
+                    .sub(2048.0f)
+                    .mul(SCALE_SIGNED_12_BIT_TO_FLOAT)
+                    .sub(mAverageDc)
+                    .intoArray(scaledSamples, 0);
+
+            for(int y = 0; y < VECTOR_SPECIES.length(); y += 2)
+            {
+                mIBuffer[fragmentPointer + I_OVERLAP] = scaledSamples[y];
+                mQBuffer[fragmentPointer++ + Q_OVERLAP] = scaledSamples[y + 1];
+            }
+        }
+
+        mSamplesPointer = offset;
+
+        //The i line is a simple delay line, so we'll just copy those as a new array here.
+        float[] i = Arrays.copyOf(mIBuffer, FRAGMENT_SIZE);
+        float[] q = new float[FRAGMENT_SIZE];
+
+        FloatVector accumulator;
+        FloatVector f1 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 0);
+        FloatVector f2 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 2);
+        FloatVector f3 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 4);
+        FloatVector f4 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 6);
+        FloatVector f5 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 8);
+        FloatVector f6 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 10);
+        FloatVector f7 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 12);
+        FloatVector f8 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 14);
+        FloatVector f9 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 16);
+        FloatVector f10 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 18);
+        FloatVector f11 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 20);
+        FloatVector f12 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 22);
+
+        for(int x = 0; x < FRAGMENT_SIZE; x++)
+        {
+            accumulator = FloatVector.zero(VECTOR_SPECIES);
+            accumulator = f1.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x), accumulator);
+            accumulator = f2.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 2), accumulator);
+            accumulator = f3.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 4), accumulator);
+            accumulator = f4.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 6), accumulator);
+            accumulator = f5.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 8), accumulator);
+            accumulator = f6.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 10), accumulator);
+            accumulator = f7.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 12), accumulator);
+            accumulator = f8.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 14), accumulator);
+            accumulator = f9.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 16), accumulator);
+            accumulator = f10.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 18), accumulator);
+            accumulator = f11.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 20), accumulator);
+            accumulator = f12.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 22), accumulator);
+
+            //Perform FS/2 frequency translation on final filtered values ... multiply sequence by 1, -1, etc.
+            if(x % 2 == 0)
+            {
+                q[x] = accumulator.reduceLanes(VectorOperators.ADD);
+            }
+            else
+            {
+                i[x] = -i[x];
+                q[x] = -accumulator.reduceLanes(VectorOperators.ADD);
+            }
+        }
+
+        //Copy residual end samples to beginning of buffers for the next iteration
+        System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
+        System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
+
+        return new ComplexSamples(i, q);
+    }
+}

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

@@ -0,0 +1,94 @@
+/*
+ * *****************************************************************************
+ * 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.airspy;
+
+import io.github.dsheirer.sample.complex.InterleavedComplexSamples;
+
+/**
+ * Scalar implementation for non-packed Airspy native buffers
+ */
+public class AirspyInterleavedBufferIteratorScalar extends AirspyBufferIterator<InterleavedComplexSamples>
+{
+    /**
+     * Constructs an instance
+     *
+     * @param samples from the airspy, either packed or unpacked.
+     * @param residualI samples from last buffer
+     * @param residualQ samples from last buffer
+     * @param averageDc measured
+     * @param timestamp of the buffer
+     */
+    public AirspyInterleavedBufferIteratorScalar(short[] samples, short[] residualI, short[] residualQ, float averageDc,
+                                                 long timestamp)
+    {
+        super(samples, residualI, residualQ, averageDc, timestamp);
+    }
+
+    @Override
+    public InterleavedComplexSamples next()
+    {
+        if(mSamplesPointer >= mSamples.length)
+        {
+            throw new IllegalStateException("End of buffer exceeded");
+        }
+
+        int offset = mSamplesPointer;
+
+        for(int x = 0; x < FRAGMENT_SIZE; x++)
+        {
+            mIBuffer[x + I_OVERLAP] = scale(mSamples[offset++], mAverageDc);
+            mQBuffer[x + Q_OVERLAP] = scale(mSamples[offset++], mAverageDc);
+        }
+
+        mSamplesPointer = offset;
+
+        float[] samples = new float[FRAGMENT_SIZE * 2];
+
+        float accumulator;
+
+        for(int x = 0; x < FRAGMENT_SIZE; x++)
+        {
+            accumulator = 0;
+
+            for(int tap = 0; tap < COEFFICIENTS.length; tap++)
+            {
+                accumulator += COEFFICIENTS[tap] * mQBuffer[x + tap];
+            }
+
+            //Perform FS/2 frequency translation on final filtered values ... multiply sequence by 1, -1, etc.
+            if(x % 2 == 0)
+            {
+                samples[2 * x] = mIBuffer[x];
+                samples[2 * x + 1] = accumulator;
+            }
+            else
+            {
+                samples[2 * x] = -mIBuffer[x];
+                samples[2 * x + 1] = -accumulator;
+            }
+        }
+
+        //Copy residual end samples to beginning of buffers for the next iteration
+        System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
+        System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
+
+        return new InterleavedComplexSamples(samples, mTimestamp);
+    }
+}

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

@@ -0,0 +1,123 @@
+/*
+ * *****************************************************************************
+ * 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.airspy;
+
+import io.github.dsheirer.sample.complex.InterleavedComplexSamples;
+import jdk.incubator.vector.FloatVector;
+import jdk.incubator.vector.VectorOperators;
+import jdk.incubator.vector.VectorSpecies;
+
+/**
+ * Vector SIMD implementation for non-packed Airspy native buffers
+ */
+public class AirspyInterleavedBufferIteratorVector128Bits extends AirspyBufferIterator<InterleavedComplexSamples>
+{
+    private static final VectorSpecies<Float> VECTOR_SPECIES = FloatVector.SPECIES_128;
+
+    /**
+     * Constructs an instance
+     *
+     * @param samples from the airspy, either packed or unpacked.
+     * @param residualI samples from last buffer
+     * @param residualQ samples from last buffer
+     * @param averageDc measured
+     * @param timestamp of the buffer
+     */
+    public AirspyInterleavedBufferIteratorVector128Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc,
+                                                        long timestamp)
+    {
+        super(samples, residualI, residualQ, averageDc, timestamp);
+    }
+
+    @Override
+    public InterleavedComplexSamples next()
+    {
+        if(mSamplesPointer >= mSamples.length)
+        {
+            throw new IllegalStateException("End of buffer exceeded");
+        }
+
+        int offset = mSamplesPointer;
+        int fragmentPointer = 0;
+        float[] scaledSamples = new float[VECTOR_SPECIES.length()];
+
+        while(fragmentPointer < FRAGMENT_SIZE)
+        {
+            for(int y = 0; y < VECTOR_SPECIES.length(); y++)
+            {
+                //Couldn't figure out an easy way to load as a short vector and recast to a float vector
+                scaledSamples[y] = mSamples[offset++];
+            }
+
+            //SIMD scaling operation
+            FloatVector.fromArray(VECTOR_SPECIES, scaledSamples, 0)
+                    .sub(2048.0f)
+                    .mul(SCALE_SIGNED_12_BIT_TO_FLOAT)
+                    .sub(mAverageDc)
+                    .intoArray(scaledSamples, 0);
+
+            for(int y = 0; y < VECTOR_SPECIES.length(); y += 2)
+            {
+                mIBuffer[fragmentPointer + I_OVERLAP] = scaledSamples[y];
+                mQBuffer[fragmentPointer++ + Q_OVERLAP] = scaledSamples[y + 1];
+            }
+        }
+
+        mSamplesPointer = offset;
+
+        float[] samples = new float[FRAGMENT_SIZE * 2];
+        FloatVector accumulator;
+        FloatVector f1 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 0);
+        FloatVector f2 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 4);
+        FloatVector f3 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 8);
+        FloatVector f4 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 12);
+        FloatVector f5 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 16);
+        FloatVector f6 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 20);
+
+        for(int x = 0; x < FRAGMENT_SIZE; x++)
+        {
+            accumulator = FloatVector.zero(VECTOR_SPECIES);
+            accumulator = f1.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x), accumulator);
+            accumulator = f2.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 4), accumulator);
+            accumulator = f3.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 8), accumulator);
+            accumulator = f4.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 12), accumulator);
+            accumulator = f5.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 16), accumulator);
+            accumulator = f6.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 20), accumulator);
+
+            //Perform FS/2 frequency translation on final filtered values ... multiply sequence by 1, -1, etc.
+            if(x % 2 == 0)
+            {
+                samples[2 * x] = mIBuffer[x];
+                samples[2 * x + 1] = accumulator.reduceLanes(VectorOperators.ADD);
+            }
+            else
+            {
+                samples[2 * x] = -mIBuffer[x];
+                samples[2 * x + 1] = -accumulator.reduceLanes(VectorOperators.ADD);
+            }
+        }
+
+        //Copy residual end samples to beginning of buffers for the next iteration
+        System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
+        System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
+
+        return new InterleavedComplexSamples(samples, mTimestamp);
+    }
+}

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

@@ -0,0 +1,117 @@
+/*
+ * *****************************************************************************
+ * 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.airspy;
+
+import io.github.dsheirer.sample.complex.InterleavedComplexSamples;
+import jdk.incubator.vector.FloatVector;
+import jdk.incubator.vector.VectorOperators;
+import jdk.incubator.vector.VectorSpecies;
+
+/**
+ * Vector SIMD implementation for non-packed Airspy native buffers
+ */
+public class AirspyInterleavedBufferIteratorVector256Bits extends AirspyBufferIterator<InterleavedComplexSamples>
+{
+    private static final VectorSpecies<Float> VECTOR_SPECIES = FloatVector.SPECIES_256;
+
+    /**
+     * Constructs an instance
+     *
+     * @param samples from the airspy, either packed or unpacked.
+     * @param residualI samples from last buffer
+     * @param residualQ samples from last buffer
+     * @param averageDc measured
+     * @param timestamp of the buffer
+     */
+    public AirspyInterleavedBufferIteratorVector256Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc,
+                                                        long timestamp)
+    {
+        super(samples, residualI, residualQ, averageDc, timestamp);
+    }
+
+    @Override
+    public InterleavedComplexSamples next()
+    {
+        if(mSamplesPointer >= mSamples.length)
+        {
+            throw new IllegalStateException("End of buffer exceeded");
+        }
+
+        int offset = mSamplesPointer;
+        int fragmentPointer = 0;
+        float[] scaledSamples = new float[VECTOR_SPECIES.length()];
+
+        while(fragmentPointer < FRAGMENT_SIZE)
+        {
+            for(int y = 0; y < VECTOR_SPECIES.length(); y++)
+            {
+                //Couldn't figure out an easy way to load as a short vector and recast to a float vector
+                scaledSamples[y] = mSamples[offset++];
+            }
+
+            //SIMD scaling operation
+            FloatVector.fromArray(VECTOR_SPECIES, scaledSamples, 0)
+                    .sub(2048.0f)
+                    .mul(SCALE_SIGNED_12_BIT_TO_FLOAT)
+                    .sub(mAverageDc)
+                    .intoArray(scaledSamples, 0);
+
+            for(int y = 0; y < VECTOR_SPECIES.length(); y += 2)
+            {
+                mIBuffer[fragmentPointer + I_OVERLAP] = scaledSamples[y];
+                mQBuffer[fragmentPointer++ + Q_OVERLAP] = scaledSamples[y + 1];
+            }
+        }
+
+        mSamplesPointer = offset;
+
+        float[] samples = new float[FRAGMENT_SIZE * 2];
+        FloatVector accumulator;
+        FloatVector f1 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 0);
+        FloatVector f2 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 8);
+        FloatVector f3 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 16);
+
+        for(int x = 0; x < FRAGMENT_SIZE; x++)
+        {
+            accumulator = FloatVector.zero(VECTOR_SPECIES);
+            accumulator = f1.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x), accumulator);
+            accumulator = f2.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 8), accumulator);
+            accumulator = f3.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 16), accumulator);
+
+            //Perform FS/2 frequency translation on final filtered values ... multiply sequence by 1, -1, etc.
+            if(x % 2 == 0)
+            {
+                samples[2 * x] = mIBuffer[x];
+                samples[2 * x + 1] = accumulator.reduceLanes(VectorOperators.ADD);
+            }
+            else
+            {
+                samples[2 * x] = -mIBuffer[x];
+                samples[2 * x + 1] = -accumulator.reduceLanes(VectorOperators.ADD);
+            }
+        }
+
+        //Copy residual end samples to beginning of buffers for the next iteration
+        System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
+        System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
+
+        return new InterleavedComplexSamples(samples, mTimestamp);
+    }
+}

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

@@ -0,0 +1,120 @@
+/*
+ * *****************************************************************************
+ * 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.airspy;
+
+import io.github.dsheirer.sample.complex.InterleavedComplexSamples;
+import jdk.incubator.vector.FloatVector;
+import jdk.incubator.vector.VectorOperators;
+import jdk.incubator.vector.VectorSpecies;
+
+/**
+ * Vector SIMD implementation for non-packed Airspy native buffers
+ */
+public class AirspyInterleavedBufferIteratorVector512Bits extends AirspyBufferIterator<InterleavedComplexSamples>
+{
+    private static final VectorSpecies<Float> VECTOR_SPECIES = FloatVector.SPECIES_512;
+    private float[] mFilterPart2;
+
+    /**
+     * Constructs an instance
+     *
+     * @param samples from the airspy, either packed or unpacked.
+     * @param residualI samples from last buffer
+     * @param residualQ samples from last buffer
+     * @param averageDc measured
+     * @param timestamp of the buffer
+     */
+    public AirspyInterleavedBufferIteratorVector512Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc,
+                                                        long timestamp)
+    {
+        super(samples, residualI, residualQ, averageDc, timestamp);
+
+        //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);
+    }
+
+    @Override
+    public InterleavedComplexSamples next()
+    {
+        if(mSamplesPointer >= mSamples.length)
+        {
+            throw new IllegalStateException("End of buffer exceeded");
+        }
+
+        int offset = mSamplesPointer;
+        int fragmentPointer = 0;
+        float[] scaledSamples = new float[VECTOR_SPECIES.length()];
+
+        while(fragmentPointer < FRAGMENT_SIZE)
+        {
+            for(int y = 0; y < VECTOR_SPECIES.length(); y++)
+            {
+                //Couldn't figure out an easy way to load as a short vector and recast to a float vector
+                scaledSamples[y] = mSamples[offset++];
+            }
+
+            //SIMD scaling operation
+            FloatVector.fromArray(VECTOR_SPECIES, scaledSamples, 0)
+                    .sub(2048.0f)
+                    .mul(SCALE_SIGNED_12_BIT_TO_FLOAT)
+                    .sub(mAverageDc)
+                    .intoArray(scaledSamples, 0);
+
+            for(int y = 0; y < VECTOR_SPECIES.length(); y += 2)
+            {
+                mIBuffer[fragmentPointer + I_OVERLAP] = scaledSamples[y];
+                mQBuffer[fragmentPointer++ + Q_OVERLAP] = scaledSamples[y + 1];
+            }
+        }
+
+        mSamplesPointer = offset;
+
+        float[] samples = new float[FRAGMENT_SIZE * 2];
+        FloatVector accumulator;
+        FloatVector f1 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 0);
+        FloatVector f2 = FloatVector.fromArray(VECTOR_SPECIES, mFilterPart2, 0);
+
+        for(int x = 0; x < FRAGMENT_SIZE; x++)
+        {
+            accumulator = FloatVector.zero(VECTOR_SPECIES);
+            accumulator = f1.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x), accumulator);
+            accumulator = f2.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 8), accumulator);
+
+            //Perform FS/2 frequency translation on final filtered values ... multiply sequence by 1, -1, etc.
+            if(x % 2 == 0)
+            {
+                samples[2 * x] = mIBuffer[x];
+                samples[2 * x + 1] = accumulator.reduceLanes(VectorOperators.ADD);
+            }
+            else
+            {
+                samples[2 * x] = -mIBuffer[x];
+                samples[2 * x + 1] = -accumulator.reduceLanes(VectorOperators.ADD);
+            }
+        }
+
+        //Copy residual end samples to beginning of buffers for the next iteration
+        System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
+        System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
+
+        return new InterleavedComplexSamples(samples, mTimestamp);
+    }
+}

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

@@ -0,0 +1,135 @@
+/*
+ * *****************************************************************************
+ * 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.airspy;
+
+import io.github.dsheirer.sample.complex.InterleavedComplexSamples;
+import jdk.incubator.vector.FloatVector;
+import jdk.incubator.vector.VectorOperators;
+import jdk.incubator.vector.VectorSpecies;
+
+/**
+ * Vector SIMD implementation for non-packed Airspy native buffers
+ */
+public class AirspyInterleavedBufferIteratorVector64Bits extends AirspyBufferIterator<InterleavedComplexSamples>
+{
+    private static final VectorSpecies<Float> VECTOR_SPECIES = FloatVector.SPECIES_64;
+
+    /**
+     * Constructs an instance
+     *
+     * @param samples from the airspy, either packed or unpacked.
+     * @param residualI samples from last buffer
+     * @param residualQ samples from last buffer
+     * @param averageDc measured
+     * @param timestamp of the buffer
+     */
+    public AirspyInterleavedBufferIteratorVector64Bits(short[] samples, short[] residualI, short[] residualQ, float averageDc,
+                                                       long timestamp)
+    {
+        super(samples, residualI, residualQ, averageDc, timestamp);
+    }
+
+    @Override
+    public InterleavedComplexSamples next()
+    {
+        if(mSamplesPointer >= mSamples.length)
+        {
+            throw new IllegalStateException("End of buffer exceeded");
+        }
+
+        int offset = mSamplesPointer;
+        int fragmentPointer = 0;
+        float[] scaledSamples = new float[VECTOR_SPECIES.length()];
+
+        while(fragmentPointer < FRAGMENT_SIZE)
+        {
+            for(int y = 0; y < VECTOR_SPECIES.length(); y++)
+            {
+                //Couldn't figure out an easy way to load as a short vector and recast to a float vector
+                scaledSamples[y] = mSamples[offset++];
+            }
+
+            //SIMD scaling operation
+            FloatVector.fromArray(VECTOR_SPECIES, scaledSamples, 0)
+                    .sub(2048.0f)
+                    .mul(SCALE_SIGNED_12_BIT_TO_FLOAT)
+                    .sub(mAverageDc)
+                    .intoArray(scaledSamples, 0);
+
+            for(int y = 0; y < VECTOR_SPECIES.length(); y += 2)
+            {
+                mIBuffer[fragmentPointer + I_OVERLAP] = scaledSamples[y];
+                mQBuffer[fragmentPointer++ + Q_OVERLAP] = scaledSamples[y + 1];
+            }
+        }
+
+        mSamplesPointer = offset;
+
+        float[] samples = new float[FRAGMENT_SIZE * 2];
+        FloatVector accumulator;
+        FloatVector f1 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 0);
+        FloatVector f2 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 2);
+        FloatVector f3 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 4);
+        FloatVector f4 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 6);
+        FloatVector f5 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 8);
+        FloatVector f6 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 10);
+        FloatVector f7 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 12);
+        FloatVector f8 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 14);
+        FloatVector f9 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 16);
+        FloatVector f10 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 18);
+        FloatVector f11 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 20);
+        FloatVector f12 = FloatVector.fromArray(VECTOR_SPECIES, COEFFICIENTS, 22);
+
+        for(int x = 0; x < FRAGMENT_SIZE; x++)
+        {
+            accumulator = FloatVector.zero(VECTOR_SPECIES);
+            accumulator = f1.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x), accumulator);
+            accumulator = f2.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 2), accumulator);
+            accumulator = f3.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 4), accumulator);
+            accumulator = f4.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 6), accumulator);
+            accumulator = f5.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 8), accumulator);
+            accumulator = f6.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 10), accumulator);
+            accumulator = f7.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 12), accumulator);
+            accumulator = f8.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 14), accumulator);
+            accumulator = f9.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 16), accumulator);
+            accumulator = f10.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 18), accumulator);
+            accumulator = f11.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 20), accumulator);
+            accumulator = f12.fma(FloatVector.fromArray(VECTOR_SPECIES, mQBuffer, x + 22), accumulator);
+
+            //Perform FS/2 frequency translation on final filtered values ... multiply sequence by 1, -1, etc.
+            if(x % 2 == 0)
+            {
+                samples[2 * x] = mIBuffer[x];
+                samples[2 * x + 1] = accumulator.reduceLanes(VectorOperators.ADD);
+            }
+            else
+            {
+                samples[2 * x] = -mIBuffer[x];
+                samples[2 * x + 1] = -accumulator.reduceLanes(VectorOperators.ADD);
+            }
+        }
+
+        //Copy residual end samples to beginning of buffers for the next iteration
+        System.arraycopy(mIBuffer, FRAGMENT_SIZE, mIBuffer, 0, I_OVERLAP);
+        System.arraycopy(mQBuffer, FRAGMENT_SIZE, mQBuffer, 0, Q_OVERLAP);
+
+        return new InterleavedComplexSamples(samples, mTimestamp);
+    }
+}

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

@@ -0,0 +1,109 @@
+/*
+ * *****************************************************************************
+ * 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.airspy;
+
+import io.github.dsheirer.buffer.INativeBuffer;
+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
+{
+    private short[] mSamples;
+    private short[] mResidualI;
+    private short[] mResidualQ;
+    private float mAverageDc;
+    private long mTimestamp;
+    private Implementation mInterleavedImplementation;
+    private Implementation mNonInterleavedImplementation;
+
+    /**
+     * Constructs an instance
+     * @param samples (non-packed) from the airspy device
+     * @param residualI samples from previous buffer
+     * @param residualQ samples from previous buffer
+     * @param averageDc measured
+     * @param timestamp of the buffer
+     * @param interleavedImplementation optimal, scalar vs vector SIMD
+     * @param nonInterleavedImplementation optimal, scalar vs vector SIMD
+     */
+    public AirspyNativeBuffer(short[] samples, short[] residualI, short[] residualQ, float averageDc,
+                              long timestamp, Implementation interleavedImplementation,
+                              Implementation nonInterleavedImplementation)
+    {
+        //Ensure we're an even multiple of the fragment size.  Typically, this will be 64k or 128k
+        if(samples.length % AirspyBufferIterator.FRAGMENT_SIZE != 0)
+        {
+            throw new IllegalArgumentException("Samples short[] length [" + samples.length +
+                    "] must be an even multiple of " + AirspyBufferIterator.FRAGMENT_SIZE);
+        }
+
+        mSamples = samples;
+        mResidualI = residualI;
+        mResidualQ = residualQ;
+        mAverageDc = averageDc;
+        mTimestamp = timestamp;
+        mInterleavedImplementation = interleavedImplementation;
+        mNonInterleavedImplementation = nonInterleavedImplementation;
+    }
+
+    @Override
+    public int sampleCount()
+    {
+        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);
+        };
+    }
+
+    @Override
+    public Iterator<InterleavedComplexSamples> iteratorInterleaved()
+    {
+        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);
+        };
+    }
+}

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

@@ -0,0 +1,136 @@
+/*
+ * *****************************************************************************
+ * 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.airspy;
+
+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
+{
+    private boolean mSamplePacking = false;
+    private short[] mResidualI = new short[AirspyBufferIterator.I_OVERLAP];
+    private short[] mResidualQ = new short[AirspyBufferIterator.Q_OVERLAP];
+    private IAirspySampleConverter mConverter;
+    private Implementation mInterleavedIteratorImplementation;
+    private Implementation mNonInterleavedIteratorImplementation;
+
+    /**
+     * Constructs an instance
+     */
+    public AirspyNativeBufferFactory()
+    {
+        updateConverter();
+
+        mInterleavedIteratorImplementation = CalibrationManager.getInstance()
+                .getImplementation(CalibrationType.AIRSPY_UNPACKED_INTERLEAVED_ITERATOR);
+        mNonInterleavedIteratorImplementation = CalibrationManager.getInstance()
+                .getImplementation(CalibrationType.AIRSPY_UNPACKED_ITERATOR);
+    }
+
+    /**
+     * Sample packing places two 12-bit samples into 3 bytes when enabled or
+     * places two 12-bit samples into 4 bytes when disabled.
+     *
+     * @param enabled
+     */
+    public void setSamplePacking(boolean enabled)
+    {
+        mSamplePacking = enabled;
+        updateConverter();
+    }
+
+    /**
+     * Creates an optimal sample converter instance.
+     */
+    private void updateConverter()
+    {
+        if(mSamplePacking)
+        {
+            if(!(mConverter instanceof ScalarPackedSampleConverter))
+            {
+                mConverter = new ScalarPackedSampleConverter();
+            }
+        }
+        else
+        {
+            Implementation implementation = CalibrationManager.getInstance().getImplementation(CalibrationType.AIRSPY_SAMPLE_CONVERTER);
+
+            if(implementation == Implementation.VECTOR_SIMD_PREFERRED)
+            {
+                if(!(mConverter instanceof VectorUnpackedSampleConverter))
+                {
+                    mConverter = new VectorUnpackedSampleConverter();
+                }
+            }
+            else
+            {
+                if(!(mConverter instanceof ScalarUnpackedSampleConverter))
+                {
+                    mConverter = new ScalarUnpackedSampleConverter();
+                }
+            }
+        }
+    }
+
+    @Override
+    public INativeBuffer getBuffer(ByteBuffer buffer, long timestamp)
+    {
+        short[] samples = mConverter.convert(buffer);
+
+        INativeBuffer nativeBuffer = new AirspyNativeBuffer(samples,
+                Arrays.copyOf(mResidualI, mResidualI.length),
+                Arrays.copyOf(mResidualQ, mResidualQ.length), mConverter.getAverageDc(), timestamp,
+                mInterleavedIteratorImplementation, mNonInterleavedIteratorImplementation);
+
+        extractResidual(samples);
+
+        return nativeBuffer;
+    }
+
+    /**
+     * Extracts the residual overlap samples needed for continuity in the Hilbert transform filter.
+     * @param samples to extract residual from
+     */
+    private void extractResidual(short[] samples)
+    {
+        int offset = samples.length - (AirspyBufferIterator.I_OVERLAP * 2);
+
+        for(int i = 0; i < AirspyBufferIterator.I_OVERLAP; i++)
+        {
+            mResidualI[i] = samples[offset + (2 * i)];
+        }
+
+        offset = samples.length - (AirspyBufferIterator.Q_OVERLAP * 2) + 1;
+
+        for(int q = 0; q < AirspyBufferIterator.Q_OVERLAP; q++)
+        {
+            mResidualQ[q] = samples[offset + (2 * q)];
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+/*
+ * *****************************************************************************
+ * 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.airspy;
+
+import java.nio.ByteBuffer;
+
+/**
+ * Interface to convert airspy samples from a byte buffer to an array of shorts.
+ */
+public interface IAirspySampleConverter
+{
+    /**
+     * Converts the airspy byte samples contained in the byte buffer to their short-valued representation
+     * @param buffer of airspy samples
+     * @return converted samples
+     */
+    short[] convert(ByteBuffer buffer);
+
+    /**
+     * Current DC average of the samples that have been processed thus far.
+     */
+    float getAverageDc();
+}

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

@@ -0,0 +1,98 @@
+/*
+ * *****************************************************************************
+ * 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.airspy;
+
+import java.nio.ByteBuffer;
+
+/**
+ * Scalar implementation of airspy sample converter for un-packed samples.
+ */
+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;
+
+    @Override
+    public short[] convert(ByteBuffer buffer)
+    {
+        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)
+        {
+            b1 = buffer.get(offset++);
+            b2 = buffer.get(offset++);
+            b3 = buffer.get(offset++);
+
+            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;
+        }
+
+        //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;
+    }
+
+    public static void main(String[] args)
+    {
+        byte[] raw = new byte[262144];
+        ByteBuffer buffer = ByteBuffer.wrap(raw);
+
+        ScalarPackedSampleConverter scalar = new ScalarPackedSampleConverter();
+        VectorUnpackedSampleConverter vector = new VectorUnpackedSampleConverter();
+
+        long accumulator = 0;
+        int iterations = 1_000_000;
+
+        System.out.println("Starting ...");
+        long start = System.currentTimeMillis();
+        for(int count = 0; count < iterations; count++)
+        {
+//            short[] samples = scalar.convert(buffer);
+            short[] samples = vector.convert(buffer);
+            accumulator += samples[1];
+        }
+        long elapsed = System.currentTimeMillis() - start;
+
+        System.out.println("Accumulator: " + accumulator);
+        System.out.println("Elapsed: " + (elapsed / 1000.0f));
+        System.out.println("Finished");
+    }
+}

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

@@ -0,0 +1,66 @@
+/*
+ * *****************************************************************************
+ * 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.airspy;
+
+import java.nio.ByteBuffer;
+
+/**
+ * Scalar implementation of airspy sample converter for un-packed samples.
+ */
+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;
+
+    @Override
+    public short[] convert(ByteBuffer buffer)
+    {
+        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++)
+        {
+            b1 = buffer.get(offset++);
+            b2 = buffer.get(offset++);
+            sample = (short)(((b2 & 0x0F) << 8) | (b1 & 0xFF));
+            samples[x] = sample;
+            dcAccumulator += 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;
+    }
+}

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

@@ -0,0 +1,96 @@
+/*
+ * *****************************************************************************
+ * 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.airspy;
+
+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;
+
+    @Override
+    public short[] convert(ByteBuffer buffer)
+    {
+        long dcAccumulator = 0;
+        short sample;
+        short[] samples;
+        byte b1, b2;
+
+        samples = new short[buffer.capacity() / 2];
+
+        int bytesOffset;
+        int rawPointer = 0;
+        ShortVector vector;
+
+        int samplesOffset = 0;
+
+        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())
+        {
+            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);
+        }
+
+        for(; samplesOffset < samples.length; samplesOffset++)
+        {
+            b1 = buffer.get(rawPointer++);
+            b2 = buffer.get(rawPointer++);
+
+            sample = (short)(((b2 & 0x0F) << 8) | (b1 & 0xFF));
+            samples[samplesOffset] = sample;
+            dcAccumulator += 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;
+    }
+}

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

@@ -22,6 +22,7 @@ package io.github.dsheirer.channel.metadata;
 import com.jidesoft.swing.JideSplitPane;
 import com.jidesoft.swing.JideTabbedPane;
 import io.github.dsheirer.channel.details.ChannelDetailPanel;
+import io.github.dsheirer.gui.power.ChannelPowerPanel;
 import io.github.dsheirer.icon.IconModel;
 import io.github.dsheirer.module.decode.event.DecodeEventPanel;
 import io.github.dsheirer.module.decode.event.MessageActivityPanel;
@@ -38,6 +39,7 @@ public class NowPlayingPanel extends JPanel
     private ChannelDetailPanel mChannelDetailPanel;
     private DecodeEventPanel mDecodeEventPanel;
     private MessageActivityPanel mMessageActivityPanel;
+    private ChannelPowerPanel mChannelPowerPanel;
 
     /**
      * GUI panel that combines the currently decoding channels metadata table and viewers for channel details,
@@ -49,6 +51,7 @@ public class NowPlayingPanel extends JPanel
         mDecodeEventPanel = new DecodeEventPanel(iconModel, userPreferences, playlistManager.getAliasModel());
         mMessageActivityPanel = new MessageActivityPanel(userPreferences);
         mChannelMetadataPanel = new ChannelMetadataPanel(playlistManager, iconModel, userPreferences);
+        mChannelPowerPanel = new ChannelPowerPanel(playlistManager);
 
         init();
     }
@@ -61,6 +64,7 @@ public class NowPlayingPanel extends JPanel
         tabbedPane.addTab("Details", mChannelDetailPanel);
         tabbedPane.addTab("Events", mDecodeEventPanel);
         tabbedPane.addTab("Messages", mMessageActivityPanel);
+        tabbedPane.addTab("Channel", mChannelPowerPanel);
         tabbedPane.setFont(this.getFont());
         tabbedPane.setForeground(Color.BLACK);
 
@@ -73,5 +77,6 @@ public class NowPlayingPanel extends JPanel
         mChannelMetadataPanel.addProcessingChainSelectionListener(mChannelDetailPanel);
         mChannelMetadataPanel.addProcessingChainSelectionListener(mDecodeEventPanel);
         mChannelMetadataPanel.addProcessingChainSelectionListener(mMessageActivityPanel);
+        mChannelMetadataPanel.addProcessingChainSelectionListener(mChannelPowerPanel);
     }
 }

src/main/java/io/github/dsheirer/channel/state/AbstractChannelState.java

@@ -1,23 +1,20 @@
 /*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 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.channel.state;
@@ -57,6 +54,9 @@ public abstract class AbstractChannelState extends Module implements IChannelEve
     protected boolean mSourceOverflow = false;
     private HeartbeatReceiver mHeartbeatReceiver = new HeartbeatReceiver();
 
+
+    //TODO: remove the IOverflowListener code from this class
+
     /**
      * Constructs an instance
      * @param channel configuration

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

@@ -1,3 +1,22 @@
+/*
+ * *****************************************************************************
+ * 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.controller;
 
 import io.github.dsheirer.util.ThreadPool;
@@ -24,11 +43,8 @@ public class NamingThreadFactory implements ThreadFactory
 
     public NamingThreadFactory( String prefix ) 
     {
-    	SecurityManager s = System.getSecurityManager();
-        
-        mThreadGroup = (s != null)? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
-        
-        mNamePrefix = prefix + " pool-" + mPoolNumber.getAndIncrement() + "-thread-";
+        mThreadGroup = Thread.currentThread().getThreadGroup();
+        mNamePrefix = prefix + " thread ";
     }
 
     public Thread newThread( Runnable runnable ) 

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

@@ -62,6 +62,8 @@ import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 
 /**
  * Channel processing manager handles all starting and stopping of channel decoding.  A processing chain is created
@@ -74,7 +76,9 @@ public class ChannelProcessingManager implements Listener<ChannelEvent>
     private final static Logger mLog = LoggerFactory.getLogger(ChannelProcessingManager.class);
     private static final String TUNER_UNAVAILABLE_DESCRIPTION = "TUNER UNAVAILABLE";
     private Map<Channel,ProcessingChain> mProcessingChains = new ConcurrentHashMap<>();
+    private Lock mLock = new ReentrantLock();
 
+    private ChannelSourceEventErrorListener mSourceErrorListener = new ChannelSourceEventErrorListener();
     private List<Listener<AudioSegment>> mAudioSegmentListeners = new CopyOnWriteArrayList<>();
     private List<Listener<IDecodeEvent>> mDecodeEventListeners = new CopyOnWriteArrayList<>();
     private Broadcaster<ChannelEvent> mChannelEventBroadcaster = new Broadcaster();
@@ -170,9 +174,8 @@ public class ChannelProcessingManager implements Listener<ChannelEvent>
      *
      * @param event that requests either enable/start or disable/stop a channel.
      */
-    @Deprecated //TODO: convert all usage to start(ChannelStartProcessingRequest request) method
     @Override
-    public synchronized void receive(ChannelEvent event)
+    public void receive(ChannelEvent event)
     {
         Channel channel = event.getChannel();
 
@@ -350,38 +353,9 @@ public class ChannelProcessingManager implements Listener<ChannelEvent>
             processingChain.addDecodeEventListener(listener);
         }
 
-        //Add a listener to detect source error state that indicates the channel should be shutdown
-        processingChain.addSourceEventListener(sourceEvent ->
-        {
-            if(sourceEvent.getEvent() == SourceEvent.Event.NOTIFICATION_ERROR_STATE && sourceEvent.getSource() != null)
-            {
-                Channel toShutdown = null;
-
-                for(Map.Entry<Channel,ProcessingChain> entry: mProcessingChains.entrySet())
-                {
-                    if(entry.getValue().hasSource(sourceEvent.getSource()))
-                    {
-                        toShutdown = entry.getKey();
-                        break;
-                    }
-                }
-
-                if(toShutdown != null)
-                {
-                    mLog.warn("Channel source error detected - stopping channel [" + toShutdown.getName() + "]");
-
-                    try
-                    {
-                        stopProcessing(toShutdown);
-                    }
-                    catch(ChannelException ce)
-                    {
-                        mLog.error("Error stopping channel [" + channel.getName() + "] with source error - " +
-                            ce.getMessage());
-                    }
-                }
-            }
-        });
+        //Add a listener to detect source error state that indicates the channel should be shutdown.
+        //Note: processing chain will only add this once.
+        processingChain.addSourceEventListener(mSourceErrorListener);
 
         //Register this manager to receive channel events from traffic channel manager modules within
         //the processing chain
@@ -459,18 +433,90 @@ public class ChannelProcessingManager implements Listener<ChannelEvent>
                     processingChain.getChannelState().updateChannelStateIdentifiers(notification);
                 }
             }
-
         }
 
-        mProcessingChains.put(channel, processingChain);
-        processingChain.start();
+        if(addProcessingChain(channel, processingChain))
+        {
+            processingChain.start();
 
-        //This has to be done on the FX event thread when the playlist editor is constructed
-        Platform.runLater(() -> channel.setProcessing(true));
+            //This has to be done on the FX event thread when the playlist editor is constructed
+            Platform.runLater(() -> channel.setProcessing(true));
 
-        getChannelMetadataModel().add(new ChannelAndMetadata(channel, processingChain.getChannelState().getChannelMetadata()));
+            mChannelEventBroadcaster.broadcast(new ChannelEvent(channel, ChannelEvent.Event.NOTIFICATION_PROCESSING_START));
+        }
+        else
+        {
+            mLog.warn("Channel [" + channel.getName() + "] processing chain not added because it already exists");
+            processingChain.removeEventLoggingModules();
+            processingChain.removeRecordingModules();
+            processingChain.removeFrequencyChangeListener(channel);
+            channel.resetFrequencyCorrection();
+            mChannelEventBroadcaster.broadcast(new ChannelEvent(channel, ChannelEvent.Event.NOTIFICATION_PROCESSING_STOP));
+            mChannelEventBroadcaster.removeListener(processingChain);
+            processingChain.getEventBus().unregister(ChannelProcessingManager.this);
+            processingChain.dispose();
+        }
+    }
 
-        mChannelEventBroadcaster.broadcast(new ChannelEvent(channel, ChannelEvent.Event.NOTIFICATION_PROCESSING_START));
+    /**
+     * Thread-safe add processing chain and add channel metadata to channel metadata model.
+     * @param channel for the processing chain
+     * @param processingChain to add
+     * @return true if processing chain was added or false if it was not added due to there already
+     * being a processing chain registered for that channel.
+     */
+    private boolean addProcessingChain(Channel channel, ProcessingChain processingChain)
+    {
+        boolean added = false;
+
+        mLock.lock();
+
+        try
+        {
+            if(!mProcessingChains.containsKey(channel))
+            {
+                added = true;
+                mProcessingChains.put(channel, processingChain);
+                getChannelMetadataModel().add(new ChannelAndMetadata(channel, processingChain.getChannelState().getChannelMetadata()));
+            }
+        }
+        finally
+        {
+            mLock.unlock();
+        }
+
+        return added;
+    }
+
+    /**
+     * Thread-safe remove processing chain.
+     * @param channel for identifying the processing chain
+     * @return the removed processing chain or null
+     */
+    private ProcessingChain removeProcessingChain(Channel channel)
+    {
+        ProcessingChain removed = null;
+
+        mLock.lock();
+
+        try
+        {
+            removed = mProcessingChains.remove(channel);
+
+            if(removed != null)
+            {
+                for(ChannelMetadata channelMetadata: removed.getChannelState().getChannelMetadata())
+                {
+                    getChannelMetadataModel().remove(channelMetadata);
+                }
+            }
+        }
+        finally
+        {
+            mLock.unlock();
+        }
+
+        return removed;
     }
 
     /**
@@ -483,30 +529,34 @@ public class ChannelProcessingManager implements Listener<ChannelEvent>
         //This has to be done on the FX event thread when the playlist editor is constructed
         Platform.runLater(() -> channel.setProcessing(false));
 
-        if(mProcessingChains.containsKey(channel))
+        ProcessingChain processingChain = removeProcessingChain(channel);
+
+        if(processingChain != null)
         {
-            ProcessingChain processingChain = mProcessingChains.remove(channel);
+            //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();
 
-            for(ChannelMetadata channelMetadata: processingChain.getChannelState().getChannelMetadata())
-            {
-                getChannelMetadataModel().remove(channelMetadata);
-            }
+                    //Deregister channel from receive frequency correction events to show in the spectral display (hack!)
+                    processingChain.removeFrequencyChangeListener(channel);
+                    channel.resetFrequencyCorrection();
 
-            processingChain.stop();
+                    mChannelEventBroadcaster.broadcast(new ChannelEvent(channel, ChannelEvent.Event.NOTIFICATION_PROCESSING_STOP));
+                    mChannelEventBroadcaster.removeListener(processingChain);
 
-            processingChain.removeEventLoggingModules();
-            processingChain.removeRecordingModules();
-
-            //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);
-
-            //Unregister for event bus requests and notifications
-            processingChain.getEventBus().unregister(ChannelProcessingManager.this);
-            processingChain.dispose();
+                    //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);
+                }
+            });
         }
         else
         {
@@ -653,4 +703,52 @@ public class ChannelProcessingManager implements Listener<ChannelEvent>
             }
         }
     }
+
+    /**
+     * Monitors all channels for an error in the source event that would require the
+     * channel's processing chain to be stopped
+     */
+    private class ChannelSourceEventErrorListener implements Listener<SourceEvent>
+    {
+        @Override public void receive(SourceEvent sourceEvent)
+        {
+            if(sourceEvent.getEvent() == SourceEvent.Event.NOTIFICATION_ERROR_STATE && sourceEvent.getSource() != null)
+            {
+                Channel toShutdown = null;
+
+                mLock.lock();
+
+                try
+                {
+                    for(Map.Entry<Channel,ProcessingChain> entry: mProcessingChains.entrySet())
+                    {
+                        if(entry.getValue().hasSource(sourceEvent.getSource()))
+                        {
+                            toShutdown = entry.getKey();
+                            break;
+                        }
+                    }
+                }
+                finally
+                {
+                    mLock.unlock();
+                }
+
+                if(toShutdown != null)
+                {
+                    mLog.warn("Channel source error detected - stopping channel [" + toShutdown.getName() + "]");
+
+                    try
+                    {
+                        stopProcessing(toShutdown);
+                    }
+                    catch(ChannelException ce)
+                    {
+                        mLog.error("Error stopping channel [" + (toShutdown != null ? toShutdown.getName() : "unknown") +
+                                "] with source error - " + ce.getMessage());
+                    }
+                }
+            }
+        }
+    }
 }

src/main/java/io/github/dsheirer/dsp/afsk/AFSK1200Decoder.java

@@ -1,7 +1,6 @@
 /*
- * ******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2018 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,17 +14,16 @@
  *
  * 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.afsk;
 
 import io.github.dsheirer.bits.IBinarySymbolProcessor;
 import io.github.dsheirer.buffer.FloatAveragingBuffer;
 import io.github.dsheirer.dsp.filter.resample.RealResampler;
-import io.github.dsheirer.dsp.mixer.IOscillator;
-import io.github.dsheirer.dsp.mixer.Oscillator;
+import io.github.dsheirer.dsp.oscillator.IRealOscillator;
+import io.github.dsheirer.dsp.oscillator.OscillatorFactory;
 import io.github.dsheirer.sample.Listener;
-import io.github.dsheirer.sample.buffer.ReusableFloatBuffer;
 import org.apache.commons.math3.util.FastMath;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -39,7 +37,7 @@ import org.slf4j.LoggerFactory;
  *
  * Provides normal or inverted decoded output.
  */
-public class AFSK1200Decoder implements Listener<ReusableFloatBuffer>
+public class AFSK1200Decoder implements Listener<float[]>
 {
     private final static Logger mLog = LoggerFactory.getLogger(AFSK1200Decoder.class);
 
@@ -71,7 +69,7 @@ public class AFSK1200Decoder implements Listener<ReusableFloatBuffer>
     private boolean mSampleDecision;
 
     //Resample to an integral of the baud rate 1200 baud * 6 samples per symbol = 7200.0 Hertz
-    private RealResampler mResampler = new RealResampler(8000.0, SAMPLE_RATE, 2000, 1);
+    private RealResampler mResampler = new RealResampler(8000.0, SAMPLE_RATE, 8192, 512);
 
     /**
      * Constructs a decoder using the provided arguments.
@@ -115,7 +113,7 @@ public class AFSK1200Decoder implements Listener<ReusableFloatBuffer>
      * @param buffer containing 8.0 kHz unfiltered FM demodulated audio samples with sub-audible LTR signalling.
      */
     @Override
-    public void receive(ReusableFloatBuffer buffer)
+    public void receive(float[] buffer)
     {
         mResampler.resample(buffer);
     }
@@ -147,17 +145,15 @@ public class AFSK1200Decoder implements Listener<ReusableFloatBuffer>
     }
 
 
-    public class Decoder implements Listener<ReusableFloatBuffer>
+    public class Decoder implements Listener<float[]>
     {
         @Override
-        public void receive(ReusableFloatBuffer buffer)
+        public void receive(float[] buffer)
         {
             //Calculate correlation values against each 1200/1800 reference signal
             mCorrelationValuesMark = mCorrelatorMark.process(buffer);
             mCorrelationValuesSpace = mCorrelatorSpace.process(buffer);
 
-            buffer.decrementUserCount();
-
             for(int x = 0; x < mCorrelationValuesMark.length; x++)
             {
                 //1200 = Mark (1) and 1800 = Space (0)
@@ -207,8 +203,8 @@ public class AFSK1200Decoder implements Listener<ReusableFloatBuffer>
         {
             mAveragingBuffer = new FloatAveragingBuffer(averagingPeriod);
 
-            IOscillator referenceSignalGenerator = new Oscillator(frequency, sampleRate);
-            mReferenceSamples = referenceSignalGenerator.generateReal(correlationPeriod);
+            IRealOscillator referenceSignalGenerator = OscillatorFactory.getRealOscillator(frequency, sampleRate);
+            mReferenceSamples = referenceSignalGenerator.generate(correlationPeriod);
 
             mDemodulatedSamples = new float[correlationPeriod];
         }
@@ -217,18 +213,16 @@ public class AFSK1200Decoder implements Listener<ReusableFloatBuffer>
          * Processes each sample in the incoming sample buffer against a generated reference sample set for one symbol
          * period to derive a correlation value that is in-turn averaged over one symbol period.
          *
-         * @param reusableFloatBuffer containing FM demodulated samples
+         * @param samples containing FM demodulated samples
          * @return a reusable array of correlation values for each sample
          */
-        public float[] process(ReusableFloatBuffer reusableFloatBuffer)
+        public float[] process(float[] samples)
         {
-            if(mCorrelationValues == null || mCorrelationValues.length != reusableFloatBuffer.getSampleCount())
+            if(mCorrelationValues == null || mCorrelationValues.length != samples.length)
             {
-                mCorrelationValues = new float[reusableFloatBuffer.getSampleCount()];
+                mCorrelationValues = new float[samples.length];
             }
 
-            float[] samples = reusableFloatBuffer.getSamples();
-
             int y;
 
             for(int x = 0; x < samples.length; x++)

src/main/java/io/github/dsheirer/dsp/afsk/AFSKTest.java

@@ -1,123 +0,0 @@
-/*******************************************************************************
- * sdr-trunk
- * Copyright (C) 2014-2018 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.afsk;
-
-import io.github.dsheirer.buffer.FloatAveragingBuffer;
-import io.github.dsheirer.dsp.mixer.IOscillator;
-import io.github.dsheirer.dsp.mixer.Oscillator;
-import io.github.dsheirer.sample.complex.Complex;
-import org.apache.commons.math3.util.FastMath;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.text.DecimalFormat;
-
-public class AFSKTest
-{
-    private final static Logger mLog = LoggerFactory.getLogger(AFSK1200Decoder.class);
-
-    private static final DecimalFormat df = new DecimalFormat("00.000");
-
-    public static String format(double value)
-    {
-        if(value > 0)
-        {
-            return " " + df.format(value);
-        }
-        else
-        {
-            return df.format(value);
-        }
-    }
-
-    public static float[] generateAFSK1200(boolean[] symbols, int samplesPerSymbol, float gain)
-    {
-        float[] samples = new float[symbols.length * samplesPerSymbol];
-
-        Oscillator oscillator = new Oscillator(1200.0, (double)samplesPerSymbol * 1200);
-
-        for(int x = 0; x < symbols.length; x++)
-        {
-            oscillator.setFrequency(symbols[x] ? 1200.0 : 1800.0);
-
-            for(int y = 0; y < samplesPerSymbol; y++)
-            {
-                Complex sample = new Complex(oscillator.inphase(), oscillator.quadrature());
-                sample.multiply(gain);
-                samples[x * samplesPerSymbol + y] = sample.inphase();
-                oscillator.rotate();
-            }
-        }
-
-        return samples;
-    }
-
-    public static void main(String[] args)
-    {
-        int sampleSize = 6;
-
-        FloatAveragingBuffer avg1200 = new FloatAveragingBuffer(sampleSize);
-        FloatAveragingBuffer avg1800 = new FloatAveragingBuffer(sampleSize);
-
-        IOscillator oscillator1200 = new Oscillator(1200.0, 7200.0);
-        IOscillator oscillator1800 = new Oscillator(1800.0, 7200.0);
-        oscillator1200.generateReal(1);
-        oscillator1800.generateReal(1);
-
-        float[] reference1200 = oscillator1200.generateReal(sampleSize);
-        float[] reference1800 = oscillator1800.generateReal(sampleSize);
-
-        boolean[] symbols = new boolean[]{true,false,true,false,true,false,true,false,true,true,true,false,true,false,
-            false,false,true,false,false,false,false,true,false,true,true,true,true,false,true,true,false,true,false,
-            true,false,true,false,true,false,true,false,true,false,true,false,true,false,true,false,true,false,true,
-            false,true,false,true,false,true,false,true,false,true,false,true,false,true,false,true,false,true,false,
-            true,false,true,false,true,false,true,false,true,false,true,false,true,false,true,false,true,false,true,
-            false,true,false,true,false,true,false,true,false,true,false,true,false,true,false,true,false,true,false,
-            true,false,true,false,true,false,true,false,true,false,true,false,true,false,true,false,true,false,true,
-            false,true,false,true,false,true,false,true,false,true,false,true,false,true,false,true,false,true,false,
-            true,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,
-            false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false};
-
-        float[] samples = generateAFSK1200(symbols, 6, 0.5f);
-
-        mLog.debug("Length:" + samples.length);
-
-        int offset = 0;
-
-        float correlation1200 = 0.0f;
-        float correlation1800 = 0.0f;
-
-        while(offset + sampleSize < samples.length)
-        {
-            correlation1200 = 0.0f;
-            correlation1800 = 0.0f;
-
-            for(int x = 0; x < sampleSize; x++)
-            {
-                correlation1200 += reference1200[x] * samples[x + offset];
-                correlation1800 += reference1800[x] * samples[x + offset];
-            }
-
-            correlation1200 = avg1200.get(FastMath.abs(correlation1200));
-            correlation1800 = avg1800.get(FastMath.abs(correlation1800));
-
-            mLog.debug(offset + " 1200:" + format(correlation1200) + " 1800:" + format(correlation1800) +
-            " Decision: " + (correlation1200 > correlation1800 ? "0" : "1"));
-
-            offset++;
-        }
-    }
-}

src/main/java/io/github/dsheirer/dsp/am/AMDemodulator.java

@@ -1,32 +1,30 @@
-/*******************************************************************************
- * sdr-trunk
- * Copyright (C) 2014-2018 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  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.am;
 
-import io.github.dsheirer.sample.buffer.ReusableBufferQueue;
-import io.github.dsheirer.sample.buffer.ReusableComplexBuffer;
-import io.github.dsheirer.sample.buffer.ReusableFloatBuffer;
 import org.apache.commons.math3.util.FastMath;
 
 /**
  * Performs AM demodulation on baseband I/Q samples to produce demodulated float output.
  */
-public class AMDemodulator
+public class AMDemodulator implements IAmDemodulator
 {
-    private ReusableBufferQueue mReusableBufferQueue = new ReusableBufferQueue("AMDemodulator");
-    private int mOutputBufferPointer;
     private float mGain;
 
     /**
@@ -59,25 +57,15 @@ public class AMDemodulator
         return (float) FastMath.sqrt((inphase * inphase) + (quadrature * quadrature)) * mGain;
     }
 
-    /**
-     * Demodulates the reusable comples sample buffer and returns a demodulated audio buffer.
-     * @param complexBuffer to demodulate
-     * @return demodulated audio buffer.
-     */
-    public ReusableFloatBuffer demodulate(ReusableComplexBuffer complexBuffer)
+    @Override public float[] demodulate(float[] i, float[] q)
     {
-        ReusableFloatBuffer reusableFloatBuffer = mReusableBufferQueue.getBuffer(complexBuffer.getSampleCount());
-        float[] input = complexBuffer.getSamples();
-        float[] output = reusableFloatBuffer.getSamples();
-        mOutputBufferPointer = 0;
+        float[] demodulated = new float[i.length];
 
-        for(int x= 0; x < complexBuffer.getSamples().length; x += 2)
+        for(int x = 0; x < i.length; x++)
         {
-            output[mOutputBufferPointer++] = demodulate(input[x], input[x + 1]);
+            demodulated[x] = (float)FastMath.sqrt((i[x] * i[x]) + (q[x] * q[x])) * mGain;
         }
 
-        complexBuffer.decrementUserCount();
-
-        return reusableFloatBuffer;
+        return demodulated;
     }
 }

src/main/java/io/github/dsheirer/dsp/am/IAmDemodulator.java

@@ -0,0 +1,15 @@
+package io.github.dsheirer.dsp.am;
+
+/**
+ * AM Demodulator interface
+ */
+public interface IAmDemodulator
+{
+    /**
+     * Demodulate the complex I & Q sample arrays
+     * @param i samples
+     * @param q samples
+     * @return demodulated samples.
+     */
+    float[] demodulate(float[] i, float[] q);
+}

src/main/java/io/github/dsheirer/dsp/filter/FilterFactory.java

@@ -1,37 +1,67 @@
-/*******************************************************************************
- *     SDR Trunk 
- *     Copyright (C) 2014,2015 Dennis Sheirer
+/*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 Dennis Sheirer
  *
- *	   Root Raised Cosine filter designer:
- *	   Copyright 2002,2007,2008,2012,2013 Free Software Foundation, Inc.
- *	   http://gnuradio.org/redmine/projects/gnuradio/repository/changes/gr-filter
- *	   /lib/firdes.cc?rev=435b1d166f0c7092bbd5e1f788e75dbb6ade3a4b
+ * 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;
 
+import io.github.dsheirer.dsp.filter.decimate.IRealDecimationFilter;
 import io.github.dsheirer.dsp.filter.design.FilterDesignException;
 import io.github.dsheirer.dsp.filter.fir.FIRFilterSpecification;
+import io.github.dsheirer.dsp.filter.fir.real.IRealFilter;
+import io.github.dsheirer.dsp.filter.fir.real.RealFIRFilter;
+import io.github.dsheirer.dsp.filter.fir.real.VectorRealFIRFilter128Bit;
+import io.github.dsheirer.dsp.filter.fir.real.VectorRealFIRFilter256Bit;
+import io.github.dsheirer.dsp.filter.fir.real.VectorRealFIRFilter512Bit;
+import io.github.dsheirer.dsp.filter.fir.real.VectorRealFIRFilter64Bit;
+import io.github.dsheirer.dsp.filter.fir.real.VectorRealFIRFilterDefaultBit;
 import io.github.dsheirer.dsp.filter.fir.remez.RemezFIRFilterDesigner;
 import io.github.dsheirer.dsp.filter.fir.remez.RemezFIRFilterDesignerWithLagrange;
+import io.github.dsheirer.dsp.filter.halfband.RealHalfBandDecimationFilter;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter11Tap128Bit;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter11Tap256Bit;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter11Tap512Bit;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter11Tap64Bit;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter128Bit;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter15Tap128Bit;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter15Tap256Bit;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter15Tap512Bit;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter15Tap64Bit;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter23Tap128Bit;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter23Tap256Bit;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter23Tap512Bit;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter23Tap64Bit;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter256Bit;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter512Bit;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter63Tap128Bit;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter63Tap256Bit;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter63Tap512Bit;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter63Tap64Bit;
+import io.github.dsheirer.dsp.filter.halfband.VectorRealHalfBandDecimationFilter64Bit;
+import io.github.dsheirer.dsp.window.WindowFactory;
+import io.github.dsheirer.dsp.window.WindowType;
+import io.github.dsheirer.vector.calibrate.CalibrationManager;
+import io.github.dsheirer.vector.calibrate.CalibrationType;
+import io.github.dsheirer.vector.calibrate.Implementation;
 import org.apache.commons.math3.util.FastMath;
 import org.jtransforms.fft.FloatFFT_1D;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.Arrays;
+import java.text.DecimalFormat;
 import java.util.Set;
 import java.util.TreeSet;
 
@@ -51,9 +81,9 @@ public class FilterFactory
      * @param frequency - cutoff in hertz
      * @param length - filter length
      * @param window - to apply against the coefficients
-     * @return
+     * @return coefficients
      */
-    public static float[] getSinc(double sampleRate, long frequency, int length, Window.WindowType window)
+    public static float[] getSinc(double sampleRate, long frequency, int length, WindowType window)
     {
         int evenLength = length % 2 == 0 ? length : length + 1;
 
@@ -94,7 +124,7 @@ public class FilterFactory
         }
 
         //Apply the window against the coefficients
-        coefficients = Window.apply(window, coefficients);
+        coefficients = WindowFactory.apply(window, coefficients);
 
         return coefficients;
     }
@@ -227,7 +257,7 @@ public class FilterFactory
      * @param windowType - window to apply against the generated coefficients
      * @return
      */
-    public static float[] getLowPass(double sampleRate, long cutoff, int filterLength, Window.WindowType windowType)
+    public static float[] getLowPass(double sampleRate, long cutoff, int filterLength, WindowType windowType)
     {
         return getSinc(sampleRate, cutoff, filterLength, windowType);
     }
@@ -247,7 +277,7 @@ public class FilterFactory
      * - stopFrequency <= sampleRate/2
      */
     public static float[] getLowPass(double sampleRate, int passFrequency, int stopFrequency, int attenuation,
-                                     Window.WindowType windowType, boolean forceOddLength)
+                                     WindowType windowType, boolean forceOddLength)
     {
         if(stopFrequency < passFrequency || stopFrequency > (sampleRate / 2))
         {
@@ -280,7 +310,7 @@ public class FilterFactory
      * @param windowType - window to apply against the generated coefficients
      * @return
      */
-    public static float[] getHighPass(int sampleRate, long cutoff, int filterLength, Window.WindowType windowType)
+    public static float[] getHighPass(int sampleRate, long cutoff, int filterLength, WindowType windowType)
     {
         //Convert the high frequency cutoff to its low frequency cutoff
         //equivalent, so that when we generate the low pass filter, prior to
@@ -291,7 +321,7 @@ public class FilterFactory
     }
 
     public static float[] getHighPass(int sampleRate, long stopFrequency, long passFrequency, int attenuation,
-                                      Window.WindowType windowType, boolean forceOddLength)
+                                      WindowType windowType, boolean forceOddLength)
     {
         /* reverse the stop and pass frequency to get the low pass variant */
         int tapCount = getTapCount(sampleRate, stopFrequency, passFrequency, attenuation);
@@ -512,7 +542,7 @@ public class FilterFactory
      * @param outputSampleRate
      * @return
      */
-    public static float[] getCICCleanupFilter(int outputSampleRate, int passFrequency, int attenuation, Window.WindowType window)
+    public static float[] getCICCleanupFilter(int outputSampleRate, int passFrequency, int attenuation, WindowType window)
     {
         int taps = getTapCount(outputSampleRate, passFrequency, passFrequency + 1500,
             attenuation);
@@ -764,7 +794,7 @@ public class FilterFactory
         double cutoff = (channelBandwidth * 1.10) / (channelSampleRate * (double)channels);
 
         //Design the prototype synthesizer with 105% of the channel bandwidth produced by the channelizer.
-        float[] taps = FilterFactory.getKaiserSinc(filterLength, cutoff, 80.0);
+        float[] taps = FilterFactory.getKaiserSinc(filterLength, cutoff, 80.0f);
 
         //This is an odd length filter - increase the length by 1 by pre-padding a zero coefficient
         float[] extendedTaps = new float[taps.length + 1];
@@ -823,7 +853,7 @@ public class FilterFactory
         //Get an initial filter and band edge frequency response using the channel bandwidth as a cutoff
         float[] taps = null;
 
-        taps = FilterFactory.getKaiserSinc(filterLength, cutoffFrequency, 80.0);
+        taps = FilterFactory.getKaiserSinc(filterLength, cutoffFrequency, 80.0f);
         double response = FilterFactory.evaluate(taps, bandEdge);
 
         //Set cutoff adjustment threshold - we'll test cutoff frequencies to around 1 hertz resolution
@@ -836,7 +866,7 @@ public class FilterFactory
             if(matchesObjective(response, PERFECT_RECONSTRUCTION_GAIN_AT_BAND_EDGE, MARGIN_OF_ERROR) &&
                 (cutoffFrequency + increment <= bandEdge))
             {
-                float[] higherCutoffTaps = FilterFactory.getKaiserSinc(filterLength, cutoffFrequency + increment, 80.0);
+                float[] higherCutoffTaps = FilterFactory.getKaiserSinc(filterLength, cutoffFrequency + increment, 80.0f);
                 double higherCutoffResponse = FilterFactory.evaluate(higherCutoffTaps, bandEdge);
 
                 if(matchesObjective(higherCutoffResponse, PERFECT_RECONSTRUCTION_GAIN_AT_BAND_EDGE, MARGIN_OF_ERROR))
@@ -882,7 +912,7 @@ public class FilterFactory
                     increment = cutoffFrequency * 0.1;
                 }
 
-                taps = FilterFactory.getKaiserSinc(filterLength, cutoffFrequency, 80.0);
+                taps = FilterFactory.getKaiserSinc(filterLength, cutoffFrequency, 80.0f);
                 response = FilterFactory.evaluate(taps, bandEdge);
             }
         }
@@ -904,7 +934,7 @@ public class FilterFactory
             mLog.debug("Input Sample Rate: " + sampleRate);
             mLog.debug("Channel Bandwidth: " + channelBandwidth);
             mLog.debug("Channels: " + channels);
-            mLog.debug("Window Type: " + Window.WindowType.KAISER.name());
+            mLog.debug("Window Type: " + WindowType.KAISER.name());
             mLog.debug("Taps Per Channel - Requested:" + tapsPerChannel + " Actual:" + ((double)extendedTaps.length / (double)channels));
             mLog.debug("Filter Length: " + (extendedTaps.length));
             mLog.debug("Requested Cutoff Frequency:  " + (sampleRate * bandEdge));
@@ -932,7 +962,7 @@ public class FilterFactory
      * @return filter coefficients.
      * @throws FilterDesignException if the requested length is not odd
      */
-    public static float[] getSinc(double cutoff, int length, Window.WindowType windowType) throws FilterDesignException
+    public static float[] getSinc(double cutoff, int length, WindowType windowType) throws FilterDesignException
     {
         if(length % 2 == 0)
         {
@@ -942,7 +972,7 @@ public class FilterFactory
         float[] coefficients = new float[length];
         int half = length / 2;
 
-        double[] window = Window.getWindow(windowType, length);
+        float[] window = WindowFactory.getWindow(windowType, length);
 
         double scalor = 2.0 * cutoff;
         double piScalor = FastMath.PI * scalor;
@@ -971,7 +1001,7 @@ public class FilterFactory
      * @return filter coefficients.
      * @throws FilterDesignException if the requested length is not odd
      */
-    public static float[] getKaiserSinc(int length, double cutoff, double attenuation) throws FilterDesignException
+    public static float[] getKaiserSinc(int length, double cutoff, float attenuation) throws FilterDesignException
     {
         if(length % 2 == 0)
         {
@@ -981,7 +1011,7 @@ public class FilterFactory
         float[] coefficients = new float[length];
         int half = length / 2;
 
-        double[] window = Window.getKaiser(length, attenuation);
+        float[] window = WindowFactory.getKaiser(length, attenuation);
 
         double scalor = 2.0 * cutoff;
         double piScalor = FastMath.PI * scalor;
@@ -1001,6 +1031,169 @@ public class FilterFactory
         return coefficients;
     }
 
+    /**
+     * Creates a symmetrical half-band filter where all odd-indexed coefficients except center are zero
+     * valued.
+     * @param length N is odd where m is an integer multiple in the formula: N = 4m + 3 (e.g. 7, 11, 15, etc.)
+     * @param windowType to apply to the filter.
+     * @return coefficients
+     */
+    public static float[] getHalfBand(int length, WindowType windowType)
+    {
+        if((length - 3) % 4 != 0)
+        {
+            throw new IllegalArgumentException("Half Band filter length (N) must be an odd length where m must be an " +
+                    "integer multiple in (N=4m+3), e.g. 7, 11, 15, etc");
+        }
+
+        float[] window = WindowFactory.getWindow(windowType, length);
+        float[] taps = new float[length];
+
+        int halfLength = length / 2;
+
+        for(int x = 0; x < length; x++)
+        {
+            int offset = x - halfLength;
+
+            if(offset == 0)
+            {
+                taps[x] = 0.5f; //No window here - window coefficient should be 1.0 anyway
+            }
+            else if((x % 2) == 0)
+            {
+                //Only calculate the even-index taps, leaving odd-index taps at default value of zero
+                taps[x] = (float)((Math.sin(offset * Math.PI / 2) / (offset * Math.PI)) * window[x]);
+            }
+        }
+
+        return taps;
+    }
+
+    /**
+     * Creates the optimal FIR filter implementation using calibration data to select
+     * from among the scalar and vector implementations.
+     * @param coefficients for the filter
+     * @return fir filter implementation
+     */
+    public static IRealFilter getRealFilter(float[] coefficients)
+    {
+        Implementation implementation = CalibrationManager.getInstance().getImplementation(CalibrationType.FILTER_FIR);
+
+        switch(implementation)
+        {
+            case VECTOR_SIMD_PREFERRED:
+                return new VectorRealFIRFilterDefaultBit(coefficients);
+            case VECTOR_SIMD_64:
+                return new VectorRealFIRFilter64Bit(coefficients);
+            case VECTOR_SIMD_128:
+                return new VectorRealFIRFilter128Bit(coefficients);
+            case VECTOR_SIMD_256:
+                return new VectorRealFIRFilter256Bit(coefficients);
+            case VECTOR_SIMD_512:
+                return new VectorRealFIRFilter512Bit(coefficients);
+            case UNCALIBRATED:
+            case SCALAR:
+            default:
+                return new RealFIRFilter(coefficients);
+        }
+    }
+
+    /**
+     * Constructs the optimal decimation filter implementation for filter length and window type
+     * using calibration data to select among scalar and vector implementation options.
+     * @param length of decimation filter
+     * @param windowType for designing the filter
+     * @return filter implementation
+     */
+    public static IRealDecimationFilter getRealDecimationFilter(int length, WindowType windowType)
+    {
+        float[] coefficients = getHalfBand(length, windowType);
+
+        switch(length)
+        {
+            case 11:
+                switch(CalibrationManager.getInstance().getImplementation(CalibrationType.FILTER_HALF_BAND_REAL_11_TAP))
+                {
+                    case VECTOR_SIMD_64:
+                        return new VectorRealHalfBandDecimationFilter11Tap64Bit(coefficients);
+                    case VECTOR_SIMD_128:
+                        return new VectorRealHalfBandDecimationFilter11Tap128Bit(coefficients);
+                    case VECTOR_SIMD_256:
+                        return new VectorRealHalfBandDecimationFilter11Tap256Bit(coefficients);
+                    case VECTOR_SIMD_512:
+                        return new VectorRealHalfBandDecimationFilter11Tap512Bit(coefficients);
+                    case SCALAR:
+                    case UNCALIBRATED:
+                    default:
+                        return new RealHalfBandDecimationFilter(coefficients);
+                }
+            case 15:
+                switch(CalibrationManager.getInstance().getImplementation(CalibrationType.FILTER_HALF_BAND_REAL_15_TAP))
+                {
+                    case VECTOR_SIMD_64:
+                        return new VectorRealHalfBandDecimationFilter15Tap64Bit(coefficients);
+                    case VECTOR_SIMD_128:
+                        return new VectorRealHalfBandDecimationFilter15Tap128Bit(coefficients);
+                    case VECTOR_SIMD_256:
+                        return new VectorRealHalfBandDecimationFilter15Tap256Bit(coefficients);
+                    case VECTOR_SIMD_512:
+                        return new VectorRealHalfBandDecimationFilter15Tap512Bit(coefficients);
+                    case SCALAR:
+                    case UNCALIBRATED:
+                    default:
+                        return new RealHalfBandDecimationFilter(coefficients);
+                }
+            case 23:
+                switch(CalibrationManager.getInstance().getImplementation(CalibrationType.FILTER_HALF_BAND_REAL_23_TAP))
+                {
+                    case VECTOR_SIMD_64:
+                        return new VectorRealHalfBandDecimationFilter23Tap64Bit(coefficients);
+                    case VECTOR_SIMD_128:
+                        return new VectorRealHalfBandDecimationFilter23Tap128Bit(coefficients);
+                    case VECTOR_SIMD_256:
+                        return new VectorRealHalfBandDecimationFilter23Tap256Bit(coefficients);
+                    case VECTOR_SIMD_512:
+                        return new VectorRealHalfBandDecimationFilter23Tap512Bit(coefficients);
+                    case SCALAR:
+                    case UNCALIBRATED:
+                    default:
+                        return new RealHalfBandDecimationFilter(coefficients);
+                }
+            case 63:
+                switch(CalibrationManager.getInstance().getImplementation(CalibrationType.FILTER_HALF_BAND_REAL_63_TAP))
+                {
+                    case VECTOR_SIMD_64:
+                        return new VectorRealHalfBandDecimationFilter63Tap64Bit(coefficients);
+                    case VECTOR_SIMD_128:
+                        return new VectorRealHalfBandDecimationFilter63Tap128Bit(coefficients);
+                    case VECTOR_SIMD_256:
+                        return new VectorRealHalfBandDecimationFilter63Tap256Bit(coefficients);
+                    case VECTOR_SIMD_512:
+                        return new VectorRealHalfBandDecimationFilter63Tap512Bit(coefficients);
+                    case SCALAR:
+                    case UNCALIBRATED:
+                    default:
+                        return new RealHalfBandDecimationFilter(coefficients);
+                }
+            default:
+                switch(CalibrationManager.getInstance().getImplementation(CalibrationType.FILTER_HALF_BAND_REAL_DEFAULT))
+                {
+                    case VECTOR_SIMD_64:
+                        return new VectorRealHalfBandDecimationFilter64Bit(coefficients);
+                    case VECTOR_SIMD_128:
+                        return new VectorRealHalfBandDecimationFilter128Bit(coefficients);
+                    case VECTOR_SIMD_256:
+                        return new VectorRealHalfBandDecimationFilter256Bit(coefficients);
+                    case VECTOR_SIMD_512:
+                        return new VectorRealHalfBandDecimationFilter512Bit(coefficients);
+                    case SCALAR:
+                    case UNCALIBRATED:
+                    default:
+                        return new RealHalfBandDecimationFilter(coefficients);
+                }
+        }
+    }
+
     /**
      * Compares two doubles for equals and avoids any rounding error that are present.
      *
@@ -1015,17 +1208,17 @@ public class FilterFactory
 
     public static void main(String[] args)
     {
-        float[] taps = null;
+        DecimalFormat df = new DecimalFormat("0.000000");
 
-        try
+        int length = 15;
+
+        float [] taps = FilterFactory.getHalfBand(length, WindowType.HAMMING);
+
+        for(int x = 0; x < length; x++)
         {
-            taps = FilterFactory.getSincM2Channelizer(12500.0, 800, 9, true);
-        }
-        catch(FilterDesignException fde)
-        {
-            mLog.error("Error", fde);
+            mLog.debug("Tap: " + x + " Value: " + df.format(taps[x]));
         }
 
-        mLog.debug("Done: " + Arrays.toString(taps));
+        mLog.debug("Done!");
     }
 }

src/main/java/io/github/dsheirer/dsp/filter/FloatHalfBandFilter.java

@@ -1,204 +0,0 @@
-/*******************************************************************************
- *     SDR Trunk 
- *     Copyright (C) 2014 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;
-
-import io.github.dsheirer.sample.real.RealSampleListener;
-import org.apache.commons.lang3.Validate;
-
-import java.util.ArrayList;
-
-public class FloatHalfBandFilter implements RealSampleListener
-{
-	private RealSampleListener mListener;
-	private ArrayList<Float> mBuffer;
-    private int mBufferSize = 1; //Temporary initial value
-	private int mBufferPointer = 0;
-	private float mGain;
-	private float[] mCoefficients;
-	private int[][] mIndexMap;
-	private int mCenterCoefficient;
-	private int mCenterCoefficientMapIndex;
-	private boolean mDispatchFlag = false;
-	
-
-	/**
-	 * Half-Band filter with decimation by 2 against real valued floats.
-	 * 
-	 * Takes advantage of the symmetrical nature of FIR filter coefficients by
-	 * adding oldest and newest sample first, then multiplying once by the
-	 * corresponding coefficient
-	 * 
-	 * Also, takes advantage of the 0-valued FIR half-band coefficents inherent
-	 * in the half-band filter, and does not calculate those coefficients.
-	 * 
-	 * This reduces the workload to (tap-size - 1) / 4 + 1 calculations per sample.
-	 * 
-	 * @param filter - filter coefficients
-	 * @param gain - gain multiplier.  Use 1.0 for unity/no gain
-	 */
-	public FloatHalfBandFilter( Filters filter, float gain )
-	{
-		mCoefficients = filter.getCoefficients();
-		mBuffer = new ArrayList<Float>();
-		mBufferSize = mCoefficients.length;
-		
-		//Fill the buffer with zero valued samples
-		for( int x = 0; x < mCoefficients.length; x++ )
-		{
-			mBuffer.add( 0.0f );
-		}
-		
-		generateIndexMap( mCoefficients.length );
-		mGain = gain;
-	}
-	
-	public void dispose()
-	{
-		mListener = null;
-	}
-
-	/**
-	 * Calculate the filtered value by applying the coefficients against
-	 * the complex samples in mBuffer
-	 */
-	public void receive( float newSample )
-	{
-		//Add the new sample to the buffer
-		mBuffer.set( mBufferPointer, newSample );
-
-		//Increment & Adjust the buffer pointer for circular wrap around
-		mBufferPointer++;
-
-		if( mBufferPointer >= mBufferSize )
-		{
-			mBufferPointer = 0;
-		}
-
-		//Toggle the flag every time, so that we can calculate and dispatch a
-		//sample every other time, when the flag is true (ie decimate by 2)
-		mDispatchFlag = !mDispatchFlag;
-		
-		//Calculate a filtered sample when the flag is true
-		if( mDispatchFlag )
-		{
-			//Convolution - multiply filter coefficients by the circular buffer
-			//samples to calculate a new filtered value
-			float accumulator = 0;
-
-			//Start with the center tap value
-			accumulator += mCoefficients[ mCenterCoefficient ] * 
-					mBuffer.get( mIndexMap[ mBufferPointer ][ mCenterCoefficientMapIndex ] );
-			
-			//For the remaining coefficients, add the symmetric samples, oldest and newest
-			//first, then multiply by the single coefficient
-			for( int x = 0; x < mCenterCoefficientMapIndex; x += 2 )
-			{
-				accumulator += mCoefficients[ x ] *
-					( mBuffer.get( mIndexMap[ mBufferPointer ][ x ] ) + 
-					  mBuffer.get( mIndexMap[ mBufferPointer ][ x + 1 ] ) );
-			}
-
-			//We're almost finished ... apply gain, cast the floats to shorts and
-			//send it on it's merry way
-			if( mListener != null )
-			{
-				mListener.receive( (float)( accumulator * mGain ) );
-			}
-		}
-	}
-	
-	/**
-	 * Creates an n X (n + 1 / 2) index map enabling quick access to the
-	 * circular buffer samples.
-	 * 
-	 * As the buffer shifts right with each subsequent sample, we have to move
-	 * the index pointers with it, for efficient access of the samples.
-	 * 
-	 * The first array index value in the index map corresponds to the current
-	 * buffer pointer location.
-	 * 
-	 * The second array index value points to the samples that should be
-	 * multiplied by the coefficients as follows:
-	 *   
-	 * 0 = center tap sample, to be multiplied by center coefficient
-	 * 
-	 * 0 = sample( 1 )
-	 * 1 = sample( size - 1 )
-	 * 
-	 * Indexes 0 and 1 will be multiplied by coefficient( 0 ).
-	 * 
-	 * Subsequent indexes 3, 4, etc, point to the oldest and newest samples that 
-	 * correspond to the matching ( 3 ) coefficient index. 
-	 * 
-	 * @param odd-sized number of filter taps (ie coefficients) and buffer
-	 */
-	private void generateIndexMap( int size )
-	{
-		//Ensure we have an odd size
-		Validate.isTrue(size % 2 == 1);
-
-		int mapWidth = ( ( size + 1 ) / 2 ) + 1;
-		
-		//Set center tap index for coefficients array
-		mCenterCoefficient = ( size - 1 ) / 2;
-		mCenterCoefficientMapIndex = mCenterCoefficient + 1;
-
-		mIndexMap = new int[ size ][ mapWidth ];
-
-		//Setup the first row, buffer pointer index 0, as a starting point
-		for( int x = 0; x < mapWidth - 2; x += 2 )
-		{
-			mIndexMap[ 0 ][ x ] = x;
-			mIndexMap[ 0 ][ x + 1 ] = size - 1 - x;
-		}
-
-		//Place center tap index in last element
-		mIndexMap[ 0 ][ mCenterCoefficientMapIndex ] = mCenterCoefficient;
-		
-		//For each subsequent row, increment the previous row's value by 1, 
-		//subtracting size as needed, to keep the values between 0 and size - 1
-		for( int x = 1; x < size; x++ )
-		{
-			for( int y = 0; y < mapWidth; y++ )
-			{
-				mIndexMap[ x ][ y ] = mIndexMap[ x - 1 ][ y ] + 1;
-				
-				if( mIndexMap[ x ][ y ] >= size )
-				{
-					mIndexMap[ x ][ y ] -= size;
-				}
-			}
-		}
-	}
-
-	/**
-	 * Registers a listener for filtered samples
-	 */
-    public void setListener( RealSampleListener listener )
-    {
-		mListener = listener;
-    }
-
-	/**
-	 * Removes (if exists) a registered filtered sample listener
-	 */
-    public void clearListener()
-    {
-		mListener = null;
-    }
-}

src/main/java/io/github/dsheirer/dsp/filter/FloatHalfBandNoDecimateFilter.java

@@ -1,194 +0,0 @@
-/*******************************************************************************
- *     SDR Trunk 
- *     Copyright (C) 2014 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;
-
-import io.github.dsheirer.sample.real.RealSampleListener;
-import org.apache.commons.lang3.Validate;
-
-import java.util.ArrayList;
-
-public class FloatHalfBandNoDecimateFilter implements RealSampleListener
-{
-	private RealSampleListener mListener;
-	private ArrayList<Float> mBuffer;
-    private int mBufferSize = 1; //Temporary initial value
-	private int mBufferPointer = 0;
-	private float mGain;
-	private float[] mCoefficients;
-	private int[][] mIndexMap;
-	private int mCenterCoefficient;
-	private int mCenterCoefficientMapIndex;
-
-	/**
-	 * Half-Band filter with decimation by a real valued float.
-	 * 
-	 * Takes advantage of the symmetrical nature of FIR filter coefficients by
-	 * adding oldest and newest sample first, then multiplying once by the
-	 * corresponding coefficient
-	 * 
-	 * Also, takes advantage of the 0-valued FIR half-band coefficents inherent
-	 * in the half-band filter, and does not calculate those coefficients.
-	 * 
-	 * This reduces the workload to (tap-size - 1) / 4 + 1 calculations per sample.
-	 * 
-	 * @param filter - filter coefficients
-	 * @param gain - gain multiplier.  Use 1.0 for unity/no gain
-	 */
-	public FloatHalfBandNoDecimateFilter( Filters filter, float gain )
-	{
-		mCoefficients = filter.getCoefficients();
-		mBuffer = new ArrayList<Float>();
-		mBufferSize = mCoefficients.length;
-		
-		//Fill the buffer with zero valued samples
-		for( int x = 0; x < mCoefficients.length; x++ )
-		{
-			mBuffer.add( 0.0f );
-		}
-		
-		generateIndexMap( mCoefficients.length );
-		mGain = gain;
-	}
-	
-	public void dispose()
-	{
-		mListener = null;
-	}
-
-	/**
-	 * Calculate the filtered value by applying the coefficients against
-	 * the complex samples in mBuffer
-	 */
-	public void receive( float newSample )
-	{
-		//Add the new sample to the buffer
-		mBuffer.set( mBufferPointer, newSample );
-
-		//Increment & Adjust the buffer pointer for circular wrap around
-		mBufferPointer++;
-
-		if( mBufferPointer >= mBufferSize )
-		{
-			mBufferPointer = 0;
-		}
-
-		//Convolution - multiply filter coefficients by the circular buffer
-		//samples to calculate a new filtered value
-		float accumulator = 0;
-
-		//Start with the center tap value
-		accumulator += mCoefficients[ mCenterCoefficient ] * 
-				mBuffer.get( mIndexMap[ mBufferPointer ][ mCenterCoefficientMapIndex ] );
-		
-		//For the remaining coefficients, add the symmetric samples, oldest and newest
-		//first, then multiply by the single coefficient
-		for( int x = 0; x < mCenterCoefficientMapIndex; x += 2 )
-		{
-			accumulator += mCoefficients[ x ] *
-				( mBuffer.get( mIndexMap[ mBufferPointer ][ x ] ) + 
-				  mBuffer.get( mIndexMap[ mBufferPointer ][ x + 1 ] ) );
-		}
-
-		//We're almost finished ... apply gain, cast the floats to floats and
-		//send it on it's merry way
-		if( mListener != null )
-		{
-			mListener.receive( (float)( accumulator * mGain ) );
-		}
-	}
-	
-	/**
-	 * Creates an n X (n + 1 / 2) index map enabling quick access to the
-	 * circular buffer samples.
-	 * 
-	 * As the buffer shifts right with each subsequent sample, we have to move
-	 * the index pointers with it, for efficient access of the samples.
-	 * 
-	 * The first array index value in the index map corresponds to the current
-	 * buffer pointer location.
-	 * 
-	 * The second array index value points to the samples that should be
-	 * multiplied by the coefficients as follows:
-	 *   
-	 * 0 = center tap sample, to be multiplied by center coefficient
-	 * 
-	 * 0 = sample( 1 )
-	 * 1 = sample( size - 1 )
-	 * 
-	 * Indexes 0 and 1 will be multiplied by coefficient( 0 ).
-	 * 
-	 * Subsequent indexes 3, 4, etc, point to the oldest and newest samples that 
-	 * correspond to the matching ( 3 ) coefficient index. 
-	 * 
-	 * @param odd-sized number of filter taps (ie coefficients) and buffer
-	 */
-	private void generateIndexMap( int size )
-	{
-		//Ensure we have an odd size
-		Validate.isTrue(size % 2 == 1);
-
-		int mapWidth = ( ( size + 1 ) / 2 ) + 1;
-		
-		//Set center tap index for coefficients array
-		mCenterCoefficient = ( size - 1 ) / 2;
-		mCenterCoefficientMapIndex = mCenterCoefficient + 1;
-
-		mIndexMap = new int[ size ][ mapWidth ];
-
-		//Setup the first row, buffer pointer index 0, as a starting point
-		for( int x = 0; x < mapWidth - 2; x += 2 )
-		{
-			mIndexMap[ 0 ][ x ] = x;
-			mIndexMap[ 0 ][ x + 1 ] = size - 1 - x;
-		}
-
-		//Place center tap index in last element
-		mIndexMap[ 0 ][ mCenterCoefficientMapIndex ] = mCenterCoefficient;
-		
-		//For each subsequent row, increment the previous row's value by 1, 
-		//subtracting size as needed, to keep the values between 0 and size - 1
-		for( int x = 1; x < size; x++ )
-		{
-			for( int y = 0; y < mapWidth; y++ )
-			{
-				mIndexMap[ x ][ y ] = mIndexMap[ x - 1 ][ y ] + 1;
-				
-				if( mIndexMap[ x ][ y ] >= size )
-				{
-					mIndexMap[ x ][ y ] -= size;
-				}
-			}
-		}
-	}
-
-	/**
-	 * Registers a listener for filtered samples
-	 */
-    public void setListener( RealSampleListener listener )
-    {
-		mListener = listener;
-    }
-
-	/**
-	 * Removes (if exists) a registered filtered sample listener
-	 */
-    public void clearListener()
-    {
-		mListener = null;
-    }
-}

src/main/java/io/github/dsheirer/dsp/filter/GoertzelFilter.java

@@ -1,30 +1,30 @@
 /*******************************************************************************
  *     SDR Trunk 
  *     Copyright (C) 2014 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;
 
-import io.github.dsheirer.dsp.filter.Window.WindowType;
+import io.github.dsheirer.dsp.window.WindowFactory;
+import io.github.dsheirer.dsp.window.WindowType;
 import org.apache.commons.math3.util.FastMath;
 
-
 /**
  * Implements the Goertzel Filter as described in
  * http://en.wikipedia.org/wiki/Goertzel_algorithm
- * 
+ * <p>
  * Calculates the magnitude of a specific frequency component within a window of
  * samples, using a Goertzel Filter (ie an optimized DFT).
  */
@@ -33,34 +33,27 @@ public class GoertzelFilter
     private int mSampleRate;
     private long mTargetFrequency;
     private int mBlockSize;
-    private double[] mWindowCoefficients;
+    private float[] mWindowCoefficients;
 
     private double mCoefficient;
 
     /**
      * Constructs the Goertzel Filter to use for block processing of
      * time-domain signal samples.
-     * 
-     * @param sampleRate
-     *            - sample rate (Hz)
-     * @param targetFrequency
-     *            - target frequency (Hz)
-     * @param blockSize
-     *            - number of samples per block of processing
-     * @param window 
-     *            - window to apply against the samples prior to calculating
-     *            the magnitude
+     *
+     * @param sampleRate      - sample rate (Hz)
+     * @param targetFrequency - target frequency (Hz)
+     * @param blockSize       - number of samples per block of processing
+     * @param window          - window to apply against the samples prior to calculating
+     *                        the magnitude
      */
-    public GoertzelFilter( int sampleRate, 
-        	    		   long targetFrequency, 
-        	    		   int blockSize,
-        	    		   WindowType window )
+    public GoertzelFilter(int sampleRate, long targetFrequency, int blockSize, WindowType window)
     {
-    	mSampleRate = sampleRate;
-    	mTargetFrequency = targetFrequency;
-    	mBlockSize = blockSize;
-    	mWindowCoefficients = Window.getWindow( window, blockSize );
-    	init();
+        mSampleRate = sampleRate;
+        mTargetFrequency = targetFrequency;
+        mBlockSize = blockSize;
+        mWindowCoefficients = WindowFactory.getWindow(window, blockSize);
+        init();
     }
 
     /**
@@ -68,77 +61,74 @@ public class GoertzelFilter
      */
     private void init()
     {
-    	double normalizedFrequency = (double) mTargetFrequency / mSampleRate;
-    	mCoefficient = 2.0D * FastMath.cos( 2 * FastMath.PI * normalizedFrequency );
+        double normalizedFrequency = (double)mTargetFrequency / mSampleRate;
+        mCoefficient = 2.0D * FastMath.cos(2 * FastMath.PI * normalizedFrequency);
     }
 
-    
     /**
-     * Returns the power (dB) of the target frequency within the block of 
+     * Returns the power (dB) of the target frequency within the block of
      * samples as normalized against the bin(0) magnitude value
-     * 
-     * @param samples
-     *            - array of time-domain samples -- array size must be the same
-     *            size as the windowSize parameter passed upon construction
-     * 
+     *
+     * @param samples - array of time-domain samples -- array size must be the same
+     *                size as the windowSize parameter passed upon construction
      * @return - power measurement in dB
-
      * @throws IllegalArgumentException if the sample array size is not equal
-     * 		to the defined block size
+     *                                  to the defined block size
      */
-    public int getPower( float[] samples ) throws IllegalArgumentException
+    public int getPower(float[] samples) throws IllegalArgumentException
     {
-    	// Verify size of samples array against block size
-    	if ( samples.length != mBlockSize )
-    	{
-    	    throw new IllegalArgumentException(
-    		    "Sample array size does not equal Block Size" );
-    	}
-    
-    	// Apply the window against the samples
-    	samples = Window.apply( mWindowCoefficients, samples );
-    
-    	// Process the samples
-    	double s = 0.0D;
-    	double s_prev = 0.0D;
-    	double s_prev2 = 0.0D;
+        // Verify size of samples array against block size
+        if(samples.length != mBlockSize)
+        {
+            throw new IllegalArgumentException("Sample array size does not equal Block Size");
+        }
 
-        for (float sample : samples) {
+        // Apply the window against the samples
+        samples = WindowFactory.apply(mWindowCoefficients, samples);
+
+        // Process the samples
+        double s = 0.0D;
+        double s_prev = 0.0D;
+        double s_prev2 = 0.0D;
+
+        for(float sample : samples)
+        {
             s = sample + (mCoefficient * s_prev) - s_prev2;
             s_prev2 = s_prev;
             s_prev = s;
         }
-    
-    	//power = s_prev2 * s_prev2 + s_prev * s_prev - coeff * s_prev * s_prev2 ;
-    
-    	double magnitude = ( s_prev2 * s_prev2 ) + ( s_prev * s_prev) - (mCoefficient * s_prev * s_prev2);
-    	int binZero = getBinZeroPower( samples );
-    	
-    	int power = (int) (20 * FastMath.log10( magnitude / binZero ) );
-    	
-    	return power;
+
+        //power = s_prev2 * s_prev2 + s_prev * s_prev - coeff * s_prev * s_prev2 ;
+
+        double magnitude = (s_prev2 * s_prev2) + (s_prev * s_prev) - (mCoefficient * s_prev * s_prev2);
+        int binZero = getBinZeroPower(samples);
+
+        int power = (int)(20 * FastMath.log10(magnitude / binZero));
+
+        return power;
     }
 
     /**
      * Sums all of the sample values to derive the bin 0 power
      */
-    private int getBinZeroPower( float[] samples )
+    private int getBinZeroPower(float[] samples)
     {
         int retVal = 0;
 
-        for (float sample : samples) {
+        for(float sample : samples)
+        {
             retVal += sample;
         }
-        
+
         return retVal;
     }
-    
+
     /**
      * @return the Sample Rate
      */
     public int getSampleRate()
     {
-    	return mSampleRate;
+        return mSampleRate;
     }
 
     /**
@@ -146,7 +136,7 @@ public class GoertzelFilter
      */
     public long getTargetFrequency()
     {
-    	return mTargetFrequency;
+        return mTargetFrequency;
     }
 
     /**
@@ -154,7 +144,7 @@ public class GoertzelFilter
      */
     public int getBlockSize()
     {
-    	return mBlockSize;
+        return mBlockSize;
     }
 
 }

src/main/java/io/github/dsheirer/dsp/filter/Window.java

@@ -1,524 +0,0 @@
-/*******************************************************************************
- * sdr-trunk
- * Copyright (C) 2014-2018 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/>
- *
- ******************************************************************************/
-
-/*
- * Kaiser Window design methods: getKaiser(), getKaiserBeta() and getBesselZerothOrder() with minor naming changes were
- * adopted from:
- *
- * https://github.com/rjeschke/neetutils-base/blob/master/src/main/java/com/github/rjeschke/neetutils/audio/FIRUtils.java
- *
- * Copyright (C) 2012 René Jeschke <rene_jeschke@yahoo.de>
- *
- * 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
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * 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.
- */
-package io.github.dsheirer.dsp.filter;
-
-import org.apache.commons.math3.util.FastMath;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.Arrays;
-
-/**
- * Window factory and corresponding utility methods.
- */
-public class Window
-{
-    private final static Logger mLog = LoggerFactory.getLogger(Window.class);
-
-    private static final double TWO_PI = FastMath.PI * 2.0d;
-    private static final double FOUR_PI = FastMath.PI * 4.0d;
-    private static final double SIX_PI = FastMath.PI * 6.0d;
-    private static final double EIGHT_PI = FastMath.PI * 8.0d;
-
-    /**
-     * Creates a window of the specified type and length.
-     *
-     * @param type of window
-     * @param length of window
-     * @return window of the specified type and length
-     */
-    public static double[] getWindow(WindowType type, int length)
-    {
-        switch(type)
-        {
-            case BLACKMAN:
-                return getBlackman(length);
-            case BLACKMAN_HARRIS_4:
-                return getBlackmanHarris4(length);
-            case BLACKMAN_HARRIS_7:
-                return getBlackmanHarris7(length);
-            case BLACKMAN_NUTALL:
-                return getBlackmanNutall(length);
-            case COSINE:
-                return getCosine(length);
-            case FLAT_TOP:
-                return getFlatTop(length);
-            case HAMMING:
-                return getHamming(length);
-            case HANN:
-                return getHann(length);
-            case KAISER:
-                throw new IllegalArgumentException("Kaiser Window cannot be created via this method.  Use the getKaiser() method instead.");
-            case NUTALL:
-                return getNutall(length);
-            case NONE:
-            default:
-                return getRectangular(length);
-        }
-    }
-
-    /**
-     * Creates an all-pass or rectangular window.
-     *
-     * @param length of the window
-     * @return rectangular window
-     */
-    public static double[] getRectangular(int length)
-    {
-        double[] coefficients = new double[length];
-
-        Arrays.fill(coefficients, 1.0d);
-
-        return coefficients;
-    }
-
-    /**
-     * Creates a cosine window of the specified length.
-     *
-     * @param length of the window
-     * @return cosine window
-     */
-    public static double[] getCosine(int length)
-    {
-        double[] coefficients = new double[length];
-
-        if(length % 2 == 0) //Even length
-        {
-            int half = (int)((length - 1) / 2);
-
-            for(int x = -half; x < length / 2 + 1; x++)
-            {
-                coefficients[x + half] = FastMath.cos(
-                    ((double)x * FastMath.PI) / ((double)length + 1.0d));
-            }
-        }
-        else //Odd length
-        {
-            int half = (int)length / 2;
-
-            for(int x = -half; x < half + 1; x++)
-            {
-                coefficients[x + half] = FastMath.cos(
-                    ((double)x * FastMath.PI) / ((double)length + 1.0d));
-            }
-        }
-
-        return coefficients;
-    }
-
-    /**
-     * Creates a 3-term Blackman window.
-     *
-     * @param length of the window
-     * @return Blackman window
-     */
-    public static double[] getBlackman(int length)
-    {
-        double[] coefficients = new double[length];
-
-        double denominator = length - 1;
-
-        double a0 = 0.426590713672;
-        double a1 = 0.496560619089;
-        double a2 = 0.0768486672399;
-
-        for(int x = 0; x < length; x++)
-        {
-            coefficients[x] = a0 -
-                (a1 * FastMath.cos((TWO_PI * (double)x) / denominator)) +
-                (a2 * FastMath.cos((FOUR_PI * (double)x) / denominator));
-        }
-
-        return coefficients;
-    }
-
-    /**
-     * Creates a 4-term Nutall window
-     *
-     * @param length of the window
-     * @return Nutall window
-     */
-    public static double[] getNutall(int length)
-    {
-        double[] coefficients = new double[length];
-
-        double denominator = length - 1;
-        double a0 = 0.355768;
-        double a1 = 0.487396;
-        double a2 = 0.144232;
-        double a3 = 0.012604;
-
-        for(int x = 0; x < length; x++)
-        {
-            coefficients[x] = a0 -
-                (a1 * FastMath.cos(TWO_PI * (double)x / denominator)) +
-                (a2 * FastMath.cos(FOUR_PI * (double)x / denominator)) -
-                (a3 * FastMath.cos(SIX_PI * (double)x / denominator));
-        }
-
-        return coefficients;
-    }
-
-    /**
-     * Creates a 4-term Blackman-Nutall window
-     *
-     * @param length of the window
-     * @return Blackman-Nutall window
-     */
-    public static double[] getBlackmanNutall(int length)
-    {
-        double[] coefficients = new double[length];
-
-        double denominator = length - 1;
-        double a0 = 0.3635819;
-        double a1 = 0.4891775;
-        double a2 = 0.1365995;
-        double a3 = 0.0106411;
-
-        for(int x = 0; x < length; x++)
-        {
-            coefficients[x] = a0 -
-                (a1 * FastMath.cos(TWO_PI * (double)x / denominator)) +
-                (a2 * FastMath.cos(FOUR_PI * (double)x / denominator)) -
-                (a3 * FastMath.cos(SIX_PI * (double)x / denominator));
-        }
-
-        return coefficients;
-    }
-
-    /**
-     * Creates a 4-term Blackman-Harris window
-     *
-     * @param length of the window
-     * @return Blackman-Harris window
-     */
-    public static double[] getBlackmanHarris4(int length)
-    {
-        double[] coefficients = new double[length];
-
-        double denominator = length - 1;
-        double a0 = 0.35875;
-        double a1 = 0.48829;
-        double a2 = 0.14128;
-        double a3 = 0.01168;
-
-        for(int x = 0; x < length; x++)
-        {
-            coefficients[x] = a0 -
-                (a1 * FastMath.cos(TWO_PI * (double)x / denominator)) +
-                (a2 * FastMath.cos(FOUR_PI * (double)x / denominator)) -
-                (a3 * FastMath.cos(SIX_PI * (double)x / denominator));
-        }
-
-        return coefficients;
-    }
-
-    /**
-     * Creates a 7-term Blackman-Harris window
-     *
-     * @param length of the window
-     * @return Blackman-Harris window
-     */
-    public static double[] getBlackmanHarris7(int length)
-    {
-        double[] coefficients = new double[length];
-
-        double denominator = length - 1;
-
-        double a0 = 0.27105140069342;
-        double a1 = 0.43329793923448;
-        double a2 = 0.21812299954311;
-        double a3 = 0.06592544638803;
-        double a4 = 0.01081174209837;
-        double a5 = 0.00077658482522;
-        double a6 = 0.00001388721735;
-
-
-        for(int x = 0; x < length; x++)
-        {
-            double w = TWO_PI * (double)x / denominator;
-
-            coefficients[x] = a0 -
-                (a1 * FastMath.cos(w)) +
-                (a2 * FastMath.cos(2.0 * w)) -
-                (a3 * FastMath.cos(3.0 * w)) +
-                (a4 * FastMath.cos(4.0 * w)) -
-                (a5 * FastMath.cos(5.0 * w)) +
-                (a6 * FastMath.cos(6.0 * w));
-        }
-
-        return coefficients;
-    }
-
-    /**
-     * Creates a Hamming window
-     *
-     * @param length of the window
-     * @return Hamming window
-     */
-    public static double[] getHamming(int length)
-    {
-        double[] coefficients = new double[length];
-
-        double a0 = 0.54;
-        double a1 = 0.46;
-        double denominator = length;
-
-        for(int x = 0; x < length; x++)
-        {
-            coefficients[x] = a0 - (a1 * FastMath.cos(TWO_PI * (double)x / denominator));
-        }
-
-        return coefficients;
-    }
-
-    /**
-     * Creates a Hann window
-     *
-     * @param length of the window
-     * @return Hann window
-     */
-    public static double[] getHann(int length)
-    {
-        double[] coefficients = new double[length];
-
-        double a0 = 0.5;
-        double a1 = 0.5;
-        double denominator = length;
-
-        for(int x = 0; x < length; x++)
-        {
-            coefficients[x] = a0 - (a1 * FastMath.cos(TWO_PI * (double)x / denominator));
-        }
-
-        return coefficients;
-    }
-
-    /**
-     * Creates a 4-term Blackman-Harris window
-     *
-     * @param length of the window
-     * @return Blackman-Harris window
-     */
-    public static double[] getFlatTop(int length)
-    {
-        double[] coefficients = new double[length];
-
-        double denominator = length - 1;
-
-        double a0 = 0.215578948;
-        double a1 = 0.41663158;
-        double a2 = 0.277263158;
-        double a3 = 0.083578947;
-        double a4 = 0.006947368;
-
-        for(int x = 0; x < length; x++)
-        {
-            coefficients[x] = a0 -
-                (a1 * FastMath.cos(TWO_PI * (double)x / denominator)) +
-                (a2 * FastMath.cos(FOUR_PI * (double)x / denominator)) -
-                (a3 * FastMath.cos(SIX_PI * (double)x / denominator)) +
-                (a4 * FastMath.cos(EIGHT_PI * (double)x / denominator));
-        }
-
-        return coefficients;
-    }
-
-    /**
-     * Calculates the beta (roll-off factor) for a Kaiser window based on the specified attenuation.
-     *
-     * @param attenuation in decibels
-     * @return beta value in the range of 0.0 to 1.0
-     */
-    public static double getKaiserBeta(double attenuation)
-    {
-        if(attenuation > 50.0)
-        {
-            return 0.1102 * (attenuation - 8.7);
-        }
-        else if(attenuation >= 21.0)
-        {
-            return (0.5842 * FastMath.pow(attenuation - 21.0, 0.4)) + (0.07886 * (attenuation - 21.0));
-        }
-        else
-        {
-            return 0.0;
-        }
-    }
-
-    /**
-     * Creates a Kaiser window.
-     *
-     * @param length of the window
-     * @param attenuation desired
-     * @return window
-     */
-    public static double[] getKaiser(int length, double attenuation)
-    {
-        double[] coefficients = new double[length];
-
-        double beta = getKaiserBeta(attenuation);
-
-        double betaBesselZerothOrder = getBesselZerothOrder(beta);
-
-        double temp;
-
-        for(int x = 0; x < coefficients.length; x++)
-        {
-            temp = beta * FastMath.sqrt(1.0 - FastMath.pow(2.0 * x / (length - 1) - 1.0, 2));
-            coefficients[x] = getBesselZerothOrder(temp) / betaBesselZerothOrder;
-        }
-
-        return coefficients;
-    }
-
-
-    /**
-     * Zeroth order modified Bessel function.
-     *
-     * @param x Value.
-     * @return Return value.
-     */
-    public final static double getBesselZerothOrder(final double x)
-    {
-        double f = 1;
-        final double x2 = x * x * 0.25;
-        double xc = x2;
-        double v = 1 + x2;
-        for (int i = 2; i < 100; i++)
-        {
-            f *= i;
-            xc *= x2;
-            final double a = xc / (f * f);
-            v += a;
-            if (a < 1e-20) break;
-        }
-
-        return v;
-    }
-
-    /**
-     * Apply the window against an array of float-type samples
-     */
-    public static float[] apply(double[] coefficients, float[] samples)
-    {
-        for(int x = 0; x < coefficients.length; x++)
-        {
-            samples[x] = (float)(samples[x] * coefficients[x]);
-        }
-
-        return samples;
-    }
-
-    /**
-     * Apply the window type against the float array of samples
-     *
-     * @param type of window to use
-     * @param samples to be windowed
-     * @return windowed samples
-     */
-    public static float[] apply(WindowType type, float[] samples)
-    {
-        double[] coefficients = getWindow(type, samples.length);
-
-        return apply(coefficients, samples);
-    }
-
-    /**
-     * Apply the window against an array of double-type samples
-     */
-    public static double[] apply(double[] coefficients, double[] samples)
-    {
-        for(int x = 0; x < coefficients.length; x++)
-        {
-            samples[x] = samples[x] * coefficients[x];
-        }
-
-        return samples;
-    }
-
-    /**
-     * Apply the window type against the double array of samples
-     *
-     * @param type of window to use
-     * @param samples to be windowed
-     * @return windowed samples
-     */
-    public static double[] apply(WindowType type, double[] samples)
-    {
-        double[] coefficients = getWindow(type, samples.length);
-
-        return apply(coefficients, samples);
-    }
-
-    /**
-     * Window types
-     */
-    public enum WindowType
-    {
-        BLACKMAN("Blackman"),
-        BLACKMAN_HARRIS_4("Blackman-Harris 4"),
-        BLACKMAN_HARRIS_7("Blackman-Harris 7"),
-        BLACKMAN_NUTALL("Blackman-Nutall"),
-        COSINE("Cosine"),
-        FLAT_TOP("Flat Top"),
-        HAMMING("Hamming"),
-        HANN("Hann"),
-        KAISER("Kaiser"),
-        NUTALL("Nutall"),
-        NONE("None");
-
-        private String mLabel;
-
-        WindowType(String label)
-        {
-            mLabel = label;
-        }
-
-        public String toString()
-        {
-            return mLabel;
-        }
-    }
-
-    public static void main(String[] args)
-    {
-        double[] kaiser = getKaiser(16, 80.0);
-
-        mLog.debug("Window:" + Arrays.toString(kaiser));
-    }
-}

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

@@ -1,6 +1,6 @@
-/*******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2017 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,15 +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.dsp.filter.channelizer;
 
 import io.github.dsheirer.sample.Broadcaster;
 import io.github.dsheirer.sample.Listener;
-import io.github.dsheirer.sample.buffer.ReusableChannelResultsBuffer;
-import io.github.dsheirer.sample.buffer.ReusableChannelResultsBufferQueue;
-import io.github.dsheirer.sample.buffer.ReusableComplexBuffer;
+import io.github.dsheirer.sample.complex.InterleavedComplexSamples;
 import io.github.dsheirer.source.ISourceEventListener;
 import io.github.dsheirer.source.SourceEvent;
 import org.slf4j.Logger;
@@ -31,10 +29,9 @@ import org.slf4j.LoggerFactory;
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
 
-public abstract class AbstractComplexPolyphaseChannelizer implements Listener<ReusableComplexBuffer>, ISourceEventListener
+public abstract class AbstractComplexPolyphaseChannelizer implements Listener<InterleavedComplexSamples>, ISourceEventListener
 {
     private final static Logger mLog = LoggerFactory.getLogger(AbstractComplexPolyphaseChannelizer.class);
-    private ReusableChannelResultsBufferQueue mBufferQueue = new ReusableChannelResultsBufferQueue("AbstractComplexPolyphaseChannelizer");
     private Broadcaster<SourceEvent> mSourceChangeBroadcaster = new Broadcaster();
     private List<PolyphaseChannelSource> mChannels = new CopyOnWriteArrayList<>();
     private double mSampleRate;
@@ -103,17 +100,14 @@ public abstract class AbstractComplexPolyphaseChannelizer implements Listener<Re
     /**
      * Dispatches the processed channel samples to any registered polyphase channel outputs.
      *
-     * @param channelResultsBuffer containing an array of an array of I/Q samples per channel
+     * @param channelResultsList a list of arrays of I/Q samples per channel
      */
-    protected void dispatch(ReusableChannelResultsBuffer channelResultsBuffer)
+    protected void dispatch(List<float[]> channelResultsList)
     {
         for(PolyphaseChannelSource channel : mChannels)
         {
-            channelResultsBuffer.incrementUserCount();
-            channel.receiveChannelResults(channelResultsBuffer);
+            channel.receiveChannelResults(channelResultsList);
         }
-
-        channelResultsBuffer.decrementUserCount();
     }
 
     /**
@@ -152,16 +146,6 @@ public abstract class AbstractComplexPolyphaseChannelizer implements Listener<Re
         return mChannels.size();
     }
 
-    /**
-     * Creates or reuses a channel results buffer for subclass implementations to use for temporary
-     * storage of channel results through distribution and consumption of channel results by
-     * channel output processors.
-     */
-    protected ReusableChannelResultsBuffer getChannelResultsBuffer()
-    {
-        return mBufferQueue.getBuffer();
-    }
-
     @Override
     public Listener<SourceEvent> getSourceEventListener()
     {

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

@@ -1,6 +1,6 @@
-/*******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2017 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,24 +14,22 @@
  *
  * 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 io.github.dsheirer.sample.IOverflowListener;
-import io.github.dsheirer.sample.Listener;
-import io.github.dsheirer.sample.buffer.ReusableChannelResultsBuffer;
-import io.github.dsheirer.sample.buffer.ReusableComplexBuffer;
+import io.github.dsheirer.sample.complex.InterleavedComplexSamples;
+import io.github.dsheirer.util.Dispatcher;
 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.Arrays;
-import java.util.Collection;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -67,8 +65,13 @@ public class ComplexPolyphaseChannelizerM2 extends AbstractComplexPolyphaseChann
     private static final DecimalFormat DECIMAL_FORMAT = new DecimalFormat("0.0");
     private static final int DEFAULT_MINIMUM_CHANNEL_BANDWIDTH = 25000;
 
-    //Sized at 152 buffers a second where max = 5 seconds and reset = 2 seconds worth of buffers
-    private IFFTProcessor mIFFTProcessor = new IFFTProcessor((5 * 152), (2 * 152));
+    /**
+     * Determines how many processed channel results to dispatch for threaded IFFT processing per batch
+     */
+    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);
     private FloatFFT_1D mFFT;
     private float[] mInlineSamples;
     private float[] mInlineFilter;
@@ -78,6 +81,7 @@ public class ComplexPolyphaseChannelizerM2 extends AbstractComplexPolyphaseChann
     private int mSampleBufferPointer;
     private int mSamplesPerBlock;
     private int mTapsPerChannel;
+    private List<float[]> mProcessedChannelResultsList = new ArrayList<>();
 
     /**
      * Creates a NMDPFB channelizer instance.
@@ -128,7 +132,7 @@ public class ComplexPolyphaseChannelizerM2 extends AbstractComplexPolyphaseChann
      */
     public void start()
     {
-        mIFFTProcessor.start();
+        mIFFTProcessorDispatcher.start();
     }
 
     /**
@@ -136,7 +140,7 @@ public class ComplexPolyphaseChannelizerM2 extends AbstractComplexPolyphaseChann
      */
     public void stop()
     {
-        mIFFTProcessor.stop();
+        mIFFTProcessorDispatcher.stop();
     }
 
     /**
@@ -187,12 +191,10 @@ public class ComplexPolyphaseChannelizerM2 extends AbstractComplexPolyphaseChann
      * Receives the complex sample buffer and processes the results through the channelizer.
      */
     @Override
-    public void receive(ReusableComplexBuffer reusableComplexBuffer)
+    public void receive(InterleavedComplexSamples complexSamples)
     {
-        ReusableChannelResultsBuffer channelResultsBuffer = getChannelResultsBuffer();
-        channelResultsBuffer.setTimestamp(reusableComplexBuffer.getTimestamp());
-
-        float[] samples = reusableComplexBuffer.getSamples();
+//TODO: how do we pass the timestamp onto the sample assemblers?
+        float[] samples = complexSamples.samples();
 
         int samplesPointer = 0;
         int samplesToCopy;
@@ -218,20 +220,19 @@ public class ComplexPolyphaseChannelizerM2 extends AbstractComplexPolyphaseChann
             if(mSampleBufferPointer >= mSamplesPerBlock)
             {
                 //Filter buffered samples and produce a single sample across each of the polyphase channels
-                process(channelResultsBuffer);
+                mProcessedChannelResultsList.add(process());
+
+                if(mProcessedChannelResultsList.size() >= PROCESSED_CHANNEL_RESULTS_THRESHOLD)
+                {
+                    mIFFTProcessorDispatcher.receive(new ArrayList<>(mProcessedChannelResultsList));
+                    mProcessedChannelResultsList.clear();
+                }
 
                 //Right-shift the samples in the buffer over to make room for a new block of samples
-                //Note: since JDK 8, hotspot JIT compiler uses native processor intrinsics for efficiency
                 System.arraycopy(mInlineSamples, 0, mInlineSamples, mSamplesPerBlock, (mInlineSamples.length - mSamplesPerBlock));
                 mSampleBufferPointer = 0;
             }
         }
-
-        //Enqueue the channel results buffer for IFFT processing and distribution on a different thread
-        mIFFTProcessor.receive(channelResultsBuffer);
-
-        //Decrement the user count to let the originator know we're done with their buffer
-        reusableComplexBuffer.decrementUserCount();
     }
 
     /**
@@ -334,7 +335,7 @@ public class ComplexPolyphaseChannelizerM2 extends AbstractComplexPolyphaseChann
      * Processes the sample buffer for each new block of sample data that is loaded and distributes the results to any
      * registered channel listeners.
      */
-    private void process(ReusableChannelResultsBuffer channelResultsBuffer)
+    private float[] process()
     {
         int bufferLength = getSubChannelCount() * mTapsPerChannel;
         float[] inlineInterimOutput = new float[bufferLength];
@@ -360,7 +361,7 @@ public class ComplexPolyphaseChannelizerM2 extends AbstractComplexPolyphaseChann
             }
         }
 
-        float[] processed = channelResultsBuffer.getEmptyBuffer(getSubChannelCount());
+        float[] processed = new float[getSubChannelCount()];
 
         if(mTopBlockIndicator)
         {
@@ -377,9 +378,9 @@ public class ComplexPolyphaseChannelizerM2 extends AbstractComplexPolyphaseChann
             }
         }
 
-        channelResultsBuffer.addChannelResults(processed);
-
         mTopBlockIndicator = !mTopBlockIndicator;
+
+        return processed;
     }
 
     /**
@@ -389,10 +390,10 @@ public class ComplexPolyphaseChannelizerM2 extends AbstractComplexPolyphaseChann
      */
     private void init(float[] coefficients)
     {
-        mFFT = new FloatFFT_1D(getChannelCount());
         int channelCount = getChannelCount();
+        mFFT = new FloatFFT_1D(channelCount);
         int bufferLength = getSubChannelCount() * mTapsPerChannel;
-        mSamplesPerBlock = getChannelCount(); //Same as subChannelCount / 2
+        mSamplesPerBlock = channelCount; //Same as subChannelCount / 2
         mTopBlockMap = getTopBlockMap(channelCount);
         mMiddleBlockMap = getMiddleBlockMap(channelCount);
         mInlineFilter = getAlignedFilter(coefficients, channelCount, mTapsPerChannel);
@@ -404,46 +405,28 @@ public class ComplexPolyphaseChannelizerM2 extends AbstractComplexPolyphaseChann
      * as required to align the phase of each polyphase channel, and then dispatch the results to any registered
      * sample consumer channels.
      */
-    public class IFFTProcessor extends ContinuousBufferProcessor<ReusableChannelResultsBuffer>
+    public class IFFTProcessorDispatcher extends Dispatcher<List<float[]>>
     {
-        public IFFTProcessor(int maximumSize, int resetThreshold)
+        public IFFTProcessorDispatcher(int maximumSize)
         {
-            super(maximumSize, resetThreshold);
+            super(maximumSize, "sdrtrunk polyphase ifft processor", Collections.emptyList());
 
-            //We create a listener interface to receive the buffers from the scheduled thread pool
+            //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(buffers -> {
-                for(ReusableChannelResultsBuffer buffer: buffers)
+            setListener(list -> {
+                List<float[]> processedChannelResults = new ArrayList<>();
+
+                for(float[] channelResults: list)
                 {
-                    for(float[] channelResults: buffer.getChannelResults())
-                    {
-                        //Rotate each of the channels to the correct phase using the IFFT
-                        mFFT.complexInverse(channelResults, true);
-                    }
-
-                    dispatch(buffer);
+                    //Rotate each of the channels to the correct phase using the IFFT
+                    mFFT.complexInverse(channelResults, true);
+                    processedChannelResults.add(channelResults);
                 }
+
+                dispatch(processedChannelResults);
             });
-
-            setOverflowListener(overflow -> mLog.debug("IFFTProcessor overflow changed - overflow:" + overflow));
-        }
-
-        /**
-         * Clears any buffers from the dispatch/processing queue.  Overrides the parent method so that we can set
-         * the user count to 0 to allow the buffer to be reclaimed.
-         */
-        protected Collection<ReusableChannelResultsBuffer> clearQueue()
-        {
-            Collection<ReusableChannelResultsBuffer> buffersToDispose = super.clearQueue();
-
-            for(ReusableChannelResultsBuffer buffer: buffersToDispose)
-            {
-                buffer.clearUserCount();
-            }
-
-            return buffersToDispose;
         }
     }
 }

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

@@ -1,227 +0,0 @@
-/*******************************************************************************
- * sdr-trunk
- * Copyright (C) 2014-2017 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.sample.IOverflowListener;
-import io.github.dsheirer.sample.Listener;
-import io.github.dsheirer.sample.OverflowableTransferQueue;
-import io.github.dsheirer.util.ThreadPool;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-public class ContinuousBufferProcessor<E> implements Listener<E>
-{
-    private final static Logger mLog = LoggerFactory.getLogger(ContinuousBufferProcessor.class);
-
-    protected OverflowableTransferQueue<E> mQueue;
-    private Listener<List<E>> mListener;
-    private ScheduledFuture<?> mScheduledFuture;
-    private AtomicBoolean mRunning = new AtomicBoolean();
-    private long mProcessingPeriod = 5; //milliseconds
-
-    /**
-     * Scheduled Buffer Processor combines an internal overflowable buffer with a scheduled runnable processing task
-     * for periodically distributing internally queued elements to the registered listener.  This processor provides
-     * a convenient way to create a thread-safe buffer for receiving elements from one thread/runnable and then
-     * distributing those elements to a registered listener where distribution occurs on a separate scheduled thread
-     * pool runnable thread.  This allows the calling input thread to quickly return without incurring any subsequent
-     * processing workload.
-     *
-     * The internal queue is an overflowable queue implementation that allows a listener to be registered to receive
-     * notifications of overflow and reset state.  Queue sizing parameters are specified in the constructor.
-     *
-     * @param maximumSize of the internal queue (overflow happens when this is exceeded)
-     * @param resetThreshold of the internal queue (overflow reset happens once queue size falls below this threshold
-     */
-    public ContinuousBufferProcessor(int maximumSize, int resetThreshold)
-    {
-        this(new OverflowableTransferQueue<>(maximumSize, resetThreshold));
-    }
-
-    /**
-     * Listener to receive the queued buffers each time this processor runs.
-     */
-    protected Listener<List<E>> getListener()
-    {
-        return mListener;
-    }
-
-    /**
-     * Sets the processing periodicity or run interval for how often the buffer queue is processed.
-     *
-     * @param milliseconds (default = 5 milliseconds)
-     */
-    public void setProcessingPeriod(long milliseconds)
-    {
-        mProcessingPeriod = milliseconds;
-    }
-
-    /**
-     * Scheduled Buffer Processor combines an internal overflowable buffer with a scheduled runnable processing task
-     * for periodically distributing internally queued elements to the registered listener.  This processor provides
-     * a convenient way to create a thread-safe buffer for receiving elements from one thread/runnable and then
-     * distributing those elements to a registered listener where distribution occurs on a separate scheduled thread
-     * pool runnable thread.  This allows the calling input thread to quickly return without incurring any subsequent
-     * processing workload.
-     *
-     * The internal queue is an overflowable queue implementation that allows a listener to be registered to receive
-     * notifications of overflow and reset state.  Queue sizing parameters are specified in the constructor.
-     *
-     * @param queue implmentation of an overflowable transfer queue
-     */
-    public ContinuousBufferProcessor(OverflowableTransferQueue<E> queue)
-    {
-        mQueue = queue;
-    }
-
-    /**
-     * Sets the listener to receive notifications of buffer overflow and/or reset.  Note: this method can also be
-     * invoked with a null argument to clear the previously registered overflow listener.
-     *
-     * @param listener to receive overflow/reset notifications.
-     */
-    public void setOverflowListener(IOverflowListener listener)
-    {
-        mQueue.setOverflowListener(listener);
-    }
-
-    /**
-     * Sets or changes the listener to receive buffers from this processor.
-     * @param listener to receive buffers
-     */
-    public void setListener(Listener<List<E>> listener)
-    {
-        mListener = listener;
-    }
-
-    /**
-     * Primary input method for adding buffers to this processor.  Note: incoming buffers will be ignored if this
-     * processor is in a stopped state.  You must invoke start() to allow incoming buffers and initiate buffer
-     * processing.
-     *
-     * @param e to enqueue for distribution to a registered listener
-     */
-    @Override
-    public void receive(E e)
-    {
-        mQueue.offer(e);
-    }
-
-    /**
-     * Starts this buffer processor and allows queuing of incoming buffers.
-     */
-    public void start()
-    {
-        if(mRunning.compareAndSet(false, true))
-        {
-            mScheduledFuture = ThreadPool.SCHEDULED.scheduleAtFixedRate(new Processor(), 0, mProcessingPeriod, TimeUnit.MILLISECONDS);
-        }
-    }
-
-    /**
-     * Stops this buffer processor, stops queuing of incoming buffers and clears the internal buffer queue.
-     */
-    public void stop()
-    {
-        if(mRunning.compareAndSet(true, false))
-        {
-            if(mScheduledFuture != null)
-            {
-                mScheduledFuture.cancel(true);
-                mScheduledFuture = null;
-            }
-
-            clearQueue();
-        }
-    }
-
-    /**
-     * Stops this buffer processor,stops queuing of incoming buffers and flushes the internal buffer queue
-     * contents to the listener.
-     */
-    public void flushAndStop()
-    {
-        if(mRunning.compareAndSet(true, false))
-        {
-            if(mScheduledFuture != null)
-            {
-                mScheduledFuture.cancel(true);
-                mScheduledFuture = null;
-            }
-
-            process();
-        }
-    }
-
-    /**
-     * Distributes queued buffers to the listener
-     */
-    protected void process()
-    {
-        List<E> buffers = new ArrayList<>();
-
-        try
-        {
-            mQueue.drainTo(buffers);
-
-            if(mListener != null)
-            {
-                mListener.receive(buffers);
-            }
-        }
-        catch(Throwable throwable)
-        {
-            mLog.error("Error while dispatching buffers to listener", throwable);
-        }
-    }
-
-    /**
-     * Clears any buffers from the queue
-     */
-    protected Collection<E> clearQueue()
-    {
-        Collection<E> clearedElements = new ArrayList<>();
-        mQueue.drainTo(clearedElements);
-        return clearedElements;
-    }
-
-    /**
-     * Indicates if this processor is currently running
-     */
-    public boolean isRunning()
-    {
-        return mRunning.get();
-    }
-
-    /**
-     * Processor to service the buffer queue and distribute the buffers to the registered listener
-     */
-    class Processor implements Runnable
-    {
-        @Override
-        public void run()
-        {
-            process();
-        }
-    }
-}

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

@@ -1,88 +0,0 @@
-/*******************************************************************************
- * sdr-trunk
- * Copyright (C) 2014-2018 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.sample.buffer.AbstractReusableBuffer;
-import io.github.dsheirer.sample.buffer.OverflowableReusableBufferTransferQueue;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class ContinuousReusableBufferProcessor<T extends AbstractReusableBuffer> extends ContinuousBufferProcessor<T>
-{
-    private final static Logger mLog = LoggerFactory.getLogger(ContinuousReusableBufferProcessor.class);
-
-    /**
-     * Scheduled Reusable Buffer Processor combines an internal overflowable buffer with a scheduled runnable processing
-     * task for periodically distributing internally queued elements to the registered listener.  This processor
-     * provides a convenient way to create a thread-safe buffer for receiving elements from one thread/runnable and then
-     * distributing those elements to a registered listener where distribution occurs on a separate scheduled thread
-     * pool runnable thread.  This allows the calling input thread to quickly return without incurring any subsequent
-     * processing workload.
-     *
-     * The internal queue is an overflowable queue implementation that allows a listener to be registered to receive
-     * notifications of overflow and reset state.  Queue sizing parameters are specified in the constructor.
-     *
-     * @param maximumSize of the internal queue (overflow happens when this is exceeded)
-     * @param resetThreshold of the internal queue (overflow reset happens once queue size falls below this threshold
-     */
-    public ContinuousReusableBufferProcessor(int maximumSize, int resetThreshold)
-    {
-        super(new OverflowableReusableBufferTransferQueue<T>(maximumSize, resetThreshold));
-    }
-
-    /**
-     * Distributes queued buffers to the listener
-     */
-    @Override
-    protected void process()
-    {
-        List<T> buffers = new ArrayList<>();
-
-        mQueue.drainTo(buffers);
-
-        try
-        {
-            if(getListener() != null)
-            {
-                getListener().receive(buffers);
-            }
-
-            buffers.clear();
-        }
-        catch(Throwable throwable)
-        {
-            mLog.error("Error while dispatching buffers to listener.  Performing buffer user count cleanup", throwable);
-
-            if(!buffers.isEmpty())
-            {
-                for(T buffer: buffers)
-                {
-                    try
-                    {
-                        buffer.decrementUserCount();
-                    }
-                    catch(IllegalStateException ise)
-                    {
-                        mLog.error("Error while performing user count cleanup on reusable buffers.");
-                    }
-                }
-            }
-        }
-    }
-}

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

@@ -1,26 +1,26 @@
 /*
+ * *****************************************************************************
+ * Copyright (C) 2014-2022 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.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.dsp.filter.FilterFactory;
 import io.github.dsheirer.dsp.filter.channelizer.output.IPolyphaseChannelOutputProcessor;
 import io.github.dsheirer.dsp.filter.channelizer.output.OneChannelOutputProcessor;
@@ -28,21 +28,21 @@ import io.github.dsheirer.dsp.filter.channelizer.output.TwoChannelOutputProcesso
 import io.github.dsheirer.dsp.filter.design.FilterDesignException;
 import io.github.dsheirer.sample.Broadcaster;
 import io.github.dsheirer.sample.Listener;
-import io.github.dsheirer.sample.buffer.IReusableComplexBufferProvider;
-import io.github.dsheirer.sample.buffer.ReusableComplexBuffer;
+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.ChannelSpecification;
 import io.github.dsheirer.source.tuner.channel.TunerChannel;
 import io.github.dsheirer.source.tuner.channel.TunerChannelSource;
+import io.github.dsheirer.util.Dispatcher;
 import org.apache.commons.math3.util.FastMath;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Queue;
@@ -76,32 +76,31 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
     private static final int POLYPHASE_SYNTHESIZER_TAPS_PER_CHANNEL = 9;
 
     private Broadcaster<SourceEvent> mSourceEventBroadcaster = new Broadcaster<>();
-    private IReusableComplexBufferProvider mReusableBufferProvider;
+    private INativeBufferProvider mNativeBufferProvider;
     private List<PolyphaseChannelSource> mChannelSources = new CopyOnWriteArrayList<>();
     private ChannelCalculator mChannelCalculator;
     private ComplexPolyphaseChannelizerM2 mPolyphaseChannelizer;
     private ChannelSourceEventListener mChannelSourceEventListener = new ChannelSourceEventListener();
-    private BufferSourceEventMonitor mBufferSourceEventMonitor = new BufferSourceEventMonitor();
-    private ContinuousBufferProcessor<ReusableComplexBuffer> mBufferProcessor;
+    private NativeBufferReceiver mNativeBufferReceiver = new NativeBufferReceiver();
+    private Dispatcher mBufferDispatcher;
     private Map<Integer,float[]> mOutputProcessorFilters = new HashMap<>();
 
     /**
      * Creates a polyphase channel manager instance.
      *
-     * @param reusableComplexBufferProvider (ie tuner) that supports register/deregister for reusable baseband sample buffer
+     * @param nativeBufferProvider (ie tuner) that supports register/deregister for reusable baseband sample buffer
      * streams
      * @param frequency of the baseband complex buffer sample stream (ie center frequency)
      * @param sampleRate of the baseband complex buffer sample stream
      */
-    public PolyphaseChannelManager(IReusableComplexBufferProvider reusableComplexBufferProvider,
-                                   long frequency, double sampleRate)
+    public PolyphaseChannelManager(INativeBufferProvider nativeBufferProvider, long frequency, double sampleRate)
     {
-        if(reusableComplexBufferProvider == null)
+        if(nativeBufferProvider == null)
         {
             throw new IllegalArgumentException("Complex buffer provider argument cannot be null");
         }
 
-        mReusableBufferProvider = reusableComplexBufferProvider;
+        mNativeBufferProvider = nativeBufferProvider;
 
         int channelCount = (int)(sampleRate / MINIMUM_CHANNEL_BANDWIDTH);
 
@@ -112,9 +111,9 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
         }
 
         mChannelCalculator = new ChannelCalculator(sampleRate, channelCount, frequency, CHANNEL_OVERSAMPLING);
-
-        mBufferProcessor = new ContinuousBufferProcessor(200, 50);
-        mBufferProcessor.setListener(mBufferSourceEventMonitor);
+        mBufferDispatcher = new Dispatcher(500, "sdrtrunk polyphase buffer processor",
+                new NativeBufferPoisonPill());
+        mBufferDispatcher.setListener(mNativeBufferReceiver);
     }
 
     /**
@@ -161,7 +160,7 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
      * @param tunerChannel specifying center frequency and bandwidth.
      * @return source or null.
      */
-    public TunerChannelSource getChannel(TunerChannel tunerChannel, ChannelSpecification channelSpecification)
+    public TunerChannelSource getChannel(TunerChannel tunerChannel)
     {
         PolyphaseChannelSource channelSource = null;
 
@@ -176,7 +175,7 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
             try
             {
                 channelSource = new PolyphaseChannelSource(tunerChannel, outputProcessor, mChannelSourceEventListener,
-                    mChannelCalculator.getChannelSampleRate(), centerFrequency, channelSpecification);
+                    mChannelCalculator.getChannelSampleRate(), centerFrequency);
 
                 mChannelSources.add(channelSource);
             }
@@ -229,7 +228,7 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
      */
     private void startChannelSource(PolyphaseChannelSource channelSource)
     {
-        synchronized(mBufferProcessor)
+        synchronized(mBufferDispatcher)
         {
             //Note: the polyphase channel source has already been added to the mChannelSources in getChannel() method
 
@@ -241,9 +240,9 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
             //If this is the first channel, register to start the sample buffers flowing
             if(mPolyphaseChannelizer.getRegisteredChannelCount() == 1)
             {
-                mReusableBufferProvider.addBufferListener(mBufferProcessor);
+                mNativeBufferProvider.addBufferListener(mBufferDispatcher);
                 mPolyphaseChannelizer.start();
-                mBufferProcessor.start();
+                mBufferDispatcher.start();
             }
         }
     }
@@ -256,7 +255,7 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
      */
     private void stopChannelSource(PolyphaseChannelSource channelSource)
     {
-        synchronized(mBufferProcessor)
+        synchronized(mBufferDispatcher)
         {
             mChannelSources.remove(channelSource);
             mPolyphaseChannelizer.removeChannel(channelSource);
@@ -265,8 +264,8 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
             //If this is the last/only channel, deregister to stop the sample buffers
             if(mPolyphaseChannelizer.getRegisteredChannelCount() == 0)
             {
-                mReusableBufferProvider.removeBufferListener(mBufferProcessor);
-                mBufferProcessor.stop();
+                mNativeBufferProvider.removeBufferListener(mBufferDispatcher);
+                mBufferDispatcher.stop();
                 mPolyphaseChannelizer.stop();
             }
         }
@@ -298,7 +297,7 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
                 mChannelCalculator.setCenterFrequency(sourceEvent.getValue().longValue());
 
                 //Defer channelizer configuration changes to be handled on the buffer processor thread
-                mBufferSourceEventMonitor.receive(sourceEvent);
+                mNativeBufferReceiver.receive(sourceEvent);
                 break;
             case NOTIFICATION_SAMPLE_RATE_CHANGE:
                 //Update channel calculator immediately so that channels can be allocated
@@ -565,7 +564,7 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
      * 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.
      */
-    public class BufferSourceEventMonitor implements Listener<List<ReusableComplexBuffer>>
+    public class NativeBufferReceiver implements Listener<INativeBuffer>
     {
         private Queue<SourceEvent> mQueuedSourceEvents = new ConcurrentLinkedQueue<>();
 
@@ -579,7 +578,7 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
         }
 
         @Override
-        public void receive(List<ReusableComplexBuffer> reusableComplexBuffers)
+        public void receive(INativeBuffer nativeBuffer)
         {
             try
             {
@@ -599,26 +598,19 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
                     queuedSourceEvent = mQueuedSourceEvents.poll();
                 }
 
-                for(ReusableComplexBuffer reusableComplexBuffer: reusableComplexBuffers)
+                if(mPolyphaseChannelizer != null)
                 {
-                    if(mPolyphaseChannelizer != null)
+                    Iterator<InterleavedComplexSamples> iterator = nativeBuffer.iteratorInterleaved();
+
+                    while(iterator.hasNext())
                     {
-                        //User count management is handled by the channelizer
-                        mPolyphaseChannelizer.receive(reusableComplexBuffer);
-                    }
-                    else
-                    {
-                        reusableComplexBuffer.decrementUserCount();
+                        mPolyphaseChannelizer.receive(iterator.next());
                     }
                 }
             }
             catch(Throwable throwable)
             {
                 mLog.error("Error", throwable);
-                for(ReusableComplexBuffer buffer: reusableComplexBuffers)
-                {
-                    buffer.decrementUserCount();
-                }
             }
         }
     }

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

@@ -1,7 +1,6 @@
 /*
- * ******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2018 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,46 +14,38 @@
  *
  * 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.channelizer.output.IPolyphaseChannelOutputProcessor;
 import io.github.dsheirer.dsp.filter.design.FilterDesignException;
-import io.github.dsheirer.dsp.filter.fir.FIRFilterSpecification;
-import io.github.dsheirer.dsp.filter.fir.complex.ComplexFIRFilter2;
-import io.github.dsheirer.dsp.filter.fir.remez.RemezFIRFilterDesigner;
 import io.github.dsheirer.sample.Listener;
-import io.github.dsheirer.sample.buffer.ReusableChannelResultsBuffer;
-import io.github.dsheirer.sample.buffer.ReusableComplexBuffer;
-import io.github.dsheirer.sample.buffer.ReusableComplexBufferAssembler;
+import io.github.dsheirer.sample.complex.ComplexSamples;
 import io.github.dsheirer.source.SourceEvent;
-import io.github.dsheirer.source.tuner.channel.ChannelSpecification;
+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.HashMap;
-import java.util.Map;
+import java.util.List;
 
-public class PolyphaseChannelSource extends TunerChannelSource
+/**
+ * Polyphase Channelizer's Tuner Channel Source implementation.  Wraps a ChannelOutputProcessor instance and
+ * provides tuner channel source functionality.  Supports dynamic swapout of the underlying channel output processor
+ * as the upstream polyphase channelizer reconfigures during tuned center frequency changes.
+ */
+public class PolyphaseChannelSource extends TunerChannelSource implements Listener<ComplexSamples>
 {
-//    private final static Logger mLog = LoggerFactory.getLogger(PolyphaseChannelSource.class);
-
-    private ReusableComplexBufferAssembler mReusableComplexBufferAssembler;
     private IPolyphaseChannelOutputProcessor mPolyphaseChannelOutputProcessor;
     private IPolyphaseChannelOutputProcessor mReplacementPolyphaseChannelOutputProcessor;
+    private StreamProcessorWithHeartbeat<ComplexSamples> mStreamHeartbeatProcessor;
     private long mReplacementFrequency;
-    private ComplexFIRFilter2 mLowPassFilter;
-    private static Map<Integer,float[]> sLowPassFilters = new HashMap();
-
     private double mChannelSampleRate;
     private long mIndexCenterFrequency;
     private long mChannelFrequencyCorrection;
 
     /**
-     * Polyphase channelizer tuner channel source implementation.  Adapts the channel array output samples from the
-     * polyphase channelizer into a single channel, or a channel synthesized from two adjacent channels that is
-     * frequency translated and decimated to a single channel.
+     * 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
@@ -65,37 +56,56 @@ public class PolyphaseChannelSource extends TunerChannelSource
      */
     public PolyphaseChannelSource(TunerChannel tunerChannel, IPolyphaseChannelOutputProcessor outputProcessor,
                                   Listener<SourceEvent> producerSourceEventListener, double channelSampleRate,
-                                  long centerFrequency, ChannelSpecification channelSpecification)
-        throws FilterDesignException
+                                  long centerFrequency) throws FilterDesignException
     {
         super(producerSourceEventListener, tunerChannel);
         mPolyphaseChannelOutputProcessor = outputProcessor;
+        mPolyphaseChannelOutputProcessor.setListener(this);
         mChannelSampleRate = channelSampleRate;
-        mReusableComplexBufferAssembler = new ReusableComplexBufferAssembler(2500, mChannelSampleRate);
-
-        float[] filterCoefficients = getLowPassFilter(channelSampleRate, channelSpecification.getPassFrequency(),
-            channelSpecification.getStopFrequency());
-        mLowPassFilter = new ComplexFIRFilter2(filterCoefficients, 1.0f);
-
+        mStreamHeartbeatProcessor = new StreamProcessorWithHeartbeat<>(getHeartbeatManager(), HEARTBEAT_INTERVAL_MS);
         setFrequency(centerFrequency);
     }
 
+    @Override
+    public void start()
+    {
+        super.start();
+
+        mStreamHeartbeatProcessor.start();
+
+        if(mPolyphaseChannelOutputProcessor != null)
+        {
+            mPolyphaseChannelOutputProcessor.start();
+        }
+    }
+
+    @Override
+    public void stop()
+    {
+        super.stop();
+
+        if(mPolyphaseChannelOutputProcessor != null)
+        {
+            mPolyphaseChannelOutputProcessor.stop();
+        }
+
+        mStreamHeartbeatProcessor.stop();
+    }
+
     /**
      * Registers the listener to receive complex sample buffers from this channel source
      */
     @Override
-    public void setListener(final Listener<ReusableComplexBuffer> listener)
+    public void setListener(final Listener<ComplexSamples> listener)
     {
-        mReusableComplexBufferAssembler.setListener(listener);
-   }
+        mStreamHeartbeatProcessor.setListener(listener);
+        mPolyphaseChannelOutputProcessor.setListener(this);
+    }
 
-    /**
-     * Removes the listener from receiving complex sample buffers from this channel source
-     */
     @Override
-    public void removeListener(Listener<ReusableComplexBuffer> listener)
+    public void receive(ComplexSamples complexSamples)
     {
-        mReusableComplexBufferAssembler.setListener(null);
+        mStreamHeartbeatProcessor.receive(complexSamples);
     }
 
     /**
@@ -119,6 +129,7 @@ public class PolyphaseChannelSource extends TunerChannelSource
         if(mPolyphaseChannelOutputProcessor == null)
         {
             mPolyphaseChannelOutputProcessor = outputProcessor;
+            mPolyphaseChannelOutputProcessor.setListener(this);
         }
         //Otherwise, we have to swap out the processor on the sample processing thread
         else
@@ -138,17 +149,14 @@ public class PolyphaseChannelSource extends TunerChannelSource
         if(mReplacementPolyphaseChannelOutputProcessor != null)
         {
             IPolyphaseChannelOutputProcessor existingProcessor = mPolyphaseChannelOutputProcessor;
+            existingProcessor.stop();
+            existingProcessor.setListener(null);
 
             //Swap out the processor so that incoming samples can accumulate in the new channel output processor
             mPolyphaseChannelOutputProcessor = mReplacementPolyphaseChannelOutputProcessor;
             mReplacementPolyphaseChannelOutputProcessor = null;
-
-            //Remove the buffer overflow listener and clear any previous buffer overflow state
-            existingProcessor.setSourceOverflowListener(null);
-            broadcastOverflowState(false);
-
-            //Register to receive buffer overflow notifications so we can push them up through the source chain
-            mPolyphaseChannelOutputProcessor.setSourceOverflowListener(this);
+            mPolyphaseChannelOutputProcessor.setListener(this);
+            mPolyphaseChannelOutputProcessor.start();
 
             //Finally, setup the frequency offset for the output processor.
             mIndexCenterFrequency = mReplacementFrequency;
@@ -161,17 +169,16 @@ public class PolyphaseChannelSource extends TunerChannelSource
      * queued for processing to extract the target channel samples, process them for frequency correction and/or
      * channel aggregation, and dispatch the results to the downstream sample listener/consumer.
      *
-     * @param channelResultsBuffer containing an array of polyphase channelizer outputs.
+     * @param channelResultsList containing a list of polyphase channelizer output arrays.
      */
-    public void receiveChannelResults(ReusableChannelResultsBuffer channelResultsBuffer)
+    public void receiveChannelResults(List<float[]> channelResultsList)
     {
         if(mReplacementPolyphaseChannelOutputProcessor != null)
         {
             swapOutputProcessor();
         }
 
-        mReusableComplexBufferAssembler.updateTimestamp(channelResultsBuffer.getTimestamp());
-        mPolyphaseChannelOutputProcessor.receiveChannelResults(channelResultsBuffer);
+        mPolyphaseChannelOutputProcessor.receiveChannelResults(channelResultsList);
     }
 
     /**
@@ -198,13 +205,9 @@ public class PolyphaseChannelSource extends TunerChannelSource
     @Override
     public void dispose()
     {
-        if(mReusableComplexBufferAssembler != null)
-        {
-            mReusableComplexBufferAssembler.dispose();
-        }
-
         if(mPolyphaseChannelOutputProcessor != null)
         {
+            mPolyphaseChannelOutputProcessor.setListener(null);
             mPolyphaseChannelOutputProcessor.dispose();
         }
     }
@@ -223,6 +226,7 @@ public class PolyphaseChannelSource extends TunerChannelSource
      */
     protected void setChannelFrequencyCorrection(long value)
     {
+//TODO: push this frequency correction down to the output processor ...
         mChannelFrequencyCorrection = value;
         updateFrequencyOffset();
         broadcastConsumerSourceEvent(SourceEvent.frequencyCorrectionChange(mChannelFrequencyCorrection));
@@ -242,12 +246,6 @@ public class PolyphaseChannelSource extends TunerChannelSource
         setChannelFrequencyCorrection(0);
     }
 
-    @Override
-    protected void processSamples()
-    {
-        mPolyphaseChannelOutputProcessor.processChannelResults(mReusableComplexBufferAssembler);
-    }
-
     /**
      * Calculates the frequency offset required to mix the incoming signal to center the desired frequency
      * within the channel
@@ -273,43 +271,4 @@ public class PolyphaseChannelSource extends TunerChannelSource
         return "POLYPHASE [" + mPolyphaseChannelOutputProcessor.getInputChannelCount() + "] " +
             getTunerChannel().getFrequency();
     }
-
-    /**
-     * Creates a low-pass filter to use as the final cleanup filter for the decimated output stream
-     *
-     * @param sampleRate for the final output channel rate
-     * @param passFrequency for half of the desired channel rate
-     * @param stopFrequency for the attenuated band
-     * @return a newly designed filter or a previously designed (cached) filter
-     * @throws FilterDesignException
-     */
-    private float[] getLowPassFilter(double sampleRate, double passFrequency, double stopFrequency) throws FilterDesignException
-    {
-        //Use existing filter if we've already designed one
-        float[] filter = sLowPassFilters.get((int) sampleRate);
-        if(filter != null)
-        {
-            return filter;
-        }
-
-        FIRFilterSpecification specification = FIRFilterSpecification.lowPassBuilder()
-            .sampleRate(sampleRate)
-            .gridDensity(16)
-            .passBandCutoff(passFrequency)
-            .passBandAmplitude(1.0)
-            .passBandRipple(0.01)
-            .stopBandStart(stopFrequency)
-            .stopBandAmplitude(0.0)
-            .stopBandRipple(0.01)
-            .build();
-
-        RemezFIRFilterDesigner designer = new RemezFIRFilterDesigner(specification);
-
-        //This will throw an exception if the filter cannot be designed
-        float[] taps = designer.getImpulseResponse();
-
-        sLowPassFilters.put((int)sampleRate, taps);
-
-        return taps;
-    }
 }

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

@@ -1,22 +1,24 @@
-/*******************************************************************************
- * sdr-trunk
- * Copyright (C) 2014-2018 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  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.sample.buffer.ReusableComplexBuffer;
-import io.github.dsheirer.sample.buffer.ReusableComplexBufferQueue;
+import io.github.dsheirer.sample.complex.ComplexSamples;
 import org.apache.commons.math3.util.FastMath;
 import org.jtransforms.fft.FloatFFT_1D;
 import org.slf4j.Logger;
@@ -45,8 +47,6 @@ import org.slf4j.LoggerFactory;
 public class TwoChannelSynthesizerM2
 {
     private final static Logger mLog = LoggerFactory.getLogger(TwoChannelSynthesizerM2.class);
-
-    private ReusableComplexBufferQueue mReusableComplexBufferQueue = new ReusableComplexBufferQueue("Two Channel Synthesizer M2");
     private float[] mSerpentineDataBuffer;
     private float[] mIQInterleavedFilter;
     private float[] mFilterVectorProduct;
@@ -87,28 +87,30 @@ public class TwoChannelSynthesizerM2
      * @param channelBuffer2 input channel
      * @return synthesized channel results of the same length as both channel 1/2 input arrays.
      */
-    public ReusableComplexBuffer process(ReusableComplexBuffer channelBuffer1, ReusableComplexBuffer channelBuffer2)
+    public ComplexSamples process(ComplexSamples channelBuffer1, ComplexSamples channelBuffer2)
     {
-        if(channelBuffer1.getSamples().length != channelBuffer1.getSamples().length)
+        if(channelBuffer1.i().length != channelBuffer1.i().length)
         {
             throw new IllegalArgumentException("Channel 1 and 2 array length must be equal");
         }
 
-        float[] channel1 = channelBuffer1.getSamples();
-        float[] channel2 = channelBuffer2.getSamples();
+        float[] iCh1 = channelBuffer1.i();
+        float[] qCh1 = channelBuffer1.q();
+        float[] iCh2 = channelBuffer2.i();
+        float[] qCh2 = channelBuffer2.q();
 
-        ReusableComplexBuffer synthesizedComplexBuffer = mReusableComplexBufferQueue.getBuffer(channel1.length);
+        float[] i = new float[iCh1.length];
+        float[] q = new float[qCh1.length];
 
-        float[] output = synthesizedComplexBuffer.getSamples();
         float[] IFFTBuffer = new float[4];
 
-        for(int x = 0; x < channel1.length; x += 2)
+        for(int x = 0; x < iCh1.length; x++)
         {
             //Load samples from each channel into buffer for IFFT
-            IFFTBuffer[0] = channel1[x];     //i
-            IFFTBuffer[1] = channel1[x + 1]; //q
-            IFFTBuffer[2] = channel2[x];     //i
-            IFFTBuffer[3] = channel2[x + 1]; //q
+            IFFTBuffer[0] = iCh1[x];     //i
+            IFFTBuffer[1] = qCh1[x]; //q
+            IFFTBuffer[2] = iCh2[x];     //i
+            IFFTBuffer[3] = qCh2[x]; //q
 
             //Perform Inverse FFT (IFFT)
             mFFT.complexInverse(IFFTBuffer, true);
@@ -148,16 +150,13 @@ public class TwoChannelSynthesizerM2
                 mQAccumulator += mFilterVectorProduct[y + 1];
             }
 
-            output[x] = mIAccumulator;
-            output[x + 1] = mQAccumulator;
+            i[x] = mIAccumulator;
+            q[x] = mQAccumulator;
 
             mTopBlockFlag = !mTopBlockFlag;
         }
 
-        channelBuffer1.decrementUserCount();
-        channelBuffer2.decrementUserCount();
-
-        return synthesizedComplexBuffer;
+        return new ComplexSamples(i, q);
     }
 
     /**

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

@@ -1,6 +1,6 @@
-/*******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2017 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,35 +14,26 @@
  *
  * 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.output;
 
-import io.github.dsheirer.dsp.mixer.IOscillator;
-import io.github.dsheirer.dsp.mixer.Oscillator;
-import io.github.dsheirer.sample.IOverflowListener;
-import io.github.dsheirer.sample.buffer.OverflowableReusableBufferTransferQueue;
-import io.github.dsheirer.sample.buffer.ReusableChannelResultsBuffer;
-import io.github.dsheirer.sample.buffer.ReusableComplexBufferAssembler;
-import io.github.dsheirer.source.Source;
+import io.github.dsheirer.sample.Listener;
+import io.github.dsheirer.sample.complex.ComplexSamples;
+import io.github.dsheirer.util.Dispatcher;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 public abstract class ChannelOutputProcessor implements IPolyphaseChannelOutputProcessor
 {
     private final static Logger mLog = LoggerFactory.getLogger(ChannelOutputProcessor.class);
 
-    private OverflowableReusableBufferTransferQueue<ReusableChannelResultsBuffer> mChannelResultsQueue;
-    private List<ReusableChannelResultsBuffer> mChannelResultsToProcess = new ArrayList<>();
-    private int mMaxResultsToProcess;
-
+    private Dispatcher<List<float[]>> mChannelResultsDispatcher;
+    protected Listener<ComplexSamples> mComplexSamplesListener;
     private int mInputChannelCount;
-    private IOscillator mFrequencyCorrectionMixer;
-    private boolean mFrequencyCorrectionEnabled;
-    private double mGain = 1.0;
 
     /**
      * Base class for polyphase channelizer output channel processing.  Provides built-in frequency translation
@@ -52,21 +43,32 @@ public abstract class ChannelOutputProcessor implements IPolyphaseChannelOutputP
      * @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.
      */
-    public ChannelOutputProcessor(int inputChannelCount, double sampleRate, double gain)
+    public ChannelOutputProcessor(int inputChannelCount, double sampleRate)
     {
         mInputChannelCount = inputChannelCount;
-        mGain = gain;
-
-//TODO: swap this out and use the LowPhaseNoiseOscillator
-        mFrequencyCorrectionMixer = new Oscillator(0, sampleRate);
-        mMaxResultsToProcess = (int)(sampleRate / 10) * 2;  //process at 100 millis interval, twice the expected inflow rate
-
-        mChannelResultsQueue = new OverflowableReusableBufferTransferQueue<>((int)(sampleRate * 3), (int)(sampleRate * 0.5));
+        mChannelResultsDispatcher = new Dispatcher<>((int)sampleRate, "sdrtrunk polyphase channel", Collections.emptyList());
+        mChannelResultsDispatcher.setListener(floats -> process(floats));
     }
 
-    protected double getGain()
+    @Override
+    public void start()
     {
-        return mGain;
+        mChannelResultsDispatcher.start();
+    }
+
+    @Override
+    public void stop()
+    {
+        mChannelResultsDispatcher.stop();
+    }
+
+    /**
+     * Registers the listener to receive the assembled complex sample buffers from this processor.
+     */
+    @Override
+    public void setListener(Listener<ComplexSamples> listener)
+    {
+        mComplexSamplesListener = listener;
     }
 
     @Override
@@ -77,97 +79,23 @@ public abstract class ChannelOutputProcessor implements IPolyphaseChannelOutputP
 
     public void dispose()
     {
-        if(mChannelResultsQueue != null)
-        {
-            mChannelResultsQueue.dispose();
-        }
-    }
-
-    /**
-     * Sets the frequency offset to apply to the incoming samples to mix the desired signal to baseband.
-     * @param frequencyOffset in hertz
-     */
-    @Override
-    public void setFrequencyOffset(long frequencyOffset)
-    {
-        mFrequencyCorrectionMixer.setFrequency(frequencyOffset);
-        mFrequencyCorrectionEnabled = (frequencyOffset != 0);
-    }
-
-    /**
-     * Oscillator/mixer to use for frequency correction against incoming sample stream
-     */
-    protected IOscillator getFrequencyCorrectionMixer()
-    {
-        return mFrequencyCorrectionMixer;
     }
 
     @Override
-    public void receiveChannelResults(ReusableChannelResultsBuffer channelResults)
+    public void receiveChannelResults(List<float[]> channelResultsList)
     {
-        mChannelResultsQueue.offer(channelResults);
-    }
-
-    /**
-     * Processes all enqueued polyphase channelizer results until the internal queue is empty
-     * @param reusableComplexBufferAssembler to receive the processed channel results
-     */
-    @Override
-    public void processChannelResults(ReusableComplexBufferAssembler reusableComplexBufferAssembler)
-    {
-        try
-        {
-            int toProcess = mChannelResultsQueue.drainTo(mChannelResultsToProcess, mMaxResultsToProcess);
-
-            if(toProcess > 0)
-            {
-                process(mChannelResultsToProcess, reusableComplexBufferAssembler);
-            }
-        }
-        catch(Throwable throwable)
-        {
-            mLog.error("Error while processing polyphase channel samples", throwable);
-        }
-
-        mChannelResultsToProcess.clear();
+        mChannelResultsDispatcher.receive(channelResultsList);
     }
 
     /**
      * Sub-class implementation to process one polyphase channelizer result array.
      * @param channelResults to process
-     * @param reusableComplexBufferAssembler to receive the processed channelizer results
      */
-    public abstract void process(List<ReusableChannelResultsBuffer> channelResults,
-                                 ReusableComplexBufferAssembler reusableComplexBufferAssembler);
-
-
-    /**
-     * Sets the overflow listener to monitor the internal channelizer channel results queue overflow state
-     */
-    public void setSourceOverflowListener(Source source)
-    {
-        mChannelResultsQueue.setSourceOverflowListener(source);
-    }
-
-    /**
-     * Removes the overflow listener from monitoring the internal channelizer channel results queue overflow state
-     */
-    public void removeOverflowListener(IOverflowListener listener)
-    {
-        mChannelResultsQueue.setOverflowListener(null);
-    }
+    public abstract void process(List<float[]> channelResults);
 
     @Override
     public int getInputChannelCount()
     {
         return mInputChannelCount;
     }
-
-    /**
-     * Indicates if this channel has a frequency correction offset
-     */
-    public boolean hasFrequencyCorrection()
-    {
-        return mFrequencyCorrectionEnabled;
-    }
 }

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

@@ -1,6 +1,6 @@
-/*******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2017 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,30 +14,41 @@
  *
  * 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.output;
 
-import io.github.dsheirer.sample.buffer.ReusableChannelResultsBuffer;
-import io.github.dsheirer.sample.buffer.ReusableComplexBufferAssembler;
-import io.github.dsheirer.source.Source;
+import io.github.dsheirer.sample.Listener;
+import io.github.dsheirer.sample.complex.ComplexSamples;
 
 import java.util.List;
 
 public interface IPolyphaseChannelOutputProcessor
 {
     /**
-     * Receive and enqueue output results from the polyphase analysis channelizer
-     * @param channelResultsBuffer to enqueue
+     * Start processing channel results
      */
-    void receiveChannelResults(ReusableChannelResultsBuffer channelResultsBuffer);
+    void start();
 
     /**
-     * Process the channel output channel results queue and deliver the output to the listener
-     *
-     * @param reusableComplexBufferAssembler to receive the processed channel results
+     * Stop processing channel results.
      */
-    void processChannelResults(ReusableComplexBufferAssembler reusableComplexBufferAssembler);
+    void stop();
+    /**
+     * Receive and enqueue output results from the polyphase analysis channelizer
+     * @param channelResults to enqueue
+     */
+    void receiveChannelResults(List<float[]> channelResults);
+
+    /**
+     * 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
@@ -49,13 +60,12 @@ public interface IPolyphaseChannelOutputProcessor
 
     /**
      * Indicates the number of input channels processed by this output processor
-     * @return
      */
     int getInputChannelCount();
 
     /**
      * Updates the input polyphase channel index(es) used by this output processor
-     * @param indexes
+     * @param indexes for the channel
      */
     void setPolyphaseChannelIndices(List<Integer> indexes);
 
@@ -66,16 +76,9 @@ public interface IPolyphaseChannelOutputProcessor
 
     /**
      * Updates the synthesis filter taps for this output processor
-     * @param filter
+     * @param filter for the output processor
      */
     void setSynthesisFilter(float[] filter);
 
-    /**
-     * Sets the listener to receive buffer overflow notifications
-     * @param source to receive overflow notifications
-     */
-    void setSourceOverflowListener(Source source);
-
-
     void dispose();
 }

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

@@ -0,0 +1,71 @@
+/*
+ * *****************************************************************************
+ * 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.output;
+
+import io.github.dsheirer.dsp.gain.complex.ComplexGain;
+import io.github.dsheirer.dsp.gain.complex.ComplexGainFactory;
+import io.github.dsheirer.dsp.mixer.ComplexMixer;
+import io.github.dsheirer.dsp.mixer.ComplexMixerFactory;
+import io.github.dsheirer.sample.complex.ComplexSamples;
+
+/**
+ * Sample assembler for a channel output processor that incorporates a mixer to perform final frequency
+ * translation on an extracted channel.
+ */
+public abstract class MixerAssembler
+{
+    protected static final int BUFFER_SIZE = 2048;
+
+    private ComplexMixer mMixer = ComplexMixerFactory.getMixer(0, 0);
+    private ComplexGain mGain;
+
+    /**
+     * Constructs an instance.
+     * @param gain to apply to fully assembled buffers.
+     */
+    protected MixerAssembler(float gain)
+    {
+        mGain = ComplexGainFactory.getComplexGain(gain);
+    }
+
+    /**
+     * Complex samples mixer for this assembler
+     */
+    protected ComplexMixer getMixer()
+    {
+        return mMixer;
+    }
+
+    protected ComplexGain getGain()
+    {
+        return mGain;
+    }
+
+    /**
+     * Indicates if this assembler has a buffer ready to dispatch to consumers.
+     */
+    public abstract boolean hasBuffer();
+
+    /**
+     * Access the fully assembled buffer when hasBuffer() indicates that a buffer is ready.
+     * @return true if a full buffer is assembled and ready.
+     */
+    public abstract ComplexSamples getBuffer();
+}

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

@@ -0,0 +1,77 @@
+/*
+ * *****************************************************************************
+ * 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.output;
+
+import io.github.dsheirer.sample.complex.ComplexSamples;
+
+/**
+ * Sample assembler to extract a single channel from the channel results array of a polyphase channel results array.
+ */
+public class OneChannelMixerAssembler extends MixerAssembler
+{
+    private SampleAssembler mSampleAssembler = new SampleAssembler(BUFFER_SIZE);
+
+    /**
+     * Constructs an instance
+     * @param gain to apply to fully assembled buffers.
+     */
+    public OneChannelMixerAssembler(float gain)
+    {
+        super(gain);
+    }
+
+    /**
+     * Receive a complex I & Q sample pair.
+     * @param i inphase
+     * @param q quadrature
+     */
+    public void receive(float i, float q)
+    {
+        mSampleAssembler.receive(i, q);
+    }
+
+    /**
+     * Indicates if there is a fully assembled buffer ready.
+     */
+    @Override
+    public boolean hasBuffer()
+    {
+        return mSampleAssembler.hasBuffer();
+    }
+
+    /**
+     * Access the assembled buffer.  Frequency offset and gain are applied to the returned buffer.
+     * @return assembled buffer.
+     */
+    @Override
+    public ComplexSamples getBuffer()
+    {
+        ComplexSamples buffer = mSampleAssembler.getBufferAndReset();
+
+        if(getMixer().hasFrequency())
+        {
+            buffer = getMixer().mix(buffer);
+        }
+
+        buffer = getGain().apply(buffer);
+
+        return buffer;
+    }
+}

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

@@ -1,6 +1,6 @@
-/*******************************************************************************
- * sdrtrunk
- * Copyright (C) 2014-2017 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,13 +14,11 @@
  *
  * 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.output;
 
-import io.github.dsheirer.sample.buffer.ReusableChannelResultsBuffer;
-import io.github.dsheirer.sample.buffer.ReusableComplexBuffer;
-import io.github.dsheirer.sample.buffer.ReusableComplexBufferAssembler;
+import io.github.dsheirer.sample.complex.ComplexSamples;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -29,7 +27,7 @@ import java.util.List;
 public class OneChannelOutputProcessor extends ChannelOutputProcessor
 {
     private final static Logger mLog = LoggerFactory.getLogger(OneChannelOutputProcessor.class);
-
+    private final OneChannelMixerAssembler mMixerAssembler;
     private int mChannelOffset;
 
     /**
@@ -38,12 +36,14 @@ public class OneChannelOutputProcessor extends ChannelOutputProcessor
      *
      * @param sampleRate of the output sample stream.
      * @param channelIndexes containing a single channel index.
-     * @param gain value to apply.  Typically this is the same as the channelizer's channel count.
+     * @param gain value to apply.  This is typically the same as the channelizer's channel count.
      */
-    public OneChannelOutputProcessor(double sampleRate, List<Integer> channelIndexes, double gain)
+    public OneChannelOutputProcessor(double sampleRate, List<Integer> channelIndexes, float gain)
     {
-        super(1, sampleRate, gain);
+        super(1, sampleRate);
         setPolyphaseChannelIndices(channelIndexes);
+        mMixerAssembler = new OneChannelMixerAssembler(gain);
+        mMixerAssembler.getMixer().setSampleRate(sampleRate);
     }
 
     @Override
@@ -62,7 +62,7 @@ public class OneChannelOutputProcessor extends ChannelOutputProcessor
         if(indexes.size() != 1)
         {
             throw new IllegalArgumentException("Single channel output processor requires a single index to " +
-                "process - provided indexes " + indexes.toString());
+                "process - provided indexes " + indexes);
         }
 
         //Set the channelized output results offset to twice the channel index to account for each channel having
@@ -70,38 +70,45 @@ public class OneChannelOutputProcessor extends ChannelOutputProcessor
         mChannelOffset = indexes.get(0) * 2;
     }
 
+    @Override
+    public void setFrequencyOffset(long frequency)
+    {
+        mMixerAssembler.getMixer().setFrequency(frequency);
+    }
+
     /**
-     * Extract the channel from the channel results array, apply frequency translation, and deliver the
-     * extracted frequency-corrected channel I/Q sample set to the complex sample listener.
+     * 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 channelResults to process containing a list of channel array of I/Q sample pairs (I0,Q0,I1,Q1...In,Qn)
-     * @param reusableComplexBufferAssembler to receive the extracted, frequency-translated channel results
+     * @param lists 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<ReusableChannelResultsBuffer> channelResults,
-                        ReusableComplexBufferAssembler reusableComplexBufferAssembler)
+    public void process(List<float[]> channelResultsList)
     {
-        for(ReusableChannelResultsBuffer channelResultsBuffer: channelResults)
+        for(float[] channelResults: channelResultsList)
         {
-            try
-            {
-                ReusableComplexBuffer channelBuffer = channelResultsBuffer.getChannel(mChannelOffset);
+            mMixerAssembler.receive(channelResults[mChannelOffset], channelResults[mChannelOffset + 1]);
 
-                if(hasFrequencyCorrection())
+            if(mMixerAssembler.hasBuffer())
+            {
+                ComplexSamples buffer = mMixerAssembler.getBuffer();
+
+                if(mComplexSamplesListener != null)
                 {
-                    getFrequencyCorrectionMixer().mixComplex(channelBuffer.getSamples());
+                    try
+                    {
+                        mComplexSamplesListener.receive(buffer);
+                    }
+                    catch(NullPointerException npe)
+                    {
+                        //Ignore ... can happen when the listener is nullified on another thread
+                    }
+                    catch(Exception e)
+                    {
+                        mLog.error("Error extracting channel samples from one polyphase channel results buffer", e);
+                    }
                 }
-
-                channelBuffer.applyGain(getGain());
-
-                reusableComplexBufferAssembler.receive(channelBuffer);
             }
-            catch(IllegalArgumentException iae)
-            {
-                mLog.error("Error extracting channel samples from polyphase channel results buffer");
-            }
-
-            channelResultsBuffer.decrementUserCount();
         }
     }
 }