Fix P25p1 -f1 Unmute on RC4 Key; Misc;

NXDN48/96 Tweak;

.gitignore

@@ -5,3 +5,5 @@ build
 *.sh
 *.csv
 examples
+*.bin
+*.ans

CMakeLists.txt

@@ -1,11 +1,64 @@
-project(dsd-fme-lite)
-cmake_minimum_required(VERSION 2.8.11)
+#Ubuntu 20.04 uses 3.16.3
+#Ubuntu 22.04 uses 3.22.1
+#Arch currently on 3.26.3
+#Cygwin currently using 3.23.2 (or newer)
+cmake_minimum_required(VERSION 3.10.2)
+project(dsd-fme)
 
 SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake/")
 #Set curses to ncurses, and wide true for ascii
 set(CURSES_NEED_NCURSES TRUE)
 set(CURSES_NEED_WIDE TRUE)
 
+#use cmake option -DAERO=ON to enable Aero Builds (OSS support and specific tweaks)
+option(AERO
+    "Build for Aero Environments (Cygwin)" OFF)
+if (AERO)
+    add_definitions(-DAERO_BUILD) 
+endif ()
+
+#use cmake option -DCOLORS=OFF to disable color output
+option(COLORS
+    "Build with Colors Enabled" ON)
+if (COLORS)
+    add_definitions(-DPRETTY_COLORS) 
+endif ()
+
+#use cmake option -DPVC=ON to enable Provoice Conventional Frame Sync
+option(PVC
+    "Build with Provoice Conventional Frame Sync Enabled" OFF)
+if (PVC)
+    add_definitions(-DPVCONVENTIONAL) 
+endif ()
+
+#use cmake option -DNXDN=ON to enable the old NXDN Sync Pattern
+option(NXDN
+    "Build with Old NXDN Sync Pattern Enabled" OFF)
+if (NXDN)
+    add_definitions(-DNXDNOLDSYNC) 
+endif ()
+
+#use cmake option -DLZ=ON to enable LimaZulu Requested NXDN Tweaks
+option(LZ
+    "Build with new LimaZulu Requested NXDN Tweaks Enabled" OFF)
+if (LZ)
+    add_definitions(-DLIMAZULUTWEAKS) 
+endif ()
+
+#use cmake option -DTONES to change default location of the tones.wav files (lwvmobile precompiled 'Aero' releases only)
+option(NXDN
+    "Build with tone wav files in the dsd-fme folder and not in /usr/share/" OFF)
+if (TN)
+    add_definitions(-DTONES) 
+endif ()
+
+#use cmake option -DZDEV to change designation of this build from MAIN to zDEV
+option(NXDN
+    "change designation of this build from MAIN to zDEV" OFF)
+if (ZDEV)
+    add_definitions(-DZDEV_BUILD) 
+endif ()
+
 include(git_revision)
 git_describe(GIT_TAG)
 
@@ -14,7 +67,7 @@ find_package(MBE REQUIRED)
 find_package(ITPP REQUIRED)
 find_package(RTLSDR)
 find_package(Curses REQUIRED) 
-find_package(PULSEAUDIO REQUIRED)
+find_package(PulseAudio REQUIRED)
 
 include_directories(SYSTEM ${LIBSNDFILE_INCLUDE_DIR} ${MBE_INCLUDE_DIR} ${ITPP_INCLUDE_DIR} ${PULSEAUDIO_INCLUDE_DIRS} ${CURSES_INCLUDE_DIR})
 set(LIBS ${MBE_LIBRARY} ${LIBSNDFILE_LIBRARY} ${ITPP_LIBRARY} ${PULSEAUDIO_SIMPLE_LIBRARY} ${CURSES_LIBRARY})
@@ -38,24 +91,24 @@ list(APPEND SRCS "${CMAKE_CURRENT_BINARY_DIR}/git_ver.c")
 
 include_directories("${PROJECT_SOURCE_DIR}/include")
 
-ADD_EXECUTABLE(dsd-fme-lite ${SRCS} ${HEADERS})
-TARGET_LINK_LIBRARIES(dsd-fme-lite ${LIBS})
+ADD_EXECUTABLE(dsd-fme ${SRCS} ${HEADERS})
+TARGET_LINK_LIBRARIES(dsd-fme ${LIBS})
 
 include(GNUInstallDirs)
-install(TARGETS dsd-fme-lite DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(TARGETS dsd-fme DESTINATION ${CMAKE_INSTALL_BINDIR})
 
 # man page
 find_program(HELP2MAN_FOUND help2man)
 if (HELP2MAN_FOUND)
-    add_custom_command(TARGET dsd-fme-lite POST_BUILD
+    add_custom_command(TARGET dsd-fme POST_BUILD
         COMMAND help2man
         ARGS -n "Digital Speech Decoder"
             --version-string=${GIT_TAG}
-            -o ${CMAKE_CURRENT_BINARY_DIR}/dsd-fme-lite.1
+            -o ${CMAKE_CURRENT_BINARY_DIR}/dsd-fme.1
             --no-info
-            $<TARGET_FILE:dsd-fme-lite>
+            $<TARGET_FILE:dsd-fme>
     )
-    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/dsd-fme-lite.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
+    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/dsd-fme.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
 endif()
 
 # uninstall target

README.md

@@ -1,17 +1,10 @@
-## Notice
-
-This branch is for modifications to make a Windows 32-bit binary to be precompiled, please DO NOT use this branch if you are a Linux User, or copy any contents out of here to modify your existing setup!
 
 # Digital Speech Decoder - Florida Man Edition
 
 DSD-FME is an evolution of the original DSD project from 'DSD Author' using the base code of [szechyjs](https://github.com/szechyjs/dsd "szechyjs"), some code and ideas from [LouisErigHerve](https://github.com/LouisErigHerve/dsd "LouisErigHerve"), [Boatbod OP25](https://github.com/boatbod/op25 "Boatbod OP25") and 
-[Osmocom OP25](https://gitea.osmocom.org/op25/op25 "Osmocom OP25"), along with other snippets of code, information, and inspirations from other projects including [DSDcc](https://github.com/f4exb/dsdcc "DSDcc"), [SDTRunk](https://github.com/DSheirer/sdrtrunk "SDRTrunk"), [MMDVMHost](https://github.com/g4klx/MMDVMHost "MMDVMHost"), [LFSR](https://github.com/mattames/LFSR "LFSR"), [OK-DMRlib](https://github.com/OK-DMR/ok-dmrlib "OK-DMRlib"), and [EZPWD-Reed-Solomon](https://github.com/pjkundert/ezpwd-reed-solomon "EZPWD"), Eric Cottrell, SP5WWP and others. Finally, this is all brought together with original code to extend the fuctionality and add new features including NCurses Terminal and Menu system, Pulse Audio, TCP Direct Link Audio, RIGCTL, Trunking Features, LRRP/GPS Mapping, P25 Phase 2, EDACS, OP25 Capture Bin compatability, etc. DSD-FME is primarily focused with Linux Desktop users, so please understand that this version may not compile, compile easily, or run correctly in other environments.
+[Osmocom OP25](https://gitea.osmocom.org/op25/op25 "Osmocom OP25"), along with other snippets of code, information, and inspirations from other projects including [DSDcc](https://github.com/f4exb/dsdcc "DSDcc"), [SDRTRunk](https://github.com/DSheirer/sdrtrunk "SDRTrunk"), [MMDVMHost](https://github.com/g4klx/MMDVMHost "MMDVMHost"), [LFSR](https://github.com/mattames/LFSR "LFSR"), [OK-DMRlib](https://github.com/OK-DMR/ok-dmrlib "OK-DMRlib"), and [EZPWD-Reed-Solomon](https://github.com/pjkundert/ezpwd-reed-solomon "EZPWD"), Eric Cottrell, SP5WWP and others. Finally, this is all brought together with original code to extend the fuctionality and add new features including NCurses Terminal and Menu system, Pulse Audio, TCP Direct Link Audio, RIGCTL, Trunking Features, LRRP/GPS Mapping, P25 Phase 2, EDACS, OP25 Capture Bin compatability, etc. DSD-FME is primarily focused with Linux Desktop users in mind, so please understand that this version may not compile, compile easily, or run correctly in other environments.
 
-This project wouldn't be possible without a few good people providing me plenty of sample audio files to run over and over again. Special thanks to jurek1111, KrisMar, noamlivne, racingfan360, iScottyBotty, LimaZulu and others for the many hours of wav samples submitted by them. Most importantly, HRH17, whose insight, information, samples, and willingness to let me remote into a computer half-way across the globe in order to test trunking features are what make DSD-FME what it has become. Thank you everybody.
-
-Click image below for video of current DMR/P25 trunking capabilities.
-
-[![DSD-FME](https://github.com/lwvmobile/dsd-fme/blob/main/dsd-fme.png)](https://www.youtube.com/watch?v=hGIijBbbUxg "DSD-FME Trunking Demo")
+This project wouldn't be possible without a few good people providing me plenty of sample audio files to run over and over again. Special thanks to jurek1111, KrisMar, noamlivne, racingfan360, iScottyBotty, LimaZulu, Forts, thewraithe2008, RayAir, and others for the many hours of wav samples and information provided by them. Most importantly, HRH17, whose insight, information, samples, and willingness to let me remote into a computer half-way across the globe in order to test trunking features are what make DSD-FME what it has become. I'd also like to thank mrscanner2008 for providing an additional remote where additional NXDN Type-C, 'Idas' Type-D, and XPT decoding and trunking could be sorted out. Thank you everybody.
 
 ![DSD-FME](https://github.com/lwvmobile/dsd-fme/blob/main/dsd-fme2.png)
 
@@ -21,10 +14,6 @@ Click image below for video of current DMR/P25 trunking capabilities.
 
 See the [examples](https://github.com/lwvmobile/dsd-fme/tree/main/examples "examples") folder for information on [cloning and installing](https://github.com/lwvmobile/dsd-fme/blob/main/examples/Install_Notes.md "cloning and installing"), [example usage](https://github.com/lwvmobile/dsd-fme/blob/main/examples/Example_Usage.md "example usage"), and [trunking examples](https://github.com/lwvmobile/dsd-fme/blob/main/examples/trunking.sh "trunking examples").
 
-## Notice
-
-The pulseaudio branch has been deleted in favor of the new main branch which also uses Pulse Audio. Users moving to the main branch should review the help file and example usage files for changes in syntax. Users can download the last pulse audio branch version from the release link if they prefer the older version. Any pre-compiled windows versions found in the release link will be considered legacy as well, and do not feature trunking support and have older handling for some other modes. Users are free to use those, but keep in mind the use case syntax may and will be different between versions. Furthermore, any wiki articles with 'auto intstall scripts' made for windows users may contain outdated information for building the deleted pulseaudio branch, please adjust any information found in those accordingly.
-
 ## License
 Copyright (C) 2010 DSD Author
 GPG Key ID: 0x3F1D7FD0 (74EF 430D F7F2 0A48 FCE6  F630 FAA2 635D 3F1D 7FD0)

download-and-install-nodeps.sh

@@ -0,0 +1,23 @@
+#! /bin/bash
+clear
+echo DSD-FME Digital Speech Decoder - Florida Man Edition Auto Installer 
+echo This will clone, build, and install DSD-FME only.
+echo If you need dependencies installed, please run download-and-install.sh instead. 
+echo
+
+read -p "Press enter to continue"
+
+git clone https://github.com/lwvmobile/dsd-fme
+cd dsd-fme
+sudo cp tone8.wav /usr/share/
+sudo cp tone24.wav /usr/share/
+sudo cp tone48.wav /usr/share/
+sudo chmod 777 /usr/share/tone8.wav
+sudo chmod 777 /usr/share/tone24.wav
+sudo chmod 777 /usr/share/tone48.wav
+mkdir build
+cd build
+cmake ..
+make -j `nproc`
+sudo make install
+sudo ldconfig

download-and-install.sh

@@ -0,0 +1,67 @@
+#! /bin/bash
+clear
+echo DSD-FME Digital Speech Decoder - Florida Man Edition Auto Installer
+echo MBELib is considered a requirement on this build.
+echo You must view this notice prior to continuing. 
+echo The Patent Notice can be found at the site below.
+echo https://github.com/lwvmobile/mbelib#readme
+echo Please confirm that you have viewed the patent notice by entering y below.
+echo
+echo y/N
+read ANSWER
+Y='y'
+if [[ $Y == $ANSWER ]]; then
+
+sudo apt update
+sudo apt install libpulse-dev pavucontrol libsndfile1-dev libfftw3-dev liblapack-dev socat libusb-1.0-0-dev libncurses5 libncurses5-dev rtl-sdr librtlsdr-dev libusb-1.0-0-dev cmake git wget make build-essential libitpp-dev libncursesw5-dev
+
+echo ITPP Manual Build and Install has been temporarily removed from this script due to issues with older versions of Ubuntu.
+echo Please check to see that libitpp-dev has successfully been downloaded and installed from the repo.
+read -p "Press enter to continue"
+
+#wget -O itpp-latest.tar.bz2 http://sourceforge.net/projects/itpp/files/latest/download?source=files
+#tar xjf itpp*
+#if you can't cd into this folder, double check folder name first
+#cd itpp-4.3.1 
+#mkdir build
+#cd build
+#cmake ..
+#make -j `nproc`
+#sudo make install
+#sudo ldconfig
+#cd ..
+#cd ..
+
+git clone https://github.com/lwvmobile/mbelib
+cd mbelib
+mkdir build
+cd build
+cmake ..
+make -j `nproc`
+sudo make install
+sudo ldconfig
+cd ..
+cd ..
+
+git clone https://github.com/lwvmobile/dsd-fme
+cd dsd-fme
+sudo cp tone8.wav /usr/share/
+sudo cp tone24.wav /usr/share/
+sudo cp tone48.wav /usr/share/
+sudo chmod 777 /usr/share/tone8.wav
+sudo chmod 777 /usr/share/tone24.wav
+sudo chmod 777 /usr/share/tone48.wav
+mkdir build
+cd build
+cmake ..
+make -j `nproc`
+sudo make install
+sudo ldconfig
+
+else
+echo
+echo Sorry, you cannot build DSD-FME without acknowledging the Patent Notice.
+fi
+
+
+

examples/Example_Usage.md

@@ -1,6 +1,6 @@
 ### Example Usage and Notes!
 
-`dsd-fme` is all you need to run for pulse input, pulse output, and auto detect for DMR BS/MS, and P25 (1 and 2) . To use other decoding methods which cannot be auto detected, please use the following command line switches. Make sure to route audio into and out of DSD-FME using pavucontrol and virtual sinks as needed.
+`dsd-fme` is all you need to run for pulse input, pulse output, and auto detect for DMR BS/MS, and P25. To use other decoding methods which cannot be auto detected, please use the following command line switches. Make sure to route audio into and out of DSD-FME using pavucontrol and virtual sinks as needed.
 
 ```
 -ft XDMA decoder class (P25 1 and 2, and DMR Stereo)
@@ -12,10 +12,28 @@
 -fm dPMR, also may need to use -xd if inverted dPMR.
 -fr DMR Mono, also may need to use -xr if inverted DMR.
 -f1 P25P1
--f2 P25P2 (will need to specify wacn/sys/nac manually)
+-f2 P25P2 (may need to specify wacn/sys/nac manually)
 -fx X2-TDMA
 ```
 
+## Conventional Frequency "Fast Scanner"
+This feature is used to allow DSD-FME to use RIGCTL or RTL input and cycle through frequencies as fast as possible to attain a frame sync. 
+
+This works almost identically to how the trunkng methods work, but instead of locking onto a control channel and tuning based on its decoding, it rapidly tunes through all loaded frequencies in a CSV file and stops when it finds a frame sync. This method is meant for loading a bunch of conventional non-trunking frequencies that signal only when voice or short data bursts are present (DMR T2, Conventional P25 P1, Conventional NXDN, etc) and decode them until the frame sync stops and then resume its scan. This method uses SDR++ RIGCTL, or RTL internal handling to go through signal. -Y is the fast scanner switch.
+
+To scan through a mixture of DMR and P25 Conventional, use:
+`dsd-fme -i tcp -C channel_map.csv -G group.csv -Y -U 4532 -N 2> log.ans` 
+
+To scan through NXDN48 only conventional, use: 
+`dsd-fme -fi -i tcp -C channel_map.csv -Y -U 4532 -N 2> log.ans` 
+
+To scan through NXDN96 only conventional, use: 
+`dsd-fme -fn -i tcp -C channel_map.csv -Y -U 4532 -N 2> log.ans`
+
+The Channel Map setup will be identical to any of the channel maps found for trunking systems, channel numbers do not matter and can be arbitrarily organized, and frequencies can be duplicated to be 'scanned' more frequently in larger CSV files. Scan speed by default is 1 second, and is most stable at that speed. This can be adjusted by using the `-t 2` option, for example, to specify 2 seconds of hang time per frequency. ~~If activity occurs on a frequency, an additional 2 seconds of 'hangtime' will occur on that frequency for any follow up voice activity.~~
+
+Please Note: DMR Simplex may not behave well on fast scan, I have not been able to test it as such, but given the nature of the on-off timeslot signalling on DMR Simplex, missed frame syncs and skipping/resuming scan may occur.
+
 ## Trunking Examples
 Please see trunking.sh for sample start up scripts or scroll down to the bottom for more explanation.
 
@@ -45,26 +63,33 @@ Then you can open up your pavucontrol "Pulse Audio Volume Control" or "Volume Co
 Wav File Input Note: Due to 96000 rate audio requiring me to double the symbol rate and center, be sure to use the -s 96000 at the very end of the startup command. Also, some NXDN48/96 may have difficulties decoding properly with wav file input. 
 
 ## Example Usage - RTL2832 Dongle Input
+Short Setup (all default values):
+
+`dsd-fme -i rtl`
+
+Detailed Setup:
+
 `dsd-fme -ft -i rtl:0:154.9875M:26:-2:8:0:6020 `
 
 ```
 RTL-SDR options:
- WARNING! Old CLI Switch Handling has been depreciated in favor of rtl:<parms>
  Usage: rtl:dev:freq:gain:ppm:bw:sq:udp
+  NOTE: all arguments after rtl are optional now for trunking, but user configuration is recommended
   dev  <num>    RTL-SDR Device Index Number
-  freq <num>    RTL-SDR Frequency (851800000 or 851.8M)
-  gain <num>    RTL-SDR Device Gain (0-49) (default = 26)(0 = Hardware AGC, not recommended)
+  freq <num>    RTL-SDR Frequency (851800000 or 851.8M) 
+  gain <num>    RTL-SDR Device Gain (0-49)(default = 0; Hardware AGC recommended)
   ppm  <num>    RTL-SDR PPM Error (default = 0)
-  bw   <num>    RTL-SDR VFO Bandwidth kHz (default = 12)(6, 8, 12, 24) 
-  sq   <num>    RTL-SDR Squelch Level (0 - Open, 25 - Little, 50 - Higher)
-  udp  <num>    RTL-SDR UDP Remote Port (default = 6020)
- Example: dsd-fme -fp -i rtl:0:851.375M:22:-2:12:0:6021
+  bw   <num>    RTL-SDR Bandwidth kHz (default = 12)(8, 12, 16, 24)  
+  sq   <num>    RTL-SDR Squelch Level vs RMS Value (Optional)
+  udp  <num>    RTL-SDR Legacy UDP Remote Port (Optional -- External Use Only)
+ Example: dsd-fme-zdev -fs -i rtl -C cap_plus_channel.csv -T
+ Example: dsd-fme-zdev -fp -i rtl:0:851.375M:22:-2:24:0:6021
 
 ```
 
 ## Example Usage - Extra Payload/PDU Logging
 
-`dsd-fme -Z -N 2>> log.ans`
+`dsd-fme -Z -N 2> log.ans`
 
 and in a second terminal tab, same folder, run
 
@@ -94,11 +119,11 @@ EDACS Trunking (w/ channel map import)
 
 `dsd-fme -i tcp -T -U 4532 -N 2> log.ans`
 
---P25 Trunking (CQPSK) with P1 Control Channel (Should switch symbol rate and center on Phase 2 audio channels)
+--P25 Trunking (QPSK) with P1 Control Channel (Should switch symbol rate and center on Phase 2 audio channels)
 
 `dsd-fme -i tcp -T -U 4532 -N -mq 2> log.ans`
 
---P25 Trunking Phase 2 TDMA Control Channel systems with CQPSK (non Phase 1 systems)
+--P25 Trunking Phase 2 TDMA Control Channel systems with QPSK (non Phase 1 systems)
 
 `dsd-fme -i tcp -T -U 4532 -N -f2 -m2 2> log.ans`
 
@@ -106,7 +131,7 @@ Trunking Note1: All samples above can also be run with the RTL input method and
 
 `dsd-fme -fp -i rtl:0:851.8M:22:-2:24:0:6020 -T -C channel_map.csv -G group.csv -N 2> log.ans`
 
-Trunking Note2: CQPSK Phase 1 and Phase 2 Systems are subceptible to LSM distortion issues, but seem to do okay, but require really good signal. Some CRC issues still occur with Phase 2 TDMA LCCH Mac Signal that can affect reliability, I believe this issue is ultimately caused by the PSK demodulation inside of FME. I also don't believe this will work on 8-level PSK, but I cannot determine that at the moment. Update: I have improved the LCCH Mac Signal decoding my increasing the QPSK decision point buffers to their maximum values. 
+Trunking Note2: QPSK Phase 1 and Phase 2 Systems may be subceptible to LSM distortion issues, but seem to do okay, but require really good signal. Some CRC issues still occur with Phase 2 TDMA LCCH Mac Signal that can affect reliability, I believe this issue is ultimately caused by the PSK demodulation inside of FME. I also don't believe this will work on 8-level PSK, but I cannot determine that at the moment. Update: I have improved the LCCH Mac Signal decoding my increasing the QPSK decision point buffers to their maximum values. 
 
 Trunking Note3: DMR Trunking has been coded, and some testing and tweaks have been carried out. Cap+, Con+, and TIII systems seem to do well with trunking now. Placing the frequency for the control channel at channel map 0 in your channel_map.csv file is not required now if using RIGCTL or the RTL Input, both can poll the VFO for the current frequency if it believes its on a control channel, but setting a fake channel number (i.e. 999) first with the CC frequency will result in finding the CC faster on startup if desired. If you need to map out your channels for TIII, you can observe the console output and look for channel numbers. For conveniece I have included the DSDPlus channel numbering (as best as I can figure it, but they seem consistent) into the console print so it will make it easier for users from DSDPlus to map frequencies into the channel_map.csv file. Make sure your channel numbers are the Cd (channel decimal) values from the log, and not the C+ (dsdplus) values. Notice: TIII Site ID value needs work to determine proper DMRLA values for system area and sub area.
 
@@ -117,14 +142,18 @@ Trunking Note3: DMR Trunking has been coded, and some testing and tweaks have be
 
 Use channel 54 in your import file, which would correspond to dsdplus channels 109 and 110 (109 = TS0 / 110 = TS1).
 
-For Connect Plus, enumerate your list from 1 to the last channel and add the frequency. For Capacity Plus, Rest Channels 1 and 2 will share the same frequency, 3 and 4 will share, 5 and 6 will share, and 7-8 will share, as Capacity Plus counts each RF frequency as two seperate channels, one for each time slot. Capacity Plus Quirk: DSD-FME makes its best effort to follow the rest channel in the event that the sync is lost for longer than the hangtime, but occassionally, DSD-FME will lose the rest channel and will have to hunt through all frequencies to find it again.
+For Connect Plus, enumerate your list from 1 to the last channel and add the frequency. For Capacity Plus, LSN 1 and 2 will share the same frequency, 3 and 4 will share, 5 and 6 will share, and 7-8 will share, as Capacity Plus counts each 'channel' as two seperate channels (LSN), one for each time slot. Capacity Plus Quirk: DSD-FME makes its best effort to follow the rest channel in the event that the sync is lost for longer than the hangtime, but occassionally, DSD-FME may lose the rest channel and will have to hunt through all frequencies to find it again.
 
-Currently uncoded/unknown DMR trunking systems include Hytera XPT.
+Trunking Note4: NXDN Trunking v1 will require a channel map. Please see the example folder for an appropriate channel map. NOTICE: NXDN trunking has been fixed on the RTL (rtl_fm) input method and works correctly now using a soft squelch value to determine when to look for frame sync. Tests show this works very well, but squelch adjustments may be required to differentiate the noise floor from the signal.
 
-Trunking Note4: NXDN TRunking will require a channel map. Please see the example folder for an appropriate channel map. ~NXDN Trunking may also require a channel map file, depending on the system. If it uses a custom range (above 800), then channels will need to be mapped. If channels do not require mapping (have channels below 800) but you are not tuning properly, then please use a channel_map and please report the issue in the issues along with the channels you are tuning and the actual rf frequency so corrections can be made.~
+NXDN Trunking Update: NXDN DFA (Direct Frequency Assignment) has been coded from the v2 documents, so using a channel map may not be required, as long as the DFA is configured with standard values, and not 'system definable' values. This will only work on trunking systems that use DFA (newer systems) in accordance to the v2 CAI document NXDN TS 1-A Version 2.0 September 2016. If the system uses 'system definable' values, then make sure to put the channels in a channel map csv file as as the 16-bit OFN values for proper tuning.
+
+NXDN Type-D/IDAS Update: Type-D or IDAS decoding/trunking has been coded now and tested on a small two channel system. Set up a channel map much like Type-C trunking. If preferred, insert channel 31 at the top of your channel map for the 'home repeater' or go to channel of choice during a TX_REL or DISC message. Extensive testing of Type-D has not been conducted. Some cavaets may currently include iffy per call wav file saving and potentially shifting SRC and TGT ID values due to how SCCH messages are handled and how Busy Repeater Messages are handled. Private calls will need to be enabled by enabling 'data calls', if desired. During testing, only data calls came on private calls, so this was set to disabled by default, but can be enabled with data calls enabled. Also, note that some home repeater channels may or may not carry calls from all systems.
 
 Channel Map and Group CSV Note: Leave the top line of the channel_map.csv and group.csv as the label, do not delete the line, if no line is there, dsd_import skips the first line so it will not import the first channel or first group in those files if there is something there that isn't a label. 
 
+Hytera XPT: Code has been added for XPT system slco/flco/csbk decoding and trunking. The setup will be similar to Capacity Plus trunking in the csv file, listing each LSN channel to a frequency (see examples/hytera_xpt_chan.csv). Currently, this set up is working with smaller XPT systems that I have been able to test with.
+
 ## NCurses Keyboard Shortcuts ##
 
 Some Keyboard Shortcuts have been implemented for testing to see how users like them. Just hope nobody pushes a key on accident and doesn't know which one it was or what it does. The current list of keyboard shortcuts include:
@@ -136,7 +165,8 @@ c - toggle compact mode
 h - toggle call history
 z - toggle console payloads
 a - toggle call alert beep
-4 - force dmr privacy key assertion over fid and svc bits
+4 - force privacy/scrambler key assertion over enc identifiers (dmr and nxdn)
+6 - force rc4 key assertion over missing pi header/le enc identifiers (dmr)
 i - toggle signal inversion on types that can't auto detect (dmr, dpmr)
 m - toggle c4fm/qpsk 10/4 (everything but phase 2 signal)
 M - toggle c4fm/qpsk 8/3 (phase 2 tdma control channel)
@@ -144,15 +174,20 @@ R - start capturing symbol capture bin (date/time name file)
 r - stop capturing symbol capture bin
 spacebar - replay last symbol capture bin (captures must be stopped first)
 s - stop playing symbol capture bin or wav input file
-P - start per call decoded wav files
-p - stop per call decoded wav files
+P - start per call decoded wav files (Capital P)
+p - stop per call decoded wav files (Lower p)
 t - toggle trunking (needs either rtl input, or rigctl connection)
-1 - Lockout Tuning/Playback of TG in Slot 1 or Conventional (Current Session Only)
-2 - Lockout Tuning/Playback of TG in Slot 2 (Current Session Only)
+y - toggle scanner (needs either rtl input, or rigctl connection)
+1 - Lockout Tuning/Playback of TG in Slot 1 or Conventional -- Current Session Only if no group.csv file specified
+2 - Lockout Tuning/Playback of TG in Slot 2 -- Current Session Only if no group.csv file specified
 0 - Toggle Audio Smoothing - May produce crackling if enabled on RTL/TCP or wav/bin files
 w - Toggle Trunking/Playback White List (Allow A Groups Only) / Black List (Block B or DE groups only) Mode
-g - Toggle Trunking Tuning to Group Calls (DMR T3, Con+, Cap+, P25)
-u - Toggle Trunking Tuning to Private Calls (DMR T3, P25)
-d - Toggle Trunking Tuning to Data Calls (DMR T3)
-
+g - Toggle Trunking Tuning to Group Calls (DMR T3, Con+, Cap+, P25, NXDN)
+u - Toggle Trunking Tuning to Private Calls (DMR T3, Cap+, P25)
+d - Toggle Trunking Tuning to Data Calls (DMR T3, NXDN)
+e - Toggle Trunking Tuning to Encrypted Calls (P25)
+8 - Connect to SDR++ TCP Audio Sink with Defaults/Retry Sink Connection on Disconnect
+9 - Connect to SDR++ RIGCTL Server with Defaults/Retry RIGCTL Connection
+D - Reset DMR Site Parms/Call Strings, etc.
+Z - Simulate NoCarrier/No VC/CC sync (capital Z)
 ```

examples/Install_Notes.md

@@ -1,12 +1,8 @@
-## Notice
-
-These should not be followed for the 'lite' branch
-
 ## How to clone and build this branch
 
 ### Ubuntu 22.04/20.04/LM20/Debian Bullseye or Newer:
 
-Using the included download-and-install.sh should make for a simple and painless clone, build, and install on newer Debian/Ubuntu/Mint/Pi systems. Simply acquire or copy the script, and run it. Update: Ubuntu 22.04 and RPi Bullseye 64-bit has been tested working with the installer script and functions appropriately.
+Using the included download-and-install.sh should make for a simple and painless clone, build, and install on newer Debian/Ubuntu/Mint/Pi systems. Simply acquire or copy the script, and run it. Update: Ubuntu 23.04 and RPi Bullseye 64-bit has been tested working with the installer script and functions appropriately.
 
 If you need all dependencies build and installed first (only on Debian/Ubuntu/Mint/Pi), run:
 
@@ -15,7 +11,7 @@ wget https://raw.githubusercontent.com/lwvmobile/dsd-fme/main/download-and-insta
 chmod +x download-and-install.sh
 ./download-and-install.sh
 ```
-
+f
 If you have dependencies already installed (i.e. need a fresh clean install on a system with DSD-FME already or using system other than Debian/Ubuntu, etc), please run this instead:
 
 ```
@@ -24,18 +20,23 @@ chmod +x download-and-install-nodeps.sh
 ./download-and-install-nodeps.sh
 ```
 
-### Ubuntu 18.04/LM19/Buster Note:
-The above install.sh should now function on older system types. You can elect to manually follow the steps down below. Do NOT Manually build and install ITPP 4.3.1 on older systems, it is currently not wanting to build on Ubuntu 18.04 and Linux Mint 19. Install it from the repository instead.
-
 ## Manual Install
 
 First, install dependency packages. This guide will assume you are using Debian/Ubuntu based distros. Check your package manager for equivalent packages if different.
 
+Debian/Mint/Ubuntu/Pi
+
 ```
 sudo apt update
 sudo apt install libpulse-dev pavucontrol libsndfile1-dev libfftw3-dev liblapack-dev socat libusb-1.0-0-dev libncurses5 libncurses5-dev rtl-sdr librtlsdr-dev libusb-1.0-0-dev cmake git wget make build-essential libitpp-dev libncursesw5-dev
 ```
-## Headless
+
+Fedora 36/37 -- from https://github.com/lwvmobile/dsd-fme/issues/99
+
+```
+sudo dnf install libsndfile-devel fftw-devel lapack-devel rtl-sdr-devel pulseaudio-libs-devel libusb-devel cmake git ncurses ncurses-devel gcc wget pavucontrol gcc-c++
+```
+## Headless Ubuntu Server/Pi
 
 If running headless, swap out pavucontrol for pulsemixer, and also install pulseaudio as well. Attempting to install pavucontrol in a headless environment may attempt to install a minimal desktop environment. Note: Default behavior of pulseaudio in a headless environment may be to be muted, so check by opening pulsemixer and unmuting and routing audio appropriately.
 
@@ -97,13 +98,45 @@ sudo make install
 sudo ldconfig
 
 ```
-Optional 'Virtual Sinks' for routing audio from SDR++ or GQRX, Media Players, etc. into DSD-FME
 
-You may wish to direct sound into DSD-FME via Virtual Sinks. You may set up a Virtual Sink or two on your machine for routing audio in and out of applications to other applications using the following command, and opening up pavucontrol "PulseAudio Volume Control" in the menu (or `pulsemixer` in headless mode) to change line out of application to virtual sink, and line in of DSD-FME to monitor of virtual sink. This command will not persist past a reboot, so you will need to invoke them each time you reboot, or search for how to add this to your conf files for persistency if desired.
+### Windows Cygwin Builds
+
+If using RTL input support, you must install libusb-win32 before proceeding with Cygwin installation. You will also need to build and compile a version of librtlsdr, but this can be tricky, and personally, I had to resort to using a much older version of the source code to get it to build at all with the rtl support in the precompiled 'Aero' builds.
+
+Then install all dependencies available in the repo prior to building, either directly selecting them during setup with the setup-x86.exe or setup-x64.exe or by issuing a command similar to this:
 
 ```
-pacmd load-module module-null-sink sink_name=virtual_sink  sink_properties=device.description=Virtual_Sink
-pacmd load-module module-null-sink sink_name=virtual_sink2  sink_properties=device.description=Virtual_Sink2
+setup-x64.exe --packages libpulse-devel,libpulse-mainloop-glib0,libpulse-simple0,libpulse0,pulseaudio,pulseaudio-debuginfo,pulseaudio-equalizer,pulseaudio-module-x11,pulseaudio-module-zeroconf,pulseaudio-utils,sox-fmt-pulseaudio,xfce-pulseaudio-plugin,libusb0,libusb1.0,libusb1.0-debuginfo,libusb1.0-devel,libncurses++w10,libncurses-devel,libncursesw10,ncurses,cmake,gcc-core,gcc-debuginfo,gcc-objc,git,make,socat,sox,sox-fmt-ao,unzip,wget,gcc-g++,libsndfile-devel
+```
+
+Then manually install ITPP and MBElib, see above install notes. Be sure to run `cp libmbe* /usr/lib` after compiling MBElib.
+
+Then you can build and install using
+
+```
+git clone https://github.com/lwvmobile/dsd-fme
+cd dsd-fme
+cp tone8.wav /usr/share/
+cp tone24.wav /usr/share/
+cp tone48.wav /usr/share/
+chmod 777 /usr/share/tone8.wav
+chmod 777 /usr/share/tone24.wav
+chmod 777 /usr/share/tone48.wav
+mkdir build
+cd build
+# -DAERO=ON is optional, but recommended if you want the older OSS support as well
+cmake -DAERO=ON ..
+make
+make install
+```
+
+### Virtual Sinks
+
+You may wish to direct sound into DSD-FME via Virtual Sinks. You may set up a Virtual Sink or two on your machine for routing audio in and out of applications to other applications using the following command, and opening up pavucontrol "PulseAudio Volume Control" in the menu (or `pulsemixer` in headless mode) to change line out of application to virtual sink, and line in of DSD-FME to monitor of virtual sink. This command will not persist past a reboot, so you will need to invoke them each time you reboot, or search for how to add this to your conf files for persistency if desired. Note: This setup is completely optional if using TCP Network Sink Audio and/or RTL Input.
+
+```
+pactl load-module module-null-sink sink_name=virtual_sink  sink_properties=device.description=Virtual_Sink
+pactl load-module module-null-sink sink_name=virtual_sink2  sink_properties=device.description=Virtual_Sink2
 ```
 
 Already have this branch, and just want to pull the latest build? You can run the rebuild.sh file in the dsd-fme folder, or manually do the pull with the commands:

examples/capacity_plus_chan.csv

@@ -1,4 +1,4 @@
-ChannelNumber(dec),frequency(Hz) (do not delete this line or won't import properly)
+LSN(dec),frequency(Hz) (do not delete this line or won't import properly)
 1,858606250
 2,858606250
 3,859606250

examples/edacs_channel_map.csv

@@ -1,4 +1,4 @@
-ChannelNumber(dec),frequency(Hz) (do not delete this line or won't import properly)
+LSN(dec),frequency(Hz) (do not delete this line or won't import properly)
 1,851375000
 2,851800000
 3,855987500

examples/hytera_xpt_chan.csv

@@ -0,0 +1,10 @@
+LSN(dec),frequency(Hz) (do not delete this line or won't import properly)
+1,858606250
+2,858606250
+3,859606250
+4,859606250
+5,860606250
+6,860606250
+7,861606250
+8,861606250
+

examples/multi_key.csv

@@ -0,0 +1,6 @@
+key id or tg id (dec), key number or value (dec) //NXDN Scrambler, BP, 10-char Hytera BP only
+2,70
+1,123
+100,70
+12,48713912656
+672560,254

examples/multi_key_hex.csv

@@ -0,0 +1,5 @@
+key id(hex), key value (hex) //10-char Hytera BP, RC4
+1,1234567890
+2,ABCDEF1234
+C,0B57935150
+64,0B57935150

examples/nxdn_sc_key.csv

@@ -1,4 +1,4 @@
-key(dec), value(dec), load any single keys as key 0
+key(dec) or tg(dec), value(dec), load any single keys as key 0
 0,23466
 1,12345
 2,32700

examples/trunking.sh

@@ -1,33 +1,37 @@
-#example trunking sh scripts (SDR++ and RTL Input) -T = trunking
+#example trunking sh scripts (SDR++ with RIGCTL and RTL Input)
 #make sure to put a # in front of all lines except the one you wish to use
 
 #P25 P1 FDMA CC with C4FM 
 #dsd-fme -i tcp -U 4532 -T -N 2> log.ans
-#dsd-fme -i rtl:0:850M:26:-2:8:0:6020 -T -N 2> log.ans
+#dsd-fme -i rtl:0:850M:0:-2:12 -T -N 2> log.ans
 
 #P25 P1 FDMA CC with QPSK (Simulcast) 
 #dsd-fme -i tcp:192.168.7.8:7355 -U 4532 -T -mq -N 2> log.ans
-#dsd-fme -i rtl:0:855.625M:26:-2:12:0:6020 -T -mq -N 2> log.ans
+#dsd-fme -i rtl:0:855.625M:0:-2:12 -T -mq -N 2> log.ans
 
 #P25 P2 TDMA CC with QPSK (Simulcast)
 #dsd-fme -i tcp:192.168.7.8:7355 -U 4532 -T -f2 -m2 -N 2> log.ans
-#dsd-fme -i rtl:0:855.625M:26:-2:12:0:6020 -T -f2 -m2 -N 2> log.ans
+#dsd-fme -i rtl:0:855.625M:0:-2:12 -T -f2 -m2 -N 2> log.ans
 
-#DMR TIII, Con+, Cap+
+#DMR TIII, Con+, Cap+, XPT
 dsd-fme -fs -i tcp -U 4532 -T -C dmr_t3_chan.csv -G group.csv -N 2> log.ans
-#dsd-fme -fs -i rtl:0:450M:26:-2:8:0:6020 -T -C connect_plus_chan.csv -G group.csv -N 2> log.ans
+#dsd-fme -fs -i rtl:0:450M:44:-2:8 -T -C connect_plus_chan.csv -G group.csv -N 2> log.ans
 
 #EDACS/EDACS-EA Digital Only
 #dsd-fme -fp -i tcp:192.168.7.5:7355 -U 4532 -T -C edacs_channel_map.csv -G group.csv -N 2> log.ans
-#dsd-fme -fp -i rtl:0:850M:26:-2:24:0:6020 -T -C edacs_channel_map.csv -G group.csv -N 2> log.ans
+#dsd-fme -fp -i rtl:0:850M:44:-2:24 -T -C edacs_channel_map.csv -G group.csv -N 2> log.ans
 
-#NXDN48 Trunking with Standard Band Plan (Channels 0-800)
+#NXDN48 Type-C or Type-D Trunking with Channel Map
+#dsd-fme -fi -i tcp -T -U 4532 -C nxdn_channel_map.csv -N 2> log.ans
+#dsd-fme -fi -i rtl:0:855.625M:0:-2:12:100 -T -C nxdn_channel_map.csv -N 2> log.ans
+
+#NXDN48 Type-C Trunking with DFA
 #dsd-fme -fi -i tcp -T -U 4532 -N 2> log.ans
-#dsd-fme -fi -i rtl:0:450M:26:-2:8:75:6020 -T -G group.csv -N 2> log.ans
+#dsd-fme -fi -i rtl:0:855.625M:0:-2:12:100 -T -N 2> log.ans
 
-#NXDN48 Trunking with Channel Map (Custom Channels > 800)
-#dsd-fme -fi -i tcp -T -U 4532 -C channel_map.csv -N 2> log.ans
-#dsd-fme -fi -i rtl:0:450M:26:-2:8:75:6020 -T -G group.csv -C channel_map.csv -N 2> log.ans
+#NXDN96 Trunking with Channel Map
+#dsd-fme -fn -i tcp -T -U 4532 -C nxdn_channel_map.csv -N 2> log.ans
+#dsd-fme -fn -i rtl -T -C nxdn_channel_map.csv -N 2> log.ans
 
 #Notes: parameters after -i tcp can be omitted if using localhost as the default hostname to connect
 #and 7355 as the default port number. -U is the port number for RIGCTL and will mirror the tcp hostname
@@ -36,5 +40,6 @@ dsd-fme -fs -i tcp -U 4532 -T -C dmr_t3_chan.csv -G group.csv -N 2> log.ans
 #inside of SDR++ match, i.e., change in SDR++ from 'localhost' to an IP to bind to (machine's IP address)
 
 #Note2: RTL input should only be used on strong signal, the SDR++ VFO will perform much better on marginal signal
+#paramters after -i rtl can also be omitted now if using the default configurations
 
 #Having a -G group.csv is purely optional, but useful if you want to block groups, or give groups names

include/dsd.h

@@ -17,7 +17,8 @@
  * PERFORMANCE OF THIS SOFTWARE.
  */
 
-//pretty pretty colors
+//defined by CMakeLists.txt -- Disable by using cmake -DCOLORS=OFF ..
+#ifdef PRETTY_COLORS
 #define KNRM  "\x1B[0m"
 #define KRED  "\x1B[31m"
 #define KGRN  "\x1B[32m"
@@ -26,6 +27,16 @@
 #define KMAG  "\x1B[35m"
 #define KCYN  "\x1B[36m"
 #define KWHT  "\x1B[37m"
+#else
+#define KNRM  ""
+#define KRED  ""
+#define KGRN  ""
+#define KYEL  ""
+#define KBLU  ""
+#define KMAG  ""
+#define KCYN  ""
+#define KWHT  ""
+#endif
 
 #include "config.h"
 #include <stdio.h>
@@ -259,6 +270,7 @@ typedef struct
   int rtl_udp_port;
   int rtl_bandwidth;
   int rtl_started;
+  int rtl_rms;
   int monitor_input_audio;
   int pulse_raw_rate_in;
   int pulse_raw_rate_out;
@@ -325,7 +337,9 @@ typedef struct
 
   int p25_trunk; //experimental P25 trunking with RIGCTL (or RTLFM)
   int p25_is_tuned; //set to 1 if currently on VC, set back to 0 if on CC
-  int trunk_hangtime; //hangtime in seconds before tuning back to CC
+  float trunk_hangtime; //hangtime in seconds before tuning back to CC
+
+  int scanner_mode; //experimental -- use the channel map as a conventional scanner, quicker tuning, but no CC
 
   //csv import filenames
   char group_in_file[1024];
@@ -356,13 +370,19 @@ typedef struct
   //Trunking - Tune Data Calls
   uint8_t trunk_tune_data_calls;
 
+  //Trunking - Tune Enc Calls (P25 only on applicable grants with svc opts)
+  uint8_t trunk_tune_enc_calls;
+
   //OSS audio - slot preference
-  uint8_t slot_preference;
+  int slot_preference;
 
   //'DSP' Format Output
   uint8_t use_dsp_output;
   char dsp_out_file[2048];
 
+  //Use P25p1 heuristics
+  uint8_t use_heuristics;
+
 } dsd_opts;
 
 typedef struct
@@ -527,17 +547,19 @@ typedef struct
   int directmode;
 
   int dmr_stereo_payload[144];    //load up 144 dibit buffer for every single DMR TDMA frame
-  uint8_t data_header_blocks[2];  //collect number of blocks to follow from data header per slot
+  int data_header_blocks[2];      //collect number of blocks to follow from data header per slot
+  int data_block_counter[2];      //counter for number of data blocks collected
+  uint8_t data_header_valid[2];   //flag for verifying the data header if still valid (in case of tact/burst fec errs)
   uint8_t data_header_padding[2]; //collect number of padding octets in last block per slot
   uint8_t data_header_format[2];  //collect format of data header (conf or unconf) per slot
   uint8_t data_header_sap[2];     //collect sap info per slot
-  uint8_t data_block_counter[2];  //counter for number of data blocks collected
   uint8_t data_p_head[2];         //flag for dmr proprietary header to follow
 
   //new stuff below here
-  uint8_t data_conf_data[2];      //flag for confirmed data blocks per slot
-  uint8_t dmr_pdu_sf[2][288];     //unified pdu 'superframe' //[slot][byte]
-  uint8_t cap_plus_csbk_bits[12*8*4]; //CSBK Cap+ FL initial and appended block bit storage
+  uint8_t data_conf_data[2];            //flag for confirmed data blocks per slot
+  uint8_t dmr_pdu_sf[2][288];          //unified pdu 'superframe' //[slot][byte]
+  uint8_t cap_plus_csbk_bits[2][12*8*8]; //CSBK Cap+ FL initial and appended block bit storage, by slot
+  uint8_t cap_plus_block_num[2];         //received block number storage -- per timeslot
   uint8_t data_block_crc_valid[2][25]; //flag each individual block as good crc on confirmed data
   char dmr_embedded_signalling[2][7][48]; //embedded signalling 2 slots by 6 vc by 48 bits (replacing TS1SuperFrame.TimeSlotRawVoiceFrame.Sync structure)
 
@@ -552,6 +574,7 @@ typedef struct
   char dmr_lrrp_gps[2][200]; //2 slots by 99 char string for string lrrp gps
   char dmr_site_parms[200]; //string for site/net info depending on type of DMR system (TIII or Con+)
   char call_string[2][200]; //string for call information
+  char active_channel[31][200]; //string for storing and displaying active trunking channels
 
 
   dPMRVoiceFS2Frame_t dPMRVoiceFS2Frame;
@@ -593,6 +616,7 @@ typedef struct
   int p2_is_lcch; //flag to tell us when a frame is lcch and not sacch
 
   //iden freq storage for frequency calculations
+  int p25_chan_tdma[16]; //set from iden_up vs iden_up_tdma
   int p25_chan_iden;
   int p25_chan_type[16];
   int p25_trans_off[16];
@@ -638,6 +662,7 @@ typedef struct
   int lcn_freq_roll; //number we have 'rolled' to in search of the CC
   time_t last_cc_sync_time; //use this to start hunting for CC after signal lost
   time_t last_vc_sync_time; //flag for voice activity bursts, tune back on con+ after more than x seconds no voice
+  time_t last_active_time; //time the a 'call grant' was received, used to clear the active_channel strings after x seconds
   int is_con_plus; //con_plus flag for knowing its safe to skip payload channel after x seconds of no voice sync
 
   //new nxdn stuff
@@ -649,13 +674,21 @@ typedef struct
   uint8_t nxdn_sacch_frame_segcrc[4];
   uint8_t nxdn_alias_block_number;
   char nxdn_alias_block_segment[4][4][8];
+
   //site/srv/cch info
   char nxdn_location_category[14];
   uint32_t nxdn_location_sys_code;
   uint16_t nxdn_location_site_code;
 
-  //multi-key array for nxdn keys
-  unsigned long long int rkey_array[0x1FF];
+  //channel access information
+  uint8_t nxdn_rcn;
+  uint8_t nxdn_base_freq;
+  uint8_t nxdn_step;
+  uint8_t nxdn_bw;
+
+  //multi-key array
+  unsigned long long int rkey_array[0xFFFF];
+  int keyloader; //let us know the keyloader is active
 
   //dmr late entry mi
   uint64_t late_entry_mi_fragment[2][7][3];
@@ -728,6 +761,26 @@ typedef struct
 #define INV_PROVOICE_EA_SYNC "13313133113113333311313133133311"
 #define PROVOICE_EA_SYNC     "31131311331331111133131311311133"
 
+//define the provoice conventional string pattern to default 85/85 if not enabled, else mute it so we won't double sync on accident in frame_sync
+#ifdef PVCONVENTIONAL
+#define PROVOICE_CONV        "00000000000000000000000000000000" //all zeroes should be unobtainable string in the frame_sync synctests
+#define INV_PROVOICE_CONV    "00000000000000000000000000000000" //all zeroes should be unobtainable string in the frame_sync synctests
+#else
+#define PROVOICE_CONV        "13131333111311311313131313131313" //TX 85 RX 85 (default programming value)
+#define INV_PROVOICE_CONV    "31313111333133133131313131313131" //TX 85 RX 85 (default programming value)
+#endif
+//we use the short sync instead of the default 85/85 wnen PVCONVENTIONAL is defined by cmake
+#define PROVOICE_CONV_SHORT                 "1313133311131131" //16-bit short pattern, last 16-bits change based on TX an RX values
+#define INV_PROVOICE_CONV_SHORT             "3131311133313313"
+//In this pattern (inverted polarity, the norm for PV) 3 is bit 0, and 1 is bit 1 (2 level GFSK)
+                  //same pattern   //TX     //RX
+// Sync Pattern = 3131311133313313 31331131 31331131 TX/RX 77  -- 31331131 symbol = 01001101 binary = 77 decimal
+// Sync Pattern = 3131311133313313 33333333 33333333 TX/RX 0   -- 33333333 symbol = 00000000 binary = 0 decimal
+// Sync Pattern = 3131311133313313 33333331 33333331 TX/RX 1   -- 33333331 symbol = 00000001 binary = 1 decimal
+// Sync Pattern = 3131311133313313 13131133 13131133 TX/RX 172 -- 13131133 symbol = 10101100 binary = 172 decimal
+// Sync Pattern = 3131311133313313 11333111 11333111 TX/RX 199 -- 11333111 symbol = 11000111 binary = 199 decimal
+// Sync Pattern = 3131311133313313 31313131 31313131 TX/RX 85  -- 31313131 symbol = 01010101 binary = 85 decimal
+
 #define EDACS_SYNC      "313131313131313131313111333133133131313131313131"
 #define INV_EDACS_SYNC  "131313131313131313131333111311311313131313131313"
 
@@ -809,6 +862,9 @@ int getSymbol (dsd_opts * opts, dsd_state * state, int have_sync);
 void upsample (dsd_state * state, float invalue);
 void processDSTAR (dsd_opts * opts, dsd_state * state);
 
+//new p25lcw
+void p25_lcw (dsd_opts * opts, dsd_state * state, uint8_t LCW_bits[], uint8_t irrecoverable_errors);
+
 void processP25lcw (dsd_opts * opts, dsd_state * state, char *lcformat, char *mfid, char *lcinfo);
 void processHDU (dsd_opts * opts, dsd_state * state);
 void processLDU1 (dsd_opts * opts, dsd_state * state);
@@ -821,14 +877,14 @@ void processX2TDMAvoice (dsd_opts * opts, dsd_state * state);
 void processDSTAR_HD (dsd_opts * opts, dsd_state * state);
 void processYSF(dsd_opts * opts, dsd_state * state); //YSF
 void processP2(dsd_opts * opts, dsd_state * state); //P2
-void processTSBK(dsd_opts * opts, dsd_state * state);
+void processTSBK(dsd_opts * opts, dsd_state * state); //P25 Trunking Single Block
+void processMPDU(dsd_opts * opts, dsd_state * state); //P25 Multi Block PDU (SAP 0x61 FMT 0x15 or 0x17 for Trunking Blocks)
 short dmr_filter(short sample);
 short nxdn_filter(short sample);
 short dpmr_filter(short sample);
 
 int strncmperr(const char *s1, const char *s2, size_t size, int MaxErr);
-/* Global functions */ 
-uint32_t ConvertBitIntoBytes(uint8_t * BufferIn, uint32_t BitLength);
+uint64_t ConvertBitIntoBytes(uint8_t * BufferIn, uint32_t BitLength);
 
 void ncursesOpen (dsd_opts * opts, dsd_state * state);
 void ncursesPrinter (dsd_opts * opts, dsd_state * state);
@@ -837,10 +893,15 @@ void ncursesClose ();
 //new NXDN Functions start here!
 void nxdn_frame (dsd_opts * opts, dsd_state * state);
 void nxdn_descramble (uint8_t dibits[], int len);
+//nxdn deinterleaving/depuncturing functions
 void nxdn_deperm_facch (dsd_opts * opts, dsd_state * state, uint8_t bits[144]);
 void nxdn_deperm_sacch (dsd_opts * opts, dsd_state * state, uint8_t bits[60]);
 void nxdn_deperm_cac (dsd_opts * opts, dsd_state * state, uint8_t bits[300]);
-void nxdn_deperm_facch2_udch (dsd_opts * opts, dsd_state * state, uint8_t bits[348]);
+void nxdn_deperm_facch2_udch (dsd_opts * opts, dsd_state * state, uint8_t bits[348], uint8_t type);
+//type-d 'idas' deinterleaving/depuncturing functions
+void nxdn_deperm_scch(dsd_opts * opts, dsd_state * state, uint8_t bits[60], uint8_t direction);
+void nxdn_deperm_facch3_udch2(dsd_opts * opts, dsd_state * state, uint8_t bits[288], uint8_t type);
+//end
 void nxdn_message_type (dsd_opts * opts, dsd_state * state, uint8_t MessageType);
 void nxdn_voice (dsd_opts * opts, dsd_state * state, int voice, uint8_t dbuf[182]);
 
@@ -850,6 +911,7 @@ static uint8_t crc6(const uint8_t buf[], int len);
 static uint16_t crc12f(const uint8_t buf[], int len);
 static uint16_t crc15(const uint8_t buf[], int len);
 static uint16_t crc16cac(const uint8_t buf[], int len);
+static uint8_t crc7_scch(uint8_t bits[], int len); //converted from op25 crc6
 
 /* NXDN Convolution functions */
 void CNXDNConvolution_start(void);
@@ -872,7 +934,9 @@ void NXDN_decode_VCALL_ASSGN(dsd_opts * opts, dsd_state * state, uint8_t * Messa
 void NXDN_decode_cch_info(dsd_opts * opts, dsd_state * state, uint8_t * Message);
 void NXDN_decode_srv_info(dsd_opts * opts, dsd_state * state, uint8_t * Message);
 void NXDN_decode_site_info(dsd_opts * opts, dsd_state * state, uint8_t * Message);
-void nxdn_location_id_handler (dsd_state * state, uint32_t location_id);
+void NXDN_decode_adj_site(dsd_opts * opts, dsd_state * state, uint8_t * Message);
+//Type-D SCCH Message Decoder
+void NXDN_decode_scch(dsd_opts * opts, dsd_state * state, uint8_t * Message, uint8_t direction);
 
 void dPMRVoiceFrameProcess(dsd_opts * opts, dsd_state * state);
 
@@ -926,11 +990,12 @@ void dmrMSData (dsd_opts * opts, dsd_state * state);
 void dmrMSBootstrap (dsd_opts * opts, dsd_state * state);
 
 //dmr data header and multi block types (header, 1/2, 3/4, 1, Unified)
-void dmr_dheader (dsd_opts * opts, dsd_state * state, uint8_t dheader[], uint32_t CRCCorrect, uint32_t IrrecoverableErrors);
+void dmr_dheader (dsd_opts * opts, dsd_state * state, uint8_t dheader[], uint8_t dheader_bits[], uint32_t CRCCorrect, uint32_t IrrecoverableErrors);
 void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_bytes[], uint8_t block_len, uint8_t databurst, uint8_t type);
 void dmr_pdu (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR_PDU[]);
 void dmr_reset_blocks (dsd_opts * opts, dsd_state * state);
-uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR_PDU[]);
+void dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR_PDU[]);
+void dmr_locn (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR_PDU[]);
 
 //dmr alg stuff
 void dmr_alg_reset (dsd_opts * opts, dsd_state * state);
@@ -947,9 +1012,12 @@ uint8_t crc8(uint8_t bits[], unsigned int len);
 bool crc8_ok(uint8_t bits[], unsigned int len);
 uint8_t crc7(uint8_t bits[], unsigned int len);
 
-//LFSR code courtesy of https://github.com/mattames/LFSR/
+//LFSR and LFSRP code courtesy of https://github.com/mattames/LFSR/
 void LFSR(dsd_state * state);
+void LFSRP(dsd_state * state);
+
 void LFSRN (char * BufferIn, char * BufferOut, dsd_state * state);
+void LFSR64(dsd_state * state);
 
 void Hamming_7_4_init();
 void Hamming_7_4_encode(unsigned char *origBits, unsigned char *encodedBits);
@@ -989,6 +1057,7 @@ bool QR_16_7_6_decode(unsigned char *rxBits);
 
 void InitAllFecFunction(void);
 void resetState (dsd_state * state);
+void reset_dibit_buffer(dsd_state * state);
 void dstar_header_decode(dsd_state * state, int radioheaderbuffer[660]);
 
 //P25 PDU Handler
@@ -1034,7 +1103,8 @@ unsigned long long int edacs_bch (unsigned long long int message);
 int csvGroupImport(dsd_opts * opts, dsd_state * state);
 int csvLCNImport(dsd_opts * opts, dsd_state * state);
 int csvChanImport(dsd_opts * opts, dsd_state * state);
-int csvKeyImport(dsd_opts * opts, dsd_state * state);
+int csvKeyImportDec(dsd_opts * opts, dsd_state * state);
+int csvKeyImportHex(dsd_opts * opts, dsd_state * state);
 
 #ifdef __cplusplus
 extern "C" {
@@ -1045,6 +1115,9 @@ void open_rtlsdr_stream(dsd_opts *opts);
 void cleanup_rtlsdr_stream();
 void get_rtlsdr_sample(int16_t *sample, dsd_opts * opts, dsd_state * state);
 void rtlsdr_sighandler();
+void rtl_dev_tune(dsd_opts * opts, long int frequency);
+int rtl_return_rms();
+void rtl_clean_queue();
 #endif
 //DMR TRELLIS
 void CDMRTrellisTribitsToBits(const unsigned char* tribits, unsigned char* payload);

rebuild.sh

@@ -0,0 +1,16 @@
+#! /bin/bash
+clear
+echo DSD-FME Digital Speech Decoder - Florida Man Edition
+echo Automatic Git Pull and Rebuild
+echo 
+sleep 1
+##Open your clone folder##
+git pull
+sleep 2
+##cd into your build folder##
+cd build
+cmake ..
+make -j `nproc`
+sudo make install
+sudo ldconfig
+

src/dmr_block.c

@@ -8,292 +8,416 @@
 
 #include "dsd.h"
 
-void dmr_dheader (dsd_opts * opts, dsd_state * state, uint8_t dheader[], uint32_t CRCCorrect, uint32_t IrrecoverableErrors)
+//hopefully a more simplified (or logical) version...once you get past all the variables
+void dmr_dheader (dsd_opts * opts, dsd_state * state, uint8_t dheader[], uint8_t dheader_bits[], uint32_t CRCCorrect, uint32_t IrrecoverableErrors)
 {
+  
   uint32_t i, j, k;
   uint8_t slot = state->currentslot;
 
   //clear out unified pdu 'superframe' slot
-  for (short int i = 0; i < 288; i++) 
-  {
-    state->dmr_pdu_sf[slot][i] = 0;
-  }
+  for (short int i = 0; i < 288; i++) state->dmr_pdu_sf[slot][i] = 0;
 
-  //TODO: ONLY RUN ON GOOD CRC?
+  //reset block counter to 1
+  state->data_block_counter[slot] = 1;
 
-  //collect relevant data header info, figure out format, and grab appropriate info from it
-  if (state->data_p_head[slot] == 0)
+  if (IrrecoverableErrors == 0 && CRCCorrect == 1) //&&CRCCorrect == 1
   {
+
+    uint8_t gi = dheader_bits[0]; //group or individual data
+    uint8_t a  = dheader_bits[1]; //response requested flag
+    uint8_t ab = (uint8_t)ConvertBitIntoBytes(&dheader_bits[2], 2); //appended blocks
+    uint8_t dpf = (uint8_t)ConvertBitIntoBytes(&dheader_bits[4], 4); //data packet format
+    uint8_t sap = (uint8_t)ConvertBitIntoBytes(&dheader_bits[8], 4); //service access point
+    uint8_t poc = (uint8_t)ConvertBitIntoBytes(&dheader_bits[8], 4); //padding octets
+    
+    uint32_t target = (uint32_t)ConvertBitIntoBytes(&dheader_bits[16], 24); //destination llid 
+    uint32_t source = (uint32_t)ConvertBitIntoBytes(&dheader_bits[40], 24); //source llid
+
+    //extra tgt/src handling for XPT 
+    uint8_t target_hash[24]; 
+    uint8_t tg_hash = 0;
+    uint8_t is_xpt = 0;
+    //set flag if XPT
+    if (strcmp (state->dmr_branding_sub, "XPT ") == 0) is_xpt = 1;
+
+    //truncate tgt/src to 16-bit values if XPT
+    if (is_xpt == 1)
+    {
+      target = (uint32_t)ConvertBitIntoBytes(&dheader_bits[24], 16); //destination llid 
+      source = (uint32_t)ConvertBitIntoBytes(&dheader_bits[48], 16); //source llid
+      if (gi == 0) 
+      {
+        for (int i = 0; i < 16; i++) target_hash[i] = dheader_bits[24+i];
+        tg_hash = crc8 (target_hash, 16);
+      }
+    }
+
+    uint8_t is_cap = 0;
+    if (strcmp (state->dmr_branding_sub, "Cap+ ") == 0) is_cap = 1;
+
+    if (is_cap)
+    {
+      //truncate tg on group? or just on private/individual data?
+      if (gi == 0) target = (uint32_t)ConvertBitIntoBytes(&dheader_bits[24], 16);
+      source = (uint32_t)ConvertBitIntoBytes(&dheader_bits[48], 16);
+    }
+
+    //store source for dmr pdu packet handling (lrrp) when not available in completed message
+    if (dpf != 15) state->dmr_lrrp_source[slot] = source;
+
+    //set dpf to storage for later use (UDT, SD, etc)
+    state->data_header_format[slot] = dpf; 
+
+    //Type Strings
+    char sap_string[20];
+    char mfid_string[20];
+    char udtf_string[20];
+    char sddd_string[20];
+    sprintf (sap_string, "%s", "");
+    sprintf (mfid_string, "%s", "");
+    sprintf (udtf_string, "%s", "");
+    sprintf (sddd_string, "%s", "");
+
+    //see 9.3 - ETSI TS 102 361-1 V2.5.1 (2017-10) for more info
+    uint8_t f  = dheader_bits[64]; //F -- Full message flag (F)
+    uint8_t bf = (uint8_t)ConvertBitIntoBytes(&dheader_bits[65], 7); //Blocks to Follow (BF)
+
+    //confirmed data header
+    uint8_t s   = dheader_bits[72]; //S -- Re-Synchronize Flag
+    uint8_t ns  = (uint8_t)ConvertBitIntoBytes(&dheader_bits[73], 3); //N(S) -- send sequence number
+    uint8_t fsn = (uint8_t)ConvertBitIntoBytes(&dheader_bits[76], 4); //Fragment Sequence Number (FSN)
+
+    //response header
+    uint8_t r_class  = (uint8_t)ConvertBitIntoBytes(&dheader_bits[72], 2);
+    uint8_t r_type   = (uint8_t)ConvertBitIntoBytes(&dheader_bits[74], 3);
+    uint8_t r_status = (uint8_t)ConvertBitIntoBytes(&dheader_bits[77], 3);
+
+    //short data - status/precoded
+    uint8_t s_ab_msb = (uint8_t)ConvertBitIntoBytes(&dheader_bits[2], 2); //appended block, msb
+    uint8_t s_ab_lsb = (uint8_t)ConvertBitIntoBytes(&dheader_bits[12], 4);//appended block, lsb
+    uint8_t s_ab_fin = (s_ab_msb << 2) | s_ab_lsb; //appended blocks, final value
+    uint8_t s_source_port = (uint8_t)ConvertBitIntoBytes(&dheader_bits[64], 3);
+    uint8_t s_dest_port = (uint8_t)ConvertBitIntoBytes(&dheader_bits[67], 3);
+    uint8_t s_status_precoded = (uint8_t)ConvertBitIntoBytes(&dheader_bits[70], 10);
+
+    //short data - raw
+    uint8_t sd_sarq = dheader_bits[70]; //Selective Automatic Repeat reQuest
+    uint8_t sd_f = dheader_bits[71];   //full message flag
+    uint8_t sd_bp = (uint8_t)ConvertBitIntoBytes(&dheader_bits[72], 8); //bit padding
+
+    //short data - defined
+    uint8_t dd_format = (uint8_t)ConvertBitIntoBytes(&dheader_bits[64], 6);
+
+    //Unified Data Transport (UDT)
+    uint8_t udt_format = (uint8_t)ConvertBitIntoBytes(&dheader_bits[12], 4);
+    uint8_t udt_padnib = (uint8_t)ConvertBitIntoBytes(&dheader_bits[64], 5);
+    uint8_t udt_uab = (uint8_t)ConvertBitIntoBytes(&dheader_bits[70], 2); //udt appended blocks
+    uint8_t udt_sf = dheader_bits[72];
+    uint8_t udt_pf = dheader_bits[73];
+    uint8_t udt_op = (uint8_t)ConvertBitIntoBytes(&dheader_bits[74], 6);
+
+    //p_head
+    uint8_t p_sap  = (uint8_t)ConvertBitIntoBytes(&dheader_bits[0], 4);
+    uint8_t p_mfid = (uint8_t)ConvertBitIntoBytes(&dheader_bits[8], 8);
+    uint8_t p_pot  = (uint8_t)ConvertBitIntoBytes(&dheader_bits[3], 5); //looking for LRRP pot_report
+
     fprintf (stderr, "%s ", KGRN);
-    state->data_block_counter[slot] = 1; //reset block counter to 1
-    state->data_header_format[slot] = dheader[0]; //collect the entire byte, we can check group or individual, response requested as well on this
-    state->data_header_sap[slot] = (dheader[1] & 0xF0) >> 4; 
+    fprintf (stderr, "\n");
+    fprintf (stderr, " Slot %d Data Header - ", slot+1);
 
-    if ( (state->data_header_format[slot] & 0xF) ==  0x2)
+    if (gi == 1 && dpf != 15) fprintf(stderr, "Group - ");
+    if (gi == 0 && dpf != 15) fprintf(stderr, "Indiv - ");
+    
+    if (dpf == 0)       fprintf (stderr, "Unified Data Transport (UDT) ");
+    else if (dpf == 1)  fprintf (stderr, "Response Packet ");
+    else if (dpf == 2)  fprintf (stderr, "Unconfirmed Delivery ");
+    else if (dpf == 3)  fprintf (stderr, "Confirmed Delivery ");
+    else if (dpf == 13) fprintf (stderr, "Short Data: Defined ");
+    else if (dpf == 14) fprintf (stderr, "Short Data: Raw or S/P ");
+    else if (dpf == 15) fprintf (stderr, "Proprietary Packet Data");
+    else fprintf (stderr, "Reserved/Unknown DPF %X ", dpf);
+
+    if (a == 1 && dpf != 15) fprintf(stderr, "- Response Requested ");
+    if (dpf != 15) fprintf (stderr, "- Source: %d Target: %d ", source, target);
+
+    //include the hash value if this is an XPT and if its IND data
+    if (dpf != 15 && is_xpt == 1 && gi == 0) fprintf (stderr, "Hash: %d ", tg_hash);
+
+    //sap string handling
+    if (dpf == 15) sap = p_sap;
+
+    if      (sap == 0)  sprintf (sap_string, "%s", "UDT Data"); //apparently, both dpf and sap for UDT is 0
+    else if (sap == 2)  sprintf (sap_string, "%s", "TCP Comp"); //TCP/IP header compression
+    else if (sap == 3)  sprintf (sap_string, "%s", "UDP Comp"); //UDP/IP header compression
+    else if (sap == 4)  sprintf (sap_string, "%s", "IP Based"); //IP based Packet Data
+    else if (sap == 5)  sprintf (sap_string, "%s", "ARP Prot"); //Address Resoution Protocol (ARP)
+    else if (sap == 9)  sprintf (sap_string, "%s", "Prop PDU"); //Proprietary Packet Data
+    else if (sap == 10) sprintf (sap_string, "%s", "Short DT"); //Short Data
+    else                sprintf (sap_string, "%s", "Reserved"); //reserved, or err/unk
+
+    //mfid string handling
+    if (dpf == 15)
     {
-      state->data_conf_data[slot] = 0; //flag as unconfirmed data, no need for additional CRC/Serial checks
-      state->data_header_padding[slot] = dheader[1] & 0xF; //number of padding octets on last block
-      state->data_header_blocks[slot] = dheader[8] & 0x7F; //number of blocks to follow, most useful for when to poll the super array for data
-      fprintf (stderr, "\n  Unconfirmed Data Header: DPF %01X - SAP %02X - Block Count %02X - Padding Octets %02X",
-               state->data_header_format[slot] & 0xF, state->data_header_sap[slot],
-               state->data_header_blocks[slot], state->data_header_padding[slot] );
+      if      (p_mfid == 0x10) sprintf (mfid_string, "%s", "Motorola");
+      else if (p_mfid == 0x58) sprintf (mfid_string, "%s", "Tait");
+      else if (p_mfid == 0x68) sprintf (mfid_string, "%s", "Hytera");
+      else if (p_mfid == 0x08) sprintf (mfid_string, "%s", "Hytera");
+      else if (p_mfid == 0x06) sprintf (mfid_string, "%s", "Trid/Mot"); 
+      else if (p_mfid == 0x00) sprintf (mfid_string, "%s", "Standard"); 
+      else                     sprintf (mfid_string, "%s", "Other");
     }
 
-    if ( (state->data_header_format[slot] & 0xF) ==  0x3)
+    //udt format string handling
+    if (dpf == 0)
     {
-      state->data_conf_data[slot] = 1; //set flag to indicate the following blocks are confirmed data so we know to run additional CRC etc on it.
-      state->data_header_padding[slot] = dheader[1] & 0xF; //number of padding octets on last block
-      state->data_header_blocks[slot] = dheader[8] & 0x7F; //number of blocks to follow, most useful for when to poll the super array for data
-      fprintf (stderr, "\n  Confirmed Data Header: DPF %01X - SAP %02X - Block Count %02X - Padding Octets %02X",
-               state->data_header_format[slot] & 0xF, state->data_header_sap[slot],
-               state->data_header_blocks[slot], state->data_header_padding[slot] );
+      if      (udt_format == 0x00) sprintf (udtf_string, "%s", "Binary");
+      else if (udt_format == 0x01) sprintf (udtf_string, "%s", "MS/TG Adr");
+      else if (udt_format == 0x02) sprintf (udtf_string, "%s", "4-bit BCD");
+      else if (udt_format == 0x03) sprintf (udtf_string, "%s", "ISO7 Char");
+      else if (udt_format == 0x04) sprintf (udtf_string, "%s", "ISO8 Char"); 
+      else if (udt_format == 0x05) sprintf (udtf_string, "%s", "NMEA LOCN"); 
+      else if (udt_format == 0x06) sprintf (udtf_string, "%s", "IP Addr");
+      else if (udt_format == 0x07) sprintf (udtf_string, "%s", "UTF-16");    //16-bit Unicode Chars
+      else if (udt_format == 0x08) sprintf (udtf_string, "%s", "Manu Spec"); //Manufacturer Specific
+      else if (udt_format == 0x09) sprintf (udtf_string, "%s", "Manu Spec"); //Manufacturer Specific
+      else if (udt_format == 0x0A) sprintf (udtf_string, "%s", "Mixed UTF"); //Appended block contains addr and 16-bit UTF-16BE
+      else                         sprintf (udtf_string, "%s", "Reserved");
     }
 
-    if ( (state->data_header_format[slot] & 0xF) ==  0xD) //DD_HEAD
+    //short data dd_head format string
+    if (dpf == 13)
     {
-      //The Response Requested (A) information element of the header shall be set to 0 for unconfirmed data and shall be set
-      //to 1 for confirmed data. ETSI TS 102 361-3 V1.2.1 (2013-07) - 6.1.2
-      if ( (state->data_header_format[slot] & 0x40) == 0x40 && state->data_p_head[slot] == 0) //check response req bit
+      if      (dd_format == 0x00) sprintf (sddd_string, "%s", "Binary");
+      else if (dd_format == 0x01) sprintf (sddd_string, "%s", "BCD   ");
+      else if (dd_format == 0x02) sprintf (sddd_string, "%s", "7-bit Char");
+      else if (dd_format == 0x03) sprintf (sddd_string, "%s", "IEC 8859-1");
+      else if (dd_format == 0x04) sprintf (sddd_string, "%s", "IEC 8859-2");
+      else if (dd_format == 0x05) sprintf (sddd_string, "%s", "IEC 8859-3");
+      else if (dd_format == 0x06) sprintf (sddd_string, "%s", "IEC 8859-4");
+      else if (dd_format == 0x07) sprintf (sddd_string, "%s", "IEC 8859-5");
+      else if (dd_format == 0x08) sprintf (sddd_string, "%s", "IEC 8859-6");
+      else if (dd_format == 0x09) sprintf (sddd_string, "%s", "IEC 8859-7");
+      else if (dd_format == 0x0A) sprintf (sddd_string, "%s", "IEC 8859-8");
+      else if (dd_format == 0x0B) sprintf (sddd_string, "%s", "IEC 8859-9");
+      else if (dd_format == 0x0C) sprintf (sddd_string, "%s", "IEC 8859-10");
+      else if (dd_format == 0x0D) sprintf (sddd_string, "%s", "IEC 8859-11"); 
+      else if (dd_format == 0x0E) sprintf (sddd_string, "%s", "IEC 8859-13"); //there is no 8059-12
+      else if (dd_format == 0x0F) sprintf (sddd_string, "%s", "IEC 8859-14");
+      else if (dd_format == 0x10) sprintf (sddd_string, "%s", "IEC 8859-15");
+      else if (dd_format == 0x11) sprintf (sddd_string, "%s", "IEC 8859-16");
+      else if (dd_format == 0x12) sprintf (sddd_string, "%s", "UTF-8   ");
+      else if (dd_format == 0x13) sprintf (sddd_string, "%s", "UTF-16  ");
+      else if (dd_format == 0x14) sprintf (sddd_string, "%s", "UTF-16BE");
+      else if (dd_format == 0x15) sprintf (sddd_string, "%s", "UTF-16LE");
+      else if (dd_format == 0x16) sprintf (sddd_string, "%s", "UTF-32  ");
+      else if (dd_format == 0x17) sprintf (sddd_string, "%s", "UTF-32BE");
+      else if (dd_format == 0x18) sprintf (sddd_string, "%s", "UTF-32LE");
+      else                        sprintf (sddd_string, "%s", "Reserved");
+    }
+
+    if (dpf == 0) //UDT
+    {
+      //UDT packet info -- samples needed for testing
+      //NOTE: This format's completed message has a CRC16 - like MBC - but has number of blocks (appended blocks) like R 1/2, etc.
+      fprintf (stderr, "\n  SAP %02X [%s] - FMT %d [%s] - PDn %d - BLOCKS %d SF %d - PF %d OP %02X", sap, sap_string, udt_format, udtf_string, udt_padnib, udt_uab, udt_sf, udt_pf, udt_op);
+
+      //set number of blocks to follow (appended blocks) for block assembler
+      state->data_header_blocks[slot] = udt_uab;
+
+      //set data header to valid
+      state->data_header_valid[slot] = 1;
+
+      //send to assembler as type 3, rearrange into CSBK type PDU (to verify), and send to dmr_cspdu
+      dmr_block_assembler (opts, state, dheader, 12, 0x0B, 3);
+
+    }
+
+    if (dpf == 1) //response data packet header
+    {
+      //mostly fleshed out response packet info
+      fprintf (stderr, "\n  SAP %02X [%s] - Class %d - Type %0d - ", sap, sap_string, r_class, r_type);
+      if (r_class == 0 && r_type == 1) fprintf (stderr, "ACK - Success");
+      if (r_class == 1)
       {
-        state->data_conf_data[slot] = 1; 
+        fprintf (stderr, "NACK - ");
+        if (r_type == 0) fprintf (stderr, "Illegal Format");
+        if (r_type == 1) fprintf (stderr, "Illegal Format");
+        if (r_type == 2) fprintf (stderr, "Packet CRC ERR");
+        if (r_type == 3) fprintf (stderr, "Memory Full");
+        if (r_type == 4) fprintf (stderr, "FSN Out of Seq");
+        if (r_type == 5) fprintf (stderr, "Undeliverable");
+        if (r_type == 6) fprintf (stderr, "PKT Out of Seq");
+        if (r_type == 7) fprintf (stderr, "Invalid User");
       }
-      else state->data_conf_data[slot] = 0;
+      if (r_class == 2) fprintf (stderr, "SACK - Retry");
+      if (r_status) fprintf (stderr, " - %d", r_status); //the object/value of the ack/nack/sack
 
-      state->data_header_padding[slot] = dheader[7] & 0xF;
-      state->data_header_blocks[slot] = ( (dheader[0] & 0x30) | ((dheader[1] & 0xF) >> 0) ); //what a pain MSB | LSB
-      fprintf (stderr, "\n  Short Data - Defined: DPF %01X - SAP %02X - Appended Blocks %02X - Padding Bits %02X",
-               state->data_header_format[slot] & 0xF, state->data_header_sap[slot],
-               state->data_header_blocks[slot], state->data_header_padding[slot] );
     }
 
-    if ( (state->data_header_format[slot] & 0xF) ==  0xE) //SP_HEAD or R_HEAD
+    //Confirmed or Unconfirmed Data Packets Header
+    if (dpf == 2 || dpf == 3) 
     {
-      //The Response Requested (A) information element of the header shall be set to 0 for unconfirmed data and shall be set
-      //to 1 for confirmed data. ETSI TS 102 361-3 V1.2.1 (2013-07) - 6.2.2
-      if ( (state->data_header_format[slot] & 0x40) == 0x40 && state->data_p_head[slot] == 0) //check response req bit
+      if (dpf == 2) fprintf (stderr, "\n  SAP %02X [%s] - FMF %d - BLOCKS %02d - PAD %02d - FSN %d", sap, sap_string, f, bf, poc, fsn);
+      if (dpf == 3) fprintf (stderr, "\n  SAP %02X [%s] - FMF %d - BLOCKS %02d - PAD %02d - S %d - NS %d - FSN %d", sap, sap_string, f, bf, poc, s, ns, fsn);
+      state->data_header_blocks[slot] = bf;
+      if (dpf == 3) state->data_conf_data[slot] = 1; //set confirmed data delivery flag for additional CRC checks, block assembly, etc.
+
+    }
+
+    //Short Data DD_Head (13), and R_Head or SP_Head (14)
+    if (dpf == 13 || dpf == 14) 
+    {
+      //only set if not all zeroes
+      if (s_ab_fin) state->data_header_blocks[slot] = s_ab_fin;
+
+      //Short Data: Defined
+      if (dpf == 13) fprintf (stderr, "\n  SD:D [DD_HEAD] - SAP %02d [%s] - BLOCKS %02d - DD %02X - PADb %d - FMT %02X [%s]", sap, sap_string, s_ab_fin, dd_format, sd_bp, dd_format, sddd_string);
+      //Short Data: Raw or S/P
+      if (dpf == 14)
       {
-        state->data_conf_data[slot] = 1; 
+        //S/P has all appended block bits set to zero -- any other way to tell difference?
+        if (s_ab_fin == 0) fprintf (stderr, "\n  SD:S/P [SP_HEAD] - SAP %02d [%s] - SP %02d - DP %02d - S/P %02X", sap, sap_string, s_source_port, s_dest_port, s_status_precoded);
+
+        //Raw
+        else fprintf (stderr, "\n  SD:RAW [R_HEAD] - SAP %02d [%s] - BLOCKS %02d - SP %02d - DP %02d - SARQ %d - FMF %d - PDb %d", sap, sap_string, s_ab_fin, s_source_port, s_dest_port, sd_sarq, sd_f, sd_bp);
       }
-      else state->data_conf_data[slot] = 0;
 
-      state->data_header_padding[slot] = dheader[7] & 0xF;
-      state->data_header_blocks[slot] = ( (dheader[0] & 0x30) | ((dheader[1] & 0xF) >> 0) ); 
-      fprintf (stderr, "\n  Short Data - Raw or Precoded: DPF %01X - SAP %02X - Appended Blocks %02X - Padding Bits %02X",
-               state->data_header_format[slot] & 0xF, state->data_header_sap[slot],
-               state->data_header_blocks[slot], state->data_header_padding[slot] );
+      //6.2.2 The Response Requested (A) information element of the header shall be set to 0 
+      //for unconfirmed data and shall be set to 1 for confirmed data. DD_HEAD, R_HEAD, or SP_HEAD (double check)
+      if (a == 1)
+      {
+        state->data_conf_data[slot] = 1;
+        fprintf (stderr, " - Confirmed Data");
+      } 
+
     }
-
-
-  }
-
-  //do we still need this? since we have ample PDU storage
-  if (state->data_header_blocks[slot] > 7)
-  {
-    state->data_header_blocks[slot] = 7;
-  }
-
-  fprintf (stderr, "%s ", KNRM);
-  //end collecting data header info
-
-  fprintf (stderr, "%s ", KYEL);
-
-  if (state->data_header_sap[slot] == 0x4 && state->data_p_head[slot] == 0) 
-  {
-    fprintf (stderr, "\n  IP Data - Source: ");
-    fprintf (stderr, "[%d]", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7] );
-    fprintf (stderr, " Destination: ");
-    fprintf (stderr, "[%d]", (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4] );
-
-    state->dmr_lrrp_source[slot] = (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7];
-
-    //Remus! Uncomment these line
-    // if ( (state->data_header_format[slot] & 0xF ) != 0x1 && state->data_p_head[slot] == 0)
-    //   sprintf (state->dmr_lrrp_gps[slot], "IP DATA SRC [%d] DST [%d] ", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7], (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4]); 
-
-  }
-
-  if (state->data_header_sap[slot] == 0x0 && state->data_p_head[slot] == 0) 
-  {
-    fprintf (stderr, "\n  Unified Data Transport - Source: ");
-    fprintf (stderr, "[%d]", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7] );
-    fprintf (stderr, " Destination: ");
-    fprintf (stderr, "[%d]", (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4] );
-
-    state->dmr_lrrp_source[slot] = (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7];
-
-    //Remus! Uncomment these line
-    // if ( (state->data_header_format[slot] & 0xF ) != 0x1 && state->data_p_head[slot] == 0)
-    //   sprintf (state->dmr_lrrp_gps[slot], "UDT SRC [%d] DST [%d] ", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7], (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4]); 
-
-  }
-
-  if (state->data_header_sap[slot] == 0x9 && state->data_p_head[slot] == 0) 
-  {
-    fprintf (stderr, "\n  Proprietary Packet Data - Source: ");
-    fprintf (stderr, "[%d]", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7] );
-    fprintf (stderr, " Destination: ");
-    fprintf (stderr, "[%d]", (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4] );
-
-    state->dmr_lrrp_source[slot] = (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7];
-
-    //Remus! Uncomment this line
-    // sprintf (state->dmr_lrrp_gps[slot], "P_HEAD SRC [%d] DST [%d] ", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7], (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4]); 
-
-  }
-
-  if (state->data_header_sap[slot] == 0x2 && state->data_p_head[slot] == 0) 
-  {
-    fprintf (stderr, "\n  TCP/IP Header Compression Data - Source: ");
-    fprintf (stderr, "[%d]", dheader[3]);
-    fprintf (stderr, " Destination: ");
-    fprintf (stderr, "[%d]", dheader[2]);
-
-    state->dmr_lrrp_source[slot] = dheader[3];
-
-    //Remus! Uncomment these line
-    // if ( (state->data_header_format[slot] & 0xF ) != 0x1 && state->data_p_head[slot] == 0)
-    //   sprintf (state->dmr_lrrp_gps[slot], "IPC SRC [%d] DST [%d] ", dheader[3], dheader[2]); 
-
-  }
-
-  if (state->data_header_sap[slot] == 0x3 && state->data_p_head[slot] == 0) 
-  {
-    fprintf (stderr, "\n  UDP/IP Header Compression Data - Source: ");
-    fprintf (stderr, "[%d]", dheader[3]);
-    fprintf (stderr, " Destination: ");
-    fprintf (stderr, "[%d]", dheader[2]);
-
-    state->dmr_lrrp_source[slot] = dheader[3];
-
-    //Remus! Uncomment these line
-    // if ( (state->data_header_format[slot] & 0xF ) != 0x1 && state->data_p_head[slot] == 0)
-    //   sprintf (state->dmr_lrrp_gps[slot], "UDP SRC [%d] DST [%d] ", dheader[3], dheader[2]);
-
-  }
-
-  if (state->data_header_sap[slot] == 0x5 && state->data_p_head[slot] == 0) 
-  {
-    fprintf (stderr, "\n  ARP - Address Resolution Protocol ");
-  }
-
-  if ( (state->data_header_format[slot] & 0xF ) == 0xD && state->data_p_head[slot] == 0) 
-  {
-    fprintf (stderr, "\n  Short Data - Defined - Source: ");
-    fprintf (stderr, "[%d]", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7] );
-    fprintf (stderr, " Destination: ");
-    fprintf (stderr, "[%d]", (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4] );
-
-    //Remus! Uncomment this line
-    // sprintf (state->dmr_lrrp_gps[slot], "SD-D SRC [%d] DST [%d] ", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7], (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4]); 
-
-  }
-
-  if ( (state->data_header_format[slot] & 0xF) == 0xE && state->data_p_head[slot] == 0) 
-  {
-    fprintf (stderr, "\n  Short Data - Raw or Status/Precoded - Source: ");
-    fprintf (stderr, "[%d]", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7] );
-    fprintf (stderr, " Destination: ");
-    fprintf (stderr, "[%d]", (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4] );
-
-    //Remus! Uncomment this line
-    // sprintf (state->dmr_lrrp_gps[slot], "SD-R/P SRC [%d] DST [%d] ", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7], (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4]); 
-
-  }
-
-  if ( (state->data_header_format[slot] & 0xF ) == 0x1 && state->data_p_head[slot] == 0)
-  {
-    fprintf (stderr, "\n  Response Packet - Source:  ");
-    fprintf (stderr, "[%d]", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7] );
-    fprintf (stderr, " Destination: ");
-    fprintf (stderr, "[%d]", (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4] );
-
-    //Remus! Uncomment these lines
-    // char rsp[90];
-    // sprintf (rsp, " - RSP SRC [%d] DST [%d] ", (dheader[5] <<16 ) + (dheader[6] << 8) + dheader[7], (dheader[2] <<16 ) + (dheader[3] <<8 ) + dheader[4]);
-    // strcat (state->dmr_lrrp_gps[slot], rsp);  
-
-  }
-
-  //Removed Dup UDT Message
-
-  if ( (state->data_header_format[slot] & 0x40) == 0x40 && state->data_p_head[slot] == 0) //check response req bit
-  {
-    fprintf (stderr, "\n  Response Requested - ");
-    fprintf (stderr, " Source:");
-    fprintf (stderr, " [%d]", (dheader[2] <<16 ) + (dheader[3] << 8) + dheader[4] );
-    fprintf (stderr, " Destination:");
-    fprintf (stderr, " [%d]", (dheader[5] <<16 ) + (dheader[6] <<8 ) + dheader[7] );
-
-    //Remus! Uncomment these lines
-    // char rsp[90];
-    // sprintf (rsp, "- RSP REQ ");
-    // strcat (state->dmr_lrrp_gps[slot], rsp);
-
-  }
-
-  //if proprietary header was flagged by the last data header, then process data differently
-  if (state->data_p_head[slot] == 1)
-  {
-    fprintf (stderr, "\n  Proprietary Data Header: SAP %01X - Format %01X - MFID %02X",
-             (dheader[0] & 0xF0) >> 4, dheader[0] & 0xF, dheader[1]       );
-
-    //state->data_p_head[slot] = 0; //disabling this, we can flag it off after processing pdu instead
-    state->data_header_sap[slot] = 0; //reset this to zero so we don't trip the condition below
-    state->data_block_counter[slot]++; //increment the counter since this counts against the data blocks
-
-    //set overarching manufacturer in use when non-standard feature id set is up
-    //if (dheader[1] != 0) state->dmr_mfid = dheader[1]; //diable, will only set in link control or csbk for now (random manufacturers getting set, bad decode? or random feature?)
-
-    //assign prop header pdu to 'superframe'
-    uint8_t blocks = state->data_header_blocks[slot] - 1;
-    for(i = 0; i < 12; i++)
+    
+    //Proprietary Data Header
+    if (dpf == 15) 
     {
-      state->dmr_pdu_sf[slot][i+(blocks*12)] = dheader[i];
+      fprintf (stderr, " - P_SAP %02d [%s] - MFID %02X [%s]", p_sap, sap_string, p_mfid, mfid_string);
+
+      //look for LRRP potential report 0x1F (may be others as well)
+      //this could just be a sap == 1, which is 'reserved', unsure (or maybe no actual correlation?)
+      if (p_sap != 1) state->data_header_blocks[slot]--; //decrement the blocks to follow count in order to pass CRC32 and properly assemble blocks
+      else //add block to start of the dmr_pdu_sf since it probably contains vital LRRP data (0x1F report) -- won't pass CRC32 either way
+      {
+        int blocks = state->data_header_blocks[slot]-1;
+        if (blocks < 1) blocks = 4; //safety value
+        if (blocks > 9) blocks = 9;
+        for(i = 0; i < 12; i++) state->dmr_pdu_sf[slot][i+(blocks*12)] = dheader[i];
+        state->data_block_counter[slot]++;
+        //no matter how you assemble this, with or without the p_head block(s), there is ALWAYS a CRC32 Failure
+        //even when it continues to pass on other SAP values, SAP 1 must have a different checksum?
+        //Users trying to get this will want to enable -F to bypass the CRC32 failure
+
+        //a recent discovery on a few systems and samples show the existence of multiple Prop Head Packets (how does that work)
+      }
+
     }
-  }
 
-  //only set this flag after everything else is processed
-  if (state->data_header_sap[slot] == 0x9 && state->data_p_head[slot] == 0) 
+    //block storage sanity
+    if (state->data_header_blocks[slot] > 9) state->data_header_blocks[slot] = 9;
+    //assuming we didn't receive the initial data header block on a p_head and then decremented it
+    //3 or 4 seems to be the average safe value
+    if (state->data_header_blocks[slot] < 1) state->data_header_blocks[slot] = 4; 
+    //set data header validity unless its a p_head (should be set prior, if received)
+    if (dpf != 15) state->data_header_valid[slot] = 1;
+
+    //REMUS! Uncomment these lines if desired
+    if (dpf != 15 && dpf != 1)
+    {
+      sprintf (state->dmr_lrrp_gps[slot], "Data Call - %s SRC [%d] DST [%d] ", sap_string, source, target);
+      if (a == 1) strcat (state->dmr_lrrp_gps[slot], "- RSP REQ ");
+    }
+
+    //REMUS! Uncomment these lines if desired -- if the data request data header is missing, though, this may keep accumulating
+    // if (dpf == 1)
+    // {
+    //   strcat (state->dmr_lrrp_gps[slot], "- RSP ");
+    //   if (r_class == 0) strcat (state->dmr_lrrp_gps[slot], "ACK - RX OK");
+    //   if (r_class == 1) strcat (state->dmr_lrrp_gps[slot], "NACK - RX ERR");
+    //   if (r_class == 2) strcat (state->dmr_lrrp_gps[slot], "SACK - RETRY");
+    
+    // }
+    //End REMUS Data string
+
+    //store SAP value
+    state->data_header_sap[slot] = sap;
+
+  } //End Irrecoverable Errors
+
+  if (IrrecoverableErrors != 0)
   {
-    fprintf (stderr, "\n  Proprietary Packet Data Incoming ");
-    state->data_p_head[slot] = 1; //flag that next data header will be a proprietary data header
+    state->data_header_valid[slot] = 0;
+    sprintf (state->dmr_lrrp_gps[slot], "%s", "");
+    state->data_p_head[slot] = 0;
+    state->data_conf_data[slot] = 0;
+    state->data_block_counter[slot] = 1; 
+    state->data_header_blocks[slot] = 1; 
+    state->data_header_format[slot] = 7;
+
   }
-  fprintf (stderr, "%s ", KNRM);
 
-  //let user know the data header may have errors
-  // fprintf (stderr, "%s", KRED);
-  // if (CRCCorrect == 1) ; //CRCCorrect 1 is good, else is bad CRC; no print on good
-  // else if(IrrecoverableErrors == 0) fprintf(stderr, " (FEC OK)");
-  // else fprintf(stderr, " (FEC/CRC ERR)");
-  // fprintf (stderr, "%s", KNRM);
+  fprintf (stderr, "%s", KNRM);
 
 }
 
+//convert UDT to a CSBK friendly PDU format
+void dmr_udt_cspdu_converter (dsd_opts * opts, dsd_state * state, uint8_t block_bytes[], uint8_t block_bits[], uint32_t CRCCorrect, uint32_t IrrecoverableErrors)
+{
+  int i, j;
+
+  //rearrange UDT data to a CSBK message format
+  uint8_t cs_byte[48]; //12 x 4, 2 bit AB should mean only 3 total appended blocks, so 4 all together (minus rearrangement)
+  memset (cs_byte, 0, sizeof (cs_byte));
+  uint8_t cs_bits[48*8];
+  memset (cs_bits, 0, sizeof (cs_bits));
+
+  cs_byte[0] = (uint8_t)ConvertBitIntoBytes(&block_bits[73], 7); //lb, pf and opcode byte
+  uint8_t udt_opcode = (uint8_t)ConvertBitIntoBytes(&block_bits[74], 6); //for observation testing
+  cs_byte[1] = 0; //set mfid to zero for now (may use custom value if needed later)
+  uint8_t udt_mfid = 0; //setting to zero
+
+  //should be 34 total (maximum) after removing tailing CRC16 (initial and last block)
+  for (i = 0; i < 34; i++) cs_byte[2+i] = block_bytes[12+i];
+
+  //bytes to bits
+  for(i = 0, j = 0; i < 36; i++, j+=8) //4 blocks max?
+  {
+    cs_bits[j + 0] = (cs_byte[i] >> 7) & 0x01;
+    cs_bits[j + 1] = (cs_byte[i] >> 6) & 0x01;
+    cs_bits[j + 2] = (cs_byte[i] >> 5) & 0x01;
+    cs_bits[j + 3] = (cs_byte[i] >> 4) & 0x01;
+    cs_bits[j + 4] = (cs_byte[i] >> 3) & 0x01;
+    cs_bits[j + 5] = (cs_byte[i] >> 2) & 0x01;
+    cs_bits[j + 6] = (cs_byte[i] >> 1) & 0x01;
+    cs_bits[j + 7] = (cs_byte[i] >> 0) & 0x01;
+  }
+
+  dmr_cspdu (opts, state, cs_bits, cs_byte, CRCCorrect, IrrecoverableErrors);
+  
+}
+
 //assemble the blocks as they come in, shuffle them into the unified dmr_pdu_sf
 void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_bytes[], uint8_t block_len, uint8_t databurst, uint8_t type)
 {
   int i, j, k;
   uint8_t lb = 0; //mbc last block
   uint8_t pf = 0; //mbc protect flag
-  // uint8_t is_conf_data = 0; //internal flag to see if type 1 blocks contain confirmed data crcs and serials
+
   uint8_t slot = state->currentslot; 
   int blocks; 
   uint8_t blockcounter = state->data_block_counter[slot];
   uint8_t block_num = state->data_header_blocks[slot];
 
-  //crc specific variables
-  // uint8_t len = 24; 
-  // uint8_t crclen = 32; //len of the crc32 (obviously)
-  // uint8_t start = 12; //starting position (+12 offset loaded up data header)
-  // uint8_t n = 12; //number of bytes per block
-
-  //TODO: CRC check on Header, Blocks and full frames as appropriate
   uint32_t CRCCorrect = 0;
   uint32_t CRCComputed = 0;
   uint32_t CRCExtracted = 0;
   uint32_t IrrecoverableErrors = 0; 
 
-  uint8_t dmr_pdu_sf_bits[8*8*50]; //give plenty of space so we don't go oob
+  uint8_t dmr_pdu_sf_bits[8*24*50]; //give plenty of space so we don't go oob
 
   //MBC Header and Block CRC
   uint8_t mbc_crc_good[2]; //header and blocks crc pass/fail local storage
@@ -302,20 +426,27 @@ void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_byte
   if (type == 1) blocks = state->data_header_blocks[slot] - 1; 
   if (type == 2) blocks = state->data_block_counter[slot];
 
+  //UDT Header and Block Check
+  uint8_t is_udt = 0;
+  if (type == 3)
+  {
+    blocks = state->data_block_counter[slot];
+    is_udt = 1;
+    type = 2;
+  }
+
   //sanity check, setting block_len and block values to sane numbers in case of missing header, else could overload array (crash) or print out
   if (blocks < 1) blocks = 1; //changed blocks from uint8_t to int
-  if (blocks > 8) blocks = 8;
+  if (blocks > 9) blocks = 9;
   if (block_len == 0) block_len = 18;
   if (block_len > 24) block_len = 24;
 
-  //WIP: CRC32 on Completed Message Working! CRC9 on 3/4 Working! CRC9 or 1/2 and 1 still need testing - type 1
-  //may/will still fail on p_head data and blocks
   if (type == 1)
   {
     //type 1 data block, shuffle method
-    for (j = 0; j < blocks; j++) //6
+    for (j = 0; j < blocks; j++) 
     {
-      for (i = 0; i < block_len; i++) //block_len
+      for (i = 0; i < block_len; i++) 
       {
         state->dmr_pdu_sf[slot][i+block_len*j] = state->dmr_pdu_sf[slot][i+block_len*(j+1)];
       }
@@ -325,8 +456,9 @@ void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_byte
     {
       state->dmr_pdu_sf[slot][i+(blocks*block_len)] = block_bytes[i]; 
     }
+
     //time to send the completed 'superframe' to the DMR PDU message handler
-    if (state->data_block_counter[slot] == state->data_header_blocks[slot])
+    if (state->data_block_counter[slot] == state->data_header_blocks[slot] && state->data_header_valid[slot] == 1)
     {
       //CRC32 on completed messages
       for(i = 0, j = 0; i < (block_num * block_len); i++, j+=8)
@@ -388,28 +520,77 @@ void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_byte
       //individual CRC9s are correct on confirmed data blocks (but we can confirm now that they are all good)
       if (CRCComputed == CRCExtracted) CRCCorrect = 1;
 
-      //test only running on good CRC or CRC/RAS bypass (aggressive_framesync)
-      if (CRCCorrect || opts->aggressive_framesync == 0) dmr_pdu (opts, state, block_len, state->dmr_pdu_sf[slot]);
+      //only run on good CRC or CRC/RAS bypass (aggressive_framesync == 0)
+      if (CRCCorrect || opts->aggressive_framesync == 0) 
+        dmr_pdu (opts, state, block_len, state->dmr_pdu_sf[slot]);
 
       if (CRCCorrect) ; //print nothing
       else
       {
         fprintf (stderr, "%s", KRED);
         fprintf (stderr, "\n Slot %d - Multi Block PDU Message CRC32 ERR", slot+1);
+
+        //debug print
+        // fprintf (stderr, " %X - %X", CRCExtracted, CRCComputed);
+
         fprintf (stderr, "%s", KNRM);
 
-        state->data_conf_data[slot] = 0; //flag off conf data flag
-        state->data_header_format[slot] = 0; //zero out so we don't keep ascii printing
-      } 
-    }
-  }
+      }
+
+      //Full Super Frame Type 1 - Payload Output
+      if (opts->payload == 1)
+      {
+        fprintf (stderr, "%s", KGRN);
+        fprintf (stderr, "\n Slot %d - Multi Block PDU Message\n  ", slot+1);
+        for (i = 0; i < ((blocks+1)*block_len); i++) 
+        {
+          fprintf (stderr, "[%02X]", state->dmr_pdu_sf[slot][i]);
+          if (i == 11 || i == 23 || i == 35 || i == 47 || i == 59 || i == 71 || i == 83 || i == 95) 
+          {
+            fprintf (stderr, "\n  "); 
+          }
+        }
+
+        //debug print
+        // fprintf (stderr, " CRC - EXT %X CMP %X", CRCExtracted, CRCComputed);
+
+        if (state->data_header_format[slot] == 13 || state->data_header_format[slot] == 14 || state->data_header_sap[slot] == 10)
+        {
+          fprintf (stderr, "%s", KCYN);
+          fprintf (stderr, "\n Short Data: ASCII \n"  );
+          for (i = 0; i < ((blocks+1)*block_len); i++)
+          {
+            if (state->dmr_pdu_sf[slot][i] <= 0x7E && state->dmr_pdu_sf[slot][i] >=0x20)
+            {
+              fprintf (stderr, "%c", state->dmr_pdu_sf[slot][i]);
+            }
+            else fprintf (stderr, " ");
+
+            if (i == 47 || i == 95) fprintf (stderr, "\n  ");
+          }
+            
+        }
+
+        fprintf (stderr, "%s ", KNRM);
+      }
+
+      //reset data header format storage
+      state->data_header_format[slot] = 7;
+      //flag off data header validity 
+      state->data_header_valid[slot] = 0; 
+      //flag off conf data flag
+      state->data_conf_data[slot] = 0;     
+
+    } //end completed sf
+
+  } //end type 1 blocks
   
 
-  //type 2 - MBC header and MBC continuation blocks
+  //type 2 - MBC and UDT header, MBC and UDT continuation blocks
   if (type == 2) 
   {
-    //sanity check (marginal signal, bad decodes, etc)
-    if (state->data_block_counter[slot] > 8) state->data_block_counter[slot] = 8;
+    //sanity check (marginal signal, bad decodes, etc) -- may go a little lower (find out max number of MBC blocks supported)
+    if (state->data_block_counter[slot] > 4) state->data_block_counter[slot] = 4;
 
     //Type 2 data block, additive method
     for (i = 0; i < block_len; i++)
@@ -422,9 +603,17 @@ void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_byte
     lb = block_bytes[0] >> 7; //last block flag
     pf = (block_bytes[0] >> 6) & 1;
 
-    if (lb == 1) //last block arrived, time to send to cspdu decoder
+    if (is_udt)
     {
-      for(i = 0, j = 0; i < 12*4; i++, j+=8) //
+      blocks = state->data_header_blocks[slot];
+      if (blocks == blockcounter) lb = 1; //double check
+      pf = 0; //flag off is set from bit in error
+    }
+
+    //last block arrived and we have a valid data header, time to send to cspdu decoder
+    if (lb == 1 && state->data_header_valid[slot] == 1) 
+    {
+      for(i = 0, j = 0; i < 12*4; i++, j+=8) //4 blocks max?
       {
         dmr_pdu_sf_bits[j + 0] = (state->dmr_pdu_sf[slot][i] >> 7) & 0x01;
         dmr_pdu_sf_bits[j + 1] = (state->dmr_pdu_sf[slot][i] >> 6) & 0x01;
@@ -436,10 +625,13 @@ void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_byte
         dmr_pdu_sf_bits[j + 7] = (state->dmr_pdu_sf[slot][i] >> 0) & 0x01;
       }
 
+      //check UDT PF
+      if (is_udt) pf = dmr_pdu_sf_bits[73];
+
       //CRC check on Header and full frames as appropriate (header crc already stored)
       //The 16 bit CRC in the header shall include the data carried by the header. 
       //The 16 bit CRC in the last block shall be performed on 
-      //all MBC blocks (conmbined) except the header block. <-- misleading statement, just like half the dmr manual
+      //all MBC blocks (conmbined) except the header block.
       
       mbc_crc_good[0] = state->data_block_crc_valid[slot][0];
       
@@ -454,15 +646,13 @@ void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_byte
       uint8_t mbc_block_bits[12*8*3];
       memset (mbc_block_bits, 0, sizeof(mbc_block_bits));
       //shift continuation blocks and last block into seperate array for crc check
-      for (i = 0; i < 12*8*3; i++)
+      for (i = 0; i < 12*8*3; i++) //only doing 3 blocks (4 minus the header)
       {
         mbc_block_bits[i] = dmr_pdu_sf_bits[i+96]; //skip mbc header
       }
 
       CRCComputed = ComputeCrcCCITT16d (mbc_block_bits, ((blocks+0)*96)-16 );
 
-      // fprintf (stderr, " \n  CRC EXT %X CRC CMP %X", CRCExtracted, CRCComputed);
-
       if (CRCComputed == CRCExtracted) mbc_crc_good[1] = 1;
 
       CRCCorrect = 0;
@@ -477,60 +667,51 @@ void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_byte
       else
       {
         fprintf (stderr, "%s", KRED);
-        fprintf(stderr, " (CRC ERR)");
+        fprintf (stderr, "\n Slot %d - Multi Block Control Message CRC16 ERR", slot+1);
+
+        //debug print
+        fprintf (stderr, " %X - %X", CRCExtracted, CRCComputed);
+
         fprintf (stderr, "%s", KNRM);
       }
 
       //cspdu will only act on any fid/opcodes if good CRC to prevent falsing on control signalling
-      dmr_cspdu (opts, state, dmr_pdu_sf_bits, state->dmr_pdu_sf[slot], CRCCorrect, IrrecoverableErrors);
+      if (!is_udt && !pf) dmr_cspdu (opts, state, dmr_pdu_sf_bits, state->dmr_pdu_sf[slot], CRCCorrect, IrrecoverableErrors);
 
-    }
-  }
+      //will need to reassemble partially before sending to dmr_pdu or dmr_cspdu for handling -- needs testing
+      if (is_udt && !pf) dmr_udt_cspdu_converter (opts, state, state->dmr_pdu_sf[slot], dmr_pdu_sf_bits, CRCCorrect, IrrecoverableErrors);
 
-  //Full Super Frame Type 1 - Debug Output
-  if (opts->payload == 1 && type == 1 && state->data_block_counter[slot] == state->data_header_blocks[slot]) 
-  {
-    fprintf (stderr, "%s", KGRN);
-    fprintf (stderr, "\n Slot %d - Multi Block PDU Message\n  ", slot+1);
-    for (i = 0; i < ((blocks+1)*block_len); i++) 
-    {
-      fprintf (stderr, "[%02X]", state->dmr_pdu_sf[slot][i]);
-      if (i == 11 || i == 23 || i == 35 || i == 47 || i == 59 || i == 71 || i == 83 || i == 95) 
+      //Full Super Frame MBC/UDT - Debug Output
+      if (opts->payload == 1)
       {
-        fprintf (stderr, "\n  "); 
+        fprintf (stderr, "%s", KGRN);
+        fprintf (stderr, "\n Slot %d - Multi Block Control Message\n  ", slot+1);
+        for (i = 0; i < ((blocks+1)*block_len); i++) 
+        {
+          fprintf (stderr, "[%02X]", state->dmr_pdu_sf[slot][i]);
+          if (i == 11 || i == 23 || i == 35 || i == 47 || i == 59 || i == 71 || i == 83 || i == 95) 
+          {
+            fprintf (stderr, "\n  "); 
+          }
+        }
+        fprintf (stderr, "%s", KRED);
+        if (mbc_crc_good[0] == 0) fprintf (stderr, "MBC/UDT Header CRC ERR ");
+        if (mbc_crc_good[1] == 0) fprintf (stderr, "MBC/UDT Blocks CRC ERR ");
+        if (pf) fprintf (stderr, "MBC/UDT Header/Blocks Protected ");
+        fprintf (stderr, "%s ", KNRM);
       }
-    }
 
-    //debug print
-    // fprintf (stderr, " CRC - EXT %X CMP %X", CRCExtracted, CRCComputed);
+    } //end last block flag on MBC
 
-    fprintf (stderr, "%s ", KNRM);
-  }
+  } //end type 2 (MBC Header and Continuation)
 
-  //Full Super Frame MBC - Debug Output
-  if (opts->payload == 1 && type == 2 && lb == 1)
+  //leave this seperate so we can reset/zero stuff in case the data header isn't valid, etc
+  //switched to an if-elseif-else so we could get the block counter increment on the end
+  //without having it in an akward position
+
+  //if the end of normal data header and blocks
+  if (type == 1 && state->data_block_counter[slot] == state->data_header_blocks[slot])
   {
-    fprintf (stderr, "%s", KGRN);
-    fprintf (stderr, "\n Slot %d - Multi Block Control Message\n  ", slot+1);
-    for (i = 0; i < ((blocks+1)*block_len); i++) 
-    {
-      fprintf (stderr, "[%02X]", state->dmr_pdu_sf[slot][i]);
-      if (i == 11 || i == 23 || i == 35 || i == 47 || i == 59 || i == 71 || i == 83 || i == 95) 
-      {
-        fprintf (stderr, "\n  "); 
-      }
-    }
-    fprintf (stderr, "%s", KRED);
-    if (mbc_crc_good[0] == 0) fprintf (stderr, "MBC Header CRC ERR ");
-    if (mbc_crc_good[1] == 0) fprintf (stderr, "MBC Blocks CRC ERR ");
-    fprintf (stderr, "%s ", KNRM);
-  }
-
-  state->data_block_counter[slot]++; //increment block counter
-
-  if (type == 2 && lb == 1)
-  {
-    state->data_block_counter[slot] = 0; //reset the block counter (MBCs)
 
     //clear out unified pdu 'superframe' slot
     for (short int i = 0; i < 288; i++)
@@ -538,23 +719,66 @@ void dmr_block_assembler (dsd_opts * opts, dsd_state * state, uint8_t block_byte
       state->dmr_pdu_sf[slot][i] = 0;
     }
 
-    state->data_block_crc_valid[slot][0] = 0; //Zero Out MBC Header Block CRC Valid
+    //Zero Out MBC Header Block CRC Valid
+    state->data_block_crc_valid[slot][0] = 0; 
+    //reset the block counter (data blocks)
+    state->data_block_counter[slot] = 1; 
+    //reset data header format storage
+    state->data_header_format[slot] = 7;
+    //flag off data header validity 
+    state->data_header_valid[slot] = 0; 
+    //flag off conf data flag
+    state->data_conf_data[slot] = 0; 
 
   }
 
+  //else if the end of MBC Header and Blocks
+  else if (type == 2 && lb == 1)
+  {
+
+    //clear out unified pdu 'superframe' slot
+    for (short int i = 0; i < 288; i++)
+    {
+      state->dmr_pdu_sf[slot][i] = 0;
+    }
+
+    //Zero Out MBC Header Block CRC Valid
+    state->data_block_crc_valid[slot][0] = 0; 
+    //reset the block counter (data blocks)
+    state->data_block_counter[slot] = 1; 
+    //reset data header format storage
+    state->data_header_format[slot] = 7;
+    //flag off data header validity 
+    state->data_header_valid[slot] = 0; 
+    //flag off conf data flag
+    state->data_conf_data[slot] = 0; 
+
+  }
+
+  //else increment block counter after sorting/shuffling blocks
+  else state->data_block_counter[slot]++;
+
 }
 
-//failsafe to clear old data header, block info, cach, in case of tact/emb/slottype failures and we
-//can no longer verify accurate data block reporting
+//failsafe to clear old data header, block info, cach, in case of tact/emb/slottype failures 
+//or tuning away and we can no longer verify accurate data block reporting
 void dmr_reset_blocks (dsd_opts * opts, dsd_state * state)
 {
   memset (state->data_p_head, 0, sizeof(state->data_p_head));
   memset (state->data_conf_data, 0, sizeof(state->data_conf_data));
   memset (state->dmr_pdu_sf, 0, sizeof(state->dmr_pdu_sf));
-  memset (state->data_block_counter, 0, sizeof(state->data_block_counter));
-  memset (state->data_header_blocks, 0, sizeof(state->data_header_blocks));
+  memset (state->data_block_counter, 1, sizeof(state->data_block_counter));
+  memset (state->data_header_blocks, 1, sizeof(state->data_header_blocks));
   memset (state->data_block_crc_valid, 0, sizeof(state->data_block_crc_valid));
   memset (state->dmr_lrrp_source, 0, sizeof(state->dmr_lrrp_source));
   memset (state->dmr_cach_fragment, 1, sizeof (state->dmr_cach_fragment));
   memset (state->cap_plus_csbk_bits, 0, sizeof(state->cap_plus_csbk_bits));
+  memset (state->cap_plus_block_num, 0, sizeof(state->cap_plus_block_num));
+  memset (state->data_header_valid, 0, sizeof(state->data_header_valid));
+  memset (state->data_header_format, 7, sizeof(state->data_header_format));
+  //reset some strings -- resetting call string here causes random blink on ncurses terminal (cap+)
+  // sprintf (state->call_string[0], "%s", "                     "); //21 spaces
+  // sprintf (state->call_string[1], "%s", "                     "); //21 spaces
+  sprintf (state->dmr_lrrp_gps[0], "%s", "");
+  sprintf (state->dmr_lrrp_gps[1], "%s", "");
 }

src/dmr_bs.c

@@ -114,13 +114,8 @@ void dmrBS (dsd_opts * opts, dsd_state * state)
   //disabled for dmr_cach testing
   tact_okay = 0;
   if ( Hamming_7_4_decode (tact_bits) ) tact_okay = 1;
-  if (tact_okay != 1)
-  {
-    if (opts->aggressive_framesync == 1)
-    {
-      goto END;
-    } 
-  }
+  if (tact_okay != 1) goto END;
+
 
   internalslot = state->currentslot = tact_bits[1];
 
@@ -344,8 +339,9 @@ void dmrBS (dsd_opts * opts, dsd_state * state)
       //process embedded link control
       fprintf (stderr, "\n");
       dmr_data_burst_handler(opts, state, (uint8_t *)dummy_bits, 0xEB);
-      //check the single burst/reverse channel opportunity
-      dmr_sbrc (opts, state, power);
+      //check the single burst/reverse channel opportunity -- moved
+      // dmr_sbrc (opts, state, power);
+
     }
 
     if (internalslot == 1 && vc2 == 6) 
@@ -353,8 +349,9 @@ void dmrBS (dsd_opts * opts, dsd_state * state)
       //process embedded link control
       fprintf (stderr, "\n");
       dmr_data_burst_handler(opts, state, (uint8_t *)dummy_bits, 0xEB);
-      //check the single burst/reverse channel opportunity
-      dmr_sbrc (opts, state, power);
+      //check the single burst/reverse channel opportunity -- moved
+      // dmr_sbrc (opts, state, power);
+
     }
 
     if (opts->payload == 1) fprintf (stderr, "\n"); //extra line break necessary here
@@ -384,7 +381,11 @@ void dmrBS (dsd_opts * opts, dsd_state * state)
     processMbeFrame (opts, state, NULL, ambe_fr3, NULL);    
 
     cach_err = dmr_cach (opts, state, cachdata); 
-    fprintf (stderr, "\n");
+    if (opts->payload == 0) fprintf (stderr, "\n");
+
+    //run sbrc here to look for the late entry key and alg after we observe potential errors in VC6
+    if (internalslot == 0 && vc1 == 6) dmr_sbrc (opts, state, power);
+    if (internalslot == 1 && vc2 == 6) dmr_sbrc (opts, state, power);
 
     // run alg refresh after vc6 ambe processing
     if (internalslot == 0 && vc1 == 6) dmr_alg_refresh (opts, state);
@@ -478,18 +479,16 @@ void dmrBS (dsd_opts * opts, dsd_state * state)
   fprintf (stderr, "| VOICE CACH/EMB ERR");
   fprintf (stderr, "%s", KNRM);
   fprintf (stderr, "\n");
-  //run LFSR if either slot had an active MI in it.
+  //run refresh if either slot had an active MI in it.
   if (state->payload_algid >= 0x21)
   {
-  state->currentslot = 0;
-  LFSR(state);
-  fprintf (stderr, "\n");
+    state->currentslot = 0;
+    dmr_alg_refresh (opts, state);
   }
   if (state->payload_algidR >= 0x21) 
   {
-  state->currentslot = 1;
-  LFSR(state);
-  fprintf (stderr, "\n");
+    state->currentslot = 1;
+    dmr_alg_refresh (opts, state);
   }
     
   //failsafe to reset all data header and blocks when bad tact or emb
@@ -572,13 +571,7 @@ void dmrBSBootstrap (dsd_opts * opts, dsd_state * state)
 
   //decode and correct tact and compare
   if ( Hamming_7_4_decode (tact_bits) ) tact_okay = 1;
-  if (tact_okay != 1)
-  {
-    if (opts->aggressive_framesync == 1)
-    {
-      goto END;
-    } 
-  }
+  if (tact_okay != 1) goto END;
 
   internalslot = state->currentslot = tact_bits[1];
 
@@ -636,11 +629,8 @@ void dmrBSBootstrap (dsd_opts * opts, dsd_state * state)
 
   if ( strcmp (sync, DMR_BS_VOICE_SYNC) != 0)
   {
-    if (opts->aggressive_framesync == 1)
-    {
-      sync_okay = 0;
-      goto END;
-    } 
+    sync_okay = 0;
+    goto END;
   }
 
   //Continue Second AMBE Frame, 18 after Sync or EmbeddedSignalling
@@ -740,7 +730,7 @@ void dmrBSBootstrap (dsd_opts * opts, dsd_state * state)
   dmr_late_entry_mi_fragment (opts, state, 1, m1, m2, m3);
 
   cach_err = dmr_cach (opts, state, cachdata);
-  fprintf (stderr, "\n");
+  if (opts->payload == 0) fprintf (stderr, "\n");
 
   //update voice sync time for trunking purposes (particularly Con+)
   if (opts->p25_is_tuned == 1) state->last_vc_sync_time = time(NULL);
@@ -755,18 +745,17 @@ void dmrBSBootstrap (dsd_opts * opts, dsd_state * state)
     fprintf (stderr, "%s", KRED);
     fprintf (stderr, "| VOICE CACH/SYNC ERR");
     fprintf (stderr, "%s", KNRM);
-    //run LFSR if either slot had an active MI in it.
+    fprintf (stderr, "\n");
+    //run refresh if either slot had an active MI in it.
     if (state->payload_algid >= 0x21)
     {
       state->currentslot = 0;
-      LFSR(state);
-      fprintf (stderr, "\n");
+      dmr_alg_refresh (opts, state);
     }
     if (state->payload_algidR >= 0x21) 
     {
       state->currentslot = 1;
-      LFSR(state);
-      fprintf (stderr, "\n");
+      dmr_alg_refresh (opts, state);
     }
     
     //failsafe to reset all data header and blocks when bad tact or emb

src/dmr_data.c

@@ -76,11 +76,8 @@ dmr_data_sync (dsd_opts * opts, dsd_state * state)
   else
   {
     cach_okay = -1;
-    if (opts->aggressive_framesync == 1)
-    {
-      SlotTypeOk = 0;
-      goto END;
-    }
+    SlotTypeOk = 0;
+    goto END;
   }
 
   state->currentslot = tact_bits[1];
@@ -262,11 +259,8 @@ dmr_data_sync (dsd_opts * opts, dsd_state * state)
   else
   {
     SlotTypeOk = -1;
-    if (opts->aggressive_framesync == 1)
-    {
-      SlotTypeOk = 0;
-      goto END;
-    }
+    SlotTypeOk = 0;
+    goto END;
   }
 
   state->color_code = (SlotType[0] << 3) + (SlotType[1] << 2) +(SlotType[2] << 1) + (SlotType[3] << 0);
@@ -342,13 +336,15 @@ dmr_data_sync (dsd_opts * opts, dsd_state * state)
 
       else if (opts->audio_in_type == 3) //rtl_fm tuning
       {
-        //UDP command to tune the RTL dongle
-        rtl_udp_tune(opts, state, state->p25_cc_freq);
+        #ifdef USE_RTLSDR
+        rtl_dev_tune(opts, state->p25_cc_freq);
+        #endif
       }
       opts->p25_is_tuned = 0;
       //zero out vc frequencies
       state->p25_vc_freq[0] = 0;
       state->p25_vc_freq[1] = 0;
+      memset (state->active_channel, 0, sizeof(state->active_channel));
       state->last_cc_sync_time = time(NULL);
       state->is_con_plus = 0; //con+ flag off
     }

src/dmr_dburst.c

@@ -9,9 +9,11 @@
  * 2022-12 DSD-FME Florida Man Edition
  *-----------------------------------------------------------------------------*/
 
-//WIP: CRC9 on confirmed data blocks; CRC32 on completed data sf;
-//WIP: Reverse Channel Signalling - RC single burst BPTC/7-bit CRC
-//WIP: Single Burst Embedded LC - Non-RC single burst LC - Look for Late Entry Alg/Key
+//WIP:  Unified Single Block Data - USBD -- TODO: USBD LIP Protocol Handling
+//WIP:  UDT Header and Blocks (coded - need samples)
+//WIP:  CRC9/CRC32 on Rate 1 Data (need samples)
+//WIP:  Reverse Channel Signalling - RC single burst BPTC/7-bit CRC (rc interleave) and when to run RC and not SB
+//WIP:  Single Burst Embedded LC - Non-RC single burst LC - Look for Late Entry Alg/Key
 
 #include "dsd.h"
 
@@ -43,9 +45,9 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
   uint8_t  LC_DataBytes[10];
   int Burst = -1;
 
-  //Unified PDU (is this the best nomenclature) Bytes
-  uint8_t  DMR_PDU[25]; //using 25 bytes as the max for now
-  uint8_t  DMR_PDU_bits[196]; //bitwise version of unified payload, will probably be a lot easier to use this w/ manual
+  //PDU Bytes and Bits
+  uint8_t  DMR_PDU[25]; 
+  uint8_t  DMR_PDU_bits[196]; 
   memset (DMR_PDU, 0, sizeof (DMR_PDU));
   memset (DMR_PDU_bits, 0, sizeof (DMR_PDU_bits));
 
@@ -61,9 +63,12 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
   uint8_t is_trellis = 0; 
   uint8_t is_emb = 0;
   uint8_t is_lc = 0;  
-  uint8_t is_full = 0; 
+  uint8_t is_full = 0;
+  uint8_t is_udt = 0; 
   uint8_t pdu_len = 0;
-  uint8_t pdu_start = 0; //starting value of pdu (0 normal, 2 for confirmed) 
+  uint8_t pdu_start = 0; //starting value of pdu (0 normal, 2 for confirmed)
+
+  uint8_t usbd_st = 0; //usbd service type 
 
   switch(databurst){
     case 0x00: //PI
@@ -127,7 +132,12 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
         pdu_len = 10; 
         pdu_start = 2; //start at plus two when assembling
         sprintf(state->fsubtype, " R12C ");
-      } 
+      }
+      if (state->data_header_format[slot] == 0) //UDT 1/2 Encoded Blocks
+      {
+        is_udt = 1; 
+        sprintf(state->fsubtype, " UDTC ");
+      }
       break;
     case 0x08: //3/4 Rate Data
       is_trellis = 1;
@@ -159,12 +169,12 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
         sprintf(state->fsubtype, " R_1C ");
       }  
       break;
-    case 0x0B: //Unified Data
+    case 0x0B: //Unified Single Block Data USBD
       is_bptc = 1;
       crclen = 16;
       crcmask = 0x3333;
       pdu_len = 12; //12 bytes
-      sprintf(state->fsubtype, " UDAT ");
+      sprintf(state->fsubtype, " USBD ");
       break;
       
     //special types (not real data 'sync' bursts)
@@ -185,6 +195,9 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
     
   }
 
+  //flag off prop head when not looking at data blocks
+  if (databurst != 0x6 && databurst != 0x7 && databurst != 0x8 && databurst != 0xA && databurst != 0xB) state->data_p_head[slot] = 0;
+
   if (databurst != 0xEB)
   {
     if (state->dmr_ms_mode == 0) fprintf(stderr, "| Color Code=%02d ", state->dmr_color_code);
@@ -199,7 +212,7 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
       for (i = 0; i < 6; i++) //3 byte CACH
       {
         int cach_byte = (state->dmr_stereo_payload[i*2] << 2) | state->dmr_stereo_payload[i*2 + 1];
-        fprintf (pFile, "%X", cach_byte);
+        fprintf (pFile, "%X", cach_byte); //nibble, not a byte, next time I look at this and wonder why its not %02X
       }
       fprintf (pFile, "\n%d %02X ", slot+1, databurst); //use hex value of current data burst type
       for (i = 6; i < 72; i++) //33 bytes, no CACH
@@ -230,7 +243,6 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
     //debug print
     //fprintf (stderr, " RAS? %X - %d %d %d", BPTCReservedBits, R[0], R[1], R[2]); 
 
-
     /* Convert the 96 bits BPTC data into 12 bytes */
     k = 0;
     for(i = 0; i < 12; i++)
@@ -266,10 +278,6 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
       CRCCorrect = 1;
     } 
 
-    //set CRC to correct on proprietary data header blocks (unsure if p_head data has valid crcs,
-    //may be ras enabled, manufacturer specific, or none, currently unknown, but possibly RAS on samples I have)
-    // else if (state->data_p_head[slot] == 1 && databurst == 0x06) CRCCorrect = 1;
-
     //run CRC9 on intermediate and last 1/2 confirmed data blocks
     else if (state->data_conf_data[slot] == 1 && databurst == 0x7)
     {
@@ -294,7 +302,7 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
     }
 
     //run CCITT on other data forms
-    else //will still run on unconfirmed data (shouldn't matter other than a possible bogus warning message)
+    else 
     {
       CRCComputed = ComputeCrcCCITT(BPTCDmrDataBit); 
       if (CRCComputed == CRCExtracted) CRCCorrect = 1;
@@ -302,12 +310,12 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
     }
 
     //set the 'RAS Flag', if no irrecoverable errors but bad crc, only when enabled by user (to prevent a lot of bad data CSBKs)
-    if (opts->aggressive_framesync == 0 && CRCCorrect == 0 && IrrecoverableErrors == 0 && BPTCReservedBits == 4) is_ras = 1; //!=0, or == 0x4, or just R[2] == 1
+    if (opts->aggressive_framesync == 0 && CRCCorrect == 0 && IrrecoverableErrors == 0 && BPTCReservedBits == 4) is_ras = 1; 
 
     //make sure the system type isn't Hytera, but could just be bad decodes on bad sample
     if (BPTCDmrDataByte[1] == 0x68) is_ras = 0;
 
-    //if this is a RAS system, set the CRC to okay if irrecoverable errors is okay
+    //if this is a RAS system, set the CRC to okay if irrecoverable errors are okay
     //if we don't do this, then we can't view some data (CSBKs on RAS enabled systems) 
     if (is_ras == 1)
     {
@@ -337,7 +345,7 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
       BPTCDmrDataBit[j + 7] = (BPTCDmrDataByte[i+pdu_start] >> 0) & 0x01;
     }
 
-    //convert to unified DMR_PDU and DMR_PDU_bits
+    //convert to DMR_PDU and DMR_PDU_bits
     for (i = 0; i < pdu_len; i++)
     {
       DMR_PDU[i] = BPTCDmrDataByte[i+pdu_start];
@@ -468,7 +476,7 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
       } 
       else
       {
-        IrrecoverableErrors = 9; //set as a shim since the trellis decoder is a pain to fix
+        // IrrecoverableErrors = 9; //set as a shim since the trellis decoder is a pain to fix
         state->data_block_crc_valid[slot][blockcounter] = 0;
       } 
 
@@ -545,14 +553,12 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
   if (databurst == 0x02) dmr_flco (opts, state, DMR_PDU_bits, CRCCorrect, IrrecoverableErrors, 2); //TLC
   if (databurst == 0xEB) dmr_flco (opts, state, DMR_PDU_bits, CRCCorrect, IrrecoverableErrors, 3); //EMB
 
-  //dmr data header and multi block types (header, 1/2, 3/4, 1, Unified) - type 1
-  if (databurst == 0x06) dmr_dheader (opts, state, DMR_PDU, CRCCorrect, IrrecoverableErrors);
-  if (databurst == 0x07) dmr_block_assembler (opts, state, DMR_PDU, pdu_len, databurst, 1); //1/2 Rate Data
+  //dmr data header and multi block types (header, 1/2, 3/4, 1, UDT) - type 1
+  if (databurst == 0x06) dmr_dheader (opts, state, DMR_PDU, DMR_PDU_bits, CRCCorrect, IrrecoverableErrors);
   if (databurst == 0x08) dmr_block_assembler (opts, state, DMR_PDU, pdu_len, databurst, 1); //3/4 Rate Data
   if (databurst == 0x0A) dmr_block_assembler (opts, state, DMR_PDU, pdu_len, databurst, 1); //Full Rate Data
-
-  //my best understanding is that unified data carries supplimentary MS data on TIII systems, not control signalling
-  if (databurst == 0x0B) dmr_block_assembler (opts, state, DMR_PDU, pdu_len, databurst, 1); //Unified Data
+  if (databurst == 0x07 && is_udt == 0) dmr_block_assembler (opts, state, DMR_PDU, pdu_len, databurst, 1); //1/2 Rate Data
+  if (databurst == 0x07 && is_udt == 1) dmr_block_assembler (opts, state, DMR_PDU, pdu_len, databurst, 3); //UDT with 1/2 Rate Encoding
 
   //control signalling types (CSBK, MBC)
   if (databurst == 0x03) dmr_cspdu (opts, state, DMR_PDU_bits, DMR_PDU, CRCCorrect, IrrecoverableErrors);
@@ -561,25 +567,38 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
   if (databurst == 0x04) 
   {
     state->data_block_counter[slot] = 0; //zero block counter before running header
+    state->data_header_valid[slot] = 1; //set valid header since we received one
     dmr_block_assembler (opts, state, DMR_PDU, pdu_len, databurst, 2);
   } 
   if (databurst == 0x05) dmr_block_assembler (opts, state, DMR_PDU, pdu_len, databurst, 2);
 
+  //Unified Single Data Block (USBD) -- Not to be confused with Unified Data Transport (UDT)
+  if (databurst == 0x0B)
+  {
+    //TODO: provide more robust handling at a later date -- ETSI TS 102 361-4 V1.11.1 (2021-01) 6.6.11.3
+    usbd_st = (uint8_t)ConvertBitIntoBytes(&DMR_PDU_bits[0], 4);
+    fprintf (stderr, "%s\n", KYEL);
+    fprintf (stderr, " Unified Single Block Data - ");
+    if (usbd_st == 0) fprintf (stderr, "Location Information Protocol");
+    else if (usbd_st > 8) fprintf (stderr, "Manufacturer Specific Service %d ", usbd_st);
+    else fprintf (stderr, "Reserved %d ", usbd_st);
+  }
+
   //set the original CRCCorrect back to its original value if the RAS flag was tripped
   if (is_ras == 1) CRCCorrect = crc_original_validity;
 
   //start printing relevant fec/crc/ras messages, don't print on idle or MBC continuation blocks (handled in dmr_block.c)
-  if (CRCCorrect == 1 && databurst != 0x09 && databurst != 0x05) ; //fprintf(stderr, "(CRC OK)");
+  if (IrrecoverableErrors == 0 && CRCCorrect == 1 && databurst != 0x09 && databurst != 0x05) ; //fprintf(stderr, "(CRC OK)");
 
-  if (IrrecoverableErrors == 0 && CRCCorrect == 0 && databurst != 0x09 && databurst != 0x05)
-  {
-    fprintf (stderr, "%s", KYEL);
-    fprintf(stderr, " (FEC OK)");
-    fprintf (stderr, "%s", KNRM);
+  // if (IrrecoverableErrors == 0 && CRCCorrect == 0 && databurst != 0x09 && databurst != 0x05)
+  // {
+  //   fprintf (stderr, "%s", KYEL);
+  //   fprintf(stderr, " (FEC OK)");
+  //   fprintf (stderr, "%s", KNRM);
 
-  } 
+  // } 
 
-  if (IrrecoverableErrors != 0 && databurst != 0x09 && databurst != 0x05)
+  if (IrrecoverableErrors != 0 && databurst != 0x09) //&& databurst != 0x05
   {
     fprintf (stderr, "%s", KRED);
     fprintf(stderr, " (FEC ERR)");
@@ -596,7 +615,7 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
     fprintf (stderr, "%s", KNRM);
   }
   
-  if (CRCCorrect == 0 && databurst != 0x09 && databurst != 0x05)
+  if (IrrecoverableErrors == 0 && CRCCorrect == 0 && is_ras == 0 && databurst != 0x09 && databurst != 0x05)
   {
     fprintf (stderr, "%s", KRED);
     fprintf (stderr, " (CRC ERR) ");
@@ -619,25 +638,6 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
     // fprintf (stderr, " CRC - EXT %X CMP %X", CRCExtracted, CRCComputed);
 
     fprintf (stderr, "%s", KNRM);
-
-    //short data - DD_HEAD, SP_HEAD or R_HEAD (Might do on TMS as well)
-    if ( (state->data_header_format[slot] & 0xF) == 0xD )
-    {
-      fprintf (stderr, "%s", KCYN);
-      fprintf (stderr, "\n  Hex to Ascii - ");
-      for (i = 0; i < pdu_len; i++)
-      {
-        if (DMR_PDU[i] <= 0x7E && DMR_PDU[i] >=0x20)
-        {
-          fprintf (stderr, "%c", DMR_PDU[i]);
-        }
-        else fprintf (stderr, ".");
-      }
-      
-      fprintf (stderr,"%s", KNRM);
-      
-    }
-
     
   }
 

src/dmr_flco.c

@@ -30,18 +30,43 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
   int is_cap_plus = 0;
   int is_alias = 0;
   int is_gps = 0;
+
+  //XPT 'Things'
+  int is_xpt = 0;
+  uint8_t xpt_hand = 0;  //handshake
+  uint8_t xpt_free = 0;  //free repeater
+  uint8_t xpt_int  = 0;  //xpt channel to interrupt (channel/repeater call should occur on?)
+  uint8_t xpt_res_a = 0; //unknown values of other bits of the XPT LC
+  uint8_t xpt_res_b = 0; //unknown values of other bits of the XPT LC
+  uint8_t xpt_res_c = 0; //unknown values of other bits of the XPT LC
+  uint8_t target_hash[24]; //for XPT (and others if desired, get the hash and compare against SLC or XPT Status CSBKs)
+  uint8_t tg_hash = 0; //value of the hashed TG
+
   uint8_t slot = state->currentslot;
   uint8_t unk = 0; //flag for unknown FLCO + FID combo
 
-  
-  pf = (uint8_t)(lc_bits[0]); //Protect Flag
-  reserved = (uint8_t)(lc_bits[1]); //Reserved 
+  pf = (uint8_t)(lc_bits[0]); //Protect Flag -- Hytera XPT uses this to signify which TS the PDU is on
+  reserved = (uint8_t)(lc_bits[1]); //Reserved -- Hytera XPT G/I bit; 0 - Individual; 1 - Group;
   flco = (uint8_t)ConvertBitIntoBytes(&lc_bits[2], 6); //Full Link Control Opcode
   fid = (uint8_t)ConvertBitIntoBytes(&lc_bits[8], 8); //Feature set ID (FID)
   so = (uint8_t)ConvertBitIntoBytes(&lc_bits[16], 8); //Service Options
   target = (uint32_t)ConvertBitIntoBytes(&lc_bits[24], 24); //Target or Talk Group
   source = (uint32_t)ConvertBitIntoBytes(&lc_bits[48], 24);
 
+  //read ahead a little to get this for the xpt flag
+  if (IrrecoverableErrors == 0 && flco == 0x09 && fid == 0x68)
+  {
+    sprintf (state->dmr_branding, "%s", "  Hytera"); 
+    sprintf (state->dmr_branding_sub, "XPT ");
+  }
+
+  //look at the dmr_branding_sub for the XPT string
+  //branding sub is set at CSBK(68-3A and 3B), SLCO 8, and here on 0x09
+  if (strcmp (state->dmr_branding_sub, "XPT ") == 0) is_xpt = 1;
+
+  //hytera XPT -- disable the pf flag, is used for TS value in some Hytera XPT PDUs
+  if (is_xpt) pf = 0;
+
   //check protect flag
   if (pf == 1)
   {
@@ -53,44 +78,49 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
     goto END_FLCO; 
   } 
 
-  //look for Cap+ on VLC header, then set source and/or rest channel appropriately
-  if (IrrecoverableErrors == 0 && type == 1 && fid == 0x10 && (flco == 0x04 || flco == 0x07) ) //0x07 appears to be a cap+ txi private call
-  {
-    is_cap_plus = 1;
-    capsite = (uint8_t)ConvertBitIntoBytes(&lc_bits[48], 4); //can't verify, just speculating
-    restchannel = (int)ConvertBitIntoBytes(&lc_bits[52], 4); //was 48,8
-    source = (uint32_t)ConvertBitIntoBytes(&lc_bits[56], 16);
-    // sprintf (state->dmr_branding, "%s", "Motorola");
-    // sprintf (state->dmr_branding_sub, "%s", "Cap+ ");
-  }
-
-
   if (IrrecoverableErrors == 0)
   {
-
+    
     if (slot == 0) state->dmr_flco = flco;
     else state->dmr_flcoR = flco;
-    
+
+    //FID 0x10 and FLCO 0x14, 0x15, 0x16 and 0x17 confirmed as Moto EMB Alias
+    //Can probably assume FID 0x10 FLCO 0x18 is Moto EMB GPS -- to be tested
+    if ( fid == 0x10 && (flco == 0x14 || flco == 0x15 || flco == 0x16 || flco == 0x17 || flco == 0x18) )
+    {
+      flco = flco - 0x10;
+      fid = 0;
+    }
+
     //Embedded Talker Alias Header Only (format and len storage)
-    if (fid == 0 && type == 3 && flco == 0x04) 
+    if ( (fid == 0 || fid == 0x68) && type == 3 && flco == 0x04) 
     {
       dmr_embedded_alias_header(opts, state, lc_bits);
     }
 
     //Embedded Talker Alias Header (continuation) and Blocks
-    if (fid == 0 && type == 3 && flco > 0x3 && flco < 0x08) 
+    if ( (fid == 0 || fid == 0x68) && type == 3 && flco > 0x03 && flco < 0x08) 
     {
       is_alias = 1;
       dmr_embedded_alias_blocks(opts, state, lc_bits);
     }
 
     //Embedded GPS
-    if (fid == 0 && type == 3 && flco == 0x08)
+    if ( (fid == 0 || fid == 0x68) && fid == 0 && type == 3 && flco == 0x08)
     {
       is_gps = 1;
       dmr_embedded_gps(opts, state, lc_bits);
     }
 
+    //look for Cap+ on VLC header, then set source and/or rest channel appropriately
+    if (type == 1 && fid == 0x10 && (flco == 0x04 || flco == 0x07) ) //0x07 appears to be a cap+ txi private call
+    {
+      is_cap_plus = 1;
+      capsite = (uint8_t)ConvertBitIntoBytes(&lc_bits[48], 4); //don't believe so
+      restchannel = (int)ConvertBitIntoBytes(&lc_bits[52], 4); //
+      source = (uint32_t)ConvertBitIntoBytes(&lc_bits[56], 16);
+    }
+
     //Unknown CapMax/Moto Things
     if (fid == 0x10 && (flco == 0x08 || flco == 0x28)) 
     {
@@ -113,8 +143,16 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
     {
       fprintf (stderr, "%s \n", KRED);
       fprintf (stderr, " SLOT %d", state->currentslot+1);
-      fprintf (stderr, " Data Terminator (TD_LC)");
-      fprintf (stderr, "%s ", KNRM);
+      fprintf (stderr, " Data Terminator (TD_LC) ");
+      fprintf (stderr, "%s", KNRM);
+
+      //reset data header format storage
+      state->data_header_format[slot] = 7;
+      //flag off data header validity 
+      state->data_header_valid[slot] = 0; 
+      //flag off conf data flag
+      state->data_conf_data[slot] = 0;
+      
       goto END_FLCO;
     }
 
@@ -132,8 +170,111 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
       goto END_FLCO;
     }
 
+    //look for any Hytera XPT system, adjust TG to 16-bit allocation 
+    //Groups use only 8 out of 16, but 16 always seems to be allocated
+    //private calls use 16-bit target values hashed to 8-bit in the site status csbk
+    //the TLC preceeds the VLC for a 'handshake' call setup in XPT
+
+    //truncate if XPT is set
+    if (is_xpt == 1)
+    {
+      target = (uint32_t)ConvertBitIntoBytes(&lc_bits[32], 16); //16-bit allocation
+      source = (uint32_t)ConvertBitIntoBytes(&lc_bits[56], 16); //16-bit allocation
+
+      //the crc8 hash is the value represented in the CSBK when dealing with private calls
+      for (int i = 0; i < 16; i++) target_hash[i] = lc_bits[32+i];
+      tg_hash = crc8 (target_hash, 16); 
+    } 
+
+    //XPT Call 'Grant/Alert' Setup Occurs in TLC with a flco 0x09 
+    if (fid == 0x68 && flco == 0x09)
+    {
+      //The CSBK always uses an 8-bit TG/TGT; The White Papers (user manuals) say 8-bit TG and 16-bit SRC addressing
+      //private calls and indiv data calls use a hash of their 8 bit tgt values in the CSBK
+      xpt_int = (uint8_t)ConvertBitIntoBytes(&lc_bits[16], 4); //This is consistent with an LCN value, not an LSN value
+      xpt_free = (uint8_t)ConvertBitIntoBytes(&lc_bits[24], 4); //24 and 4 on 0x09
+      xpt_hand = (uint8_t)ConvertBitIntoBytes(&lc_bits[28], 4); //handshake kind: 0 - ordinary; 1-2 Interrupts; 3-15 reserved; 
+
+      target = (uint32_t)ConvertBitIntoBytes(&lc_bits[32], 16); //16-bit allocation
+      source = (uint32_t)ConvertBitIntoBytes(&lc_bits[56], 16); //16-bit allocation
+
+      //the bits that are left behind
+      xpt_res_a = (uint8_t)ConvertBitIntoBytes(&lc_bits[20], 4); //after the xpt_int channel, before the free repeater channel -- call being established = 7; call connected = 0; ??
+      xpt_res_b = (uint8_t)ConvertBitIntoBytes(&lc_bits[48], 8); //where the first 8 bits of the SRC would be
+
+      //the crc8 hash is the value represented in the CSBK when dealing with private calls
+      for (int i = 0; i < 16; i++) target_hash[i] = lc_bits[32+i];
+      tg_hash = crc8 (target_hash, 16); 
+
+      fprintf (stderr, "%s \n", KGRN);
+      fprintf (stderr, " SLOT %d ", state->currentslot+1);
+      if (opts->payload == 1) fprintf(stderr, "FLCO=0x%02X FID=0x%02X ", flco, fid); 
+      fprintf (stderr, "TGT=%u SRC=%u ", target, source);
+      
+      fprintf (stderr, "Hytera XPT ");
+
+      //Group ID ranges from 1 to 240; emergency group call ID ranges from 250 to 254; all call ID is 255.
+      if (reserved == 1)
+      {
+        fprintf (stderr, "Group "); //according to observation
+        if (target > 248 && target < 255) fprintf (stderr, "Emergency ");
+        if (target == 255) fprintf (stderr, "All ");
+      } 
+      else fprintf (stderr, "Private "); //according to observation
+      fprintf (stderr, "Call Alert "); //Alert or Grant
+
+      //reorganized all the 'extra' data to a second line and added extra verbosity
+      if (opts->payload == 1) fprintf (stderr, "\n  ");
+      if (opts->payload == 1) fprintf (stderr, "%s", KYEL);
+      //only display the hashed tgt value if its a private call and not a group call
+      if (reserved == 0 && opts->payload == 1) fprintf(stderr, "TGT Hash=%d; ", tg_hash);
+      if (opts->payload == 1) fprintf(stderr, "HSK=%X; ", xpt_hand);
+      //extra verbosity on handshake types found in the patent
+      if (opts->payload == 1) 
+      {
+        fprintf (stderr, "Handshake - ");
+        if (xpt_hand == 0) fprintf (stderr, "Ordinary; ");
+        else if (xpt_hand == 1) fprintf (stderr, "Callback/Alarm Interrupt; ");
+        else if (xpt_hand == 2) fprintf (stderr, "Release Channel Interrupt; ");
+        else fprintf (stderr, "Reserved; ");
+      }
+
+      // if (opts->payload == 1)
+      // {
+      //   if (xpt_res_a == 0) fprintf (stderr, "Call Connected; ");
+      //   if (xpt_res_a == 1) fprintf (stderr, "Data Call Request; ");
+      //   if (xpt_res_a == 7) fprintf (stderr, "Voice Call Request; ");
+      //   if (xpt_res_a == 2) fprintf (stderr, "Unknown Status; ");
+      // }
+
+      //logical repeater channel, not the logical slot value in the CSBK
+      if (opts->payload == 1) fprintf(stderr, "Call on LCN %d; ", xpt_int); //LCN channel call or 'interrupt' will occur on
+      // if (opts->payload == 1) fprintf(stderr, "RS A[%01X]B[%02X]C[%02X]; ", xpt_res_a, xpt_res_b, xpt_res_c); //leftover bits
+      if (opts->payload == 1) fprintf (stderr, "Free LCN %d; ", xpt_free); //current free repeater LCN channel
+      fprintf (stderr, "%s ", KNRM);
+
+      //add string for ncurses terminal display
+      sprintf (state->dmr_site_parms, "Free LCN - %d ", xpt_free);
+
+      is_xpt = 1;
+      goto END_FLCO;
+    }
+
+    //Hytera XPT 'Others' -- moved the patent opcodes here as well for now
+    if ( fid == 0x68 && (flco == 0x13 || flco == 0x31 || flco == 0x2E || flco == 0x2F) )
+    {
+      if (type == 1) fprintf (stderr, "%s \n", KCYN);
+      if (type == 2) fprintf (stderr, "%s \n", KCYN);
+      if (type == 3) fprintf (stderr, "%s", KCYN);
+      fprintf (stderr, " SLOT %d", state->currentslot+1);
+      fprintf (stderr, " Hytera ");
+      unk = 1;
+      goto END_FLCO;
+    }
+
     //unknown other manufacturer or OTA ENC, etc.
-    if (fid != 0 && fid != 0x68 && fid != 0x10) //removed tait from the list
+    //removed tait from the list, added hytera 0x08
+    if (fid != 0 && fid != 0x68 && fid != 0x10 && fid != 0x08) 
     {
       if (type == 1) fprintf (stderr, "%s \n", KYEL);
       if (type == 2) fprintf (stderr, "%s \n", KYEL);
@@ -147,11 +288,9 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
   }  
 
   //will want to continue to observe for different flco and fid combinations to find out their meaning
-  //Standard Addressing/Cap+ Addressing (trying to avoid embedded alias and gps, etc)
   if(IrrecoverableErrors == 0 && is_alias == 0 && is_gps == 0) 
   {
     //set overarching manufacturer in use when non-standard feature id set is up
-    //may not want to set moto 0x10 here either, lots of radios use that set as well
     if (fid != 0) state->dmr_mfid = fid;
 
     if (type != 2) //VLC and EMB, set our target, source, so, and fid per channel
@@ -203,6 +342,7 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
         state->payload_miR = 0;
         state->payload_keyidR = 0;
       }
+      
     }
     
 
@@ -222,12 +362,18 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
     
     fprintf (stderr, " SLOT %d ", state->currentslot+1);
     fprintf(stderr, "TGT=%u SRC=%u ", target, source);
+    if (opts->payload == 1 && is_xpt == 1 && flco == 0x3) fprintf(stderr, "HASH=%d ", tg_hash);
     if (opts->payload == 1) fprintf(stderr, "FLCO=0x%02X FID=0x%02X SVC=0x%02X ", flco, fid, so);
 
     //0x04 and 0x05 on a TLC seem to indicate a Cap + Private Call Terminator (perhaps one for each MS)
     //0x07 on a VLC seems to indicate a Cap+ Private Call Header
-    //0x23 on the Embedded Voice Burst Sync seems to indicate a Cap+ Private Call in progress
-    if (flco == 0x4 || flco == 0x5 || flco == 0x7 || flco == 0x23) //Cap+ Things
+    //0x23 on the Embedded Voice Burst Sync seems to indicate a Cap+ or Cap+ TXI Private Call in progress
+    //0x20 on the Embedded Voice Burst Sync seems to indicate a Moto (non-specific) Group Call in progress
+    //its possible that both EMB FID 0x10 FLCO 0x20 and 0x23 are just Moto but non-specific (observed 0x20 on Tier 2)
+
+    if (fid == 0x68) sprintf (state->call_string[slot], " Hytera  "); 
+
+    else if (flco == 0x4 || flco == 0x5 || flco == 0x7 || flco == 0x23) //Cap+ Things
     {
       sprintf (state->call_string[slot], " Cap+");
       fprintf (stderr, "Cap+ ");
@@ -247,7 +393,7 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
       sprintf (state->call_string[slot], " Private ");
       fprintf (stderr, "Private "); 
     }
-    else //Grp_V_Ch_Usr
+    else //Grp_V_Ch_Usr -- still valid on hytera VLC
     {
       sprintf (state->call_string[slot], "   Group ");
       fprintf (stderr, "Group "); 
@@ -271,64 +417,74 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
     //REMUS! Uncomment Line Below if desired
     // else strcat (state->call_string[slot], "          ");
 
-    /* Check the "Service Option" bits */ 
-    if(so & 0x30)
+    //Motorola FID 0x10 Only
+    if (fid == 0x10)
     {
-      /* Experimentally determined with DSD+,
-      * is equal to 0x2, this is a TXI call */
-      if((so & 0x30) == 0x20)
+      /* Check the "Service Option" bits */ 
+      if(so & 0x30)
+      {
+        /* Experimentally determined with DSD+,
+        * is equal to 0x2, this is a TXI call */
+        if((so & 0x30) == 0x20)
+        {
+          //REMUS! Uncomment Line Below if desired
+          // strcat (state->call_string[slot], " TXI");
+          fprintf(stderr, "TXI ");
+        } 
+        else
+        {
+          //REMUS! Uncomment Line Below if desired
+          // strcat (state->call_string[slot], " RES");
+          fprintf(stderr, "RS%d ", (so & 0x30) >> 4);
+        } 
+      }
+      if(so & 0x08)
       {
         //REMUS! Uncomment Line Below if desired
-        // strcat (state->call_string[slot], " TXI");
-        fprintf(stderr, "TXI ");
+        // strcat (state->call_string[slot], "-BC   ");
+        fprintf(stderr, "Broadcast ");
       } 
-      else
+      if(so & 0x04)
       {
         //REMUS! Uncomment Line Below if desired
-        // strcat (state->call_string[slot], " RES");
-        fprintf(stderr, "RS%d ", (so & 0x30) >> 4);
+        // strcat (state->call_string[slot], "-OVCM ");
+        fprintf(stderr, "OVCM ");
       } 
-    }
-    if(so & 0x08)
-    {
-      //REMUS! Uncomment Line Below if desired
-      // strcat (state->call_string[slot], "-BC   ");
-      fprintf(stderr, "Broadcast ");
-    } 
-    if(so & 0x04)
-    {
-      //REMUS! Uncomment Line Below if desired
-      // strcat (state->call_string[slot], "-OVCM ");
-      fprintf(stderr, "OVCM ");
-    } 
-    if(so & 0x03)
-    {
-      if((so & 0x03) == 0x01)
+      if(so & 0x03)
       {
-        //REMUS! Uncomment Line Below if desired
-        // strcat (state->call_string[slot], "-P1");
-        fprintf(stderr, "Priority 1 ");
-      } 
-      else if((so & 0x03) == 0x02)
-      {
-        //REMUS! Uncomment Line Below if desired
-        // strcat (state->call_string[slot], "-P2");
-        fprintf(stderr, "Priority 2 ");
-      } 
-      else if((so & 0x03) == 0x03)
-      {
-        //REMUS! Uncomment Line Below if desired
-        // strcat (state->call_string[slot], "-P3");
-        fprintf(stderr, "Priority 3 ");
-      } 
-      else /* We should never go here */
-      {
-        //REMUS! Uncomment Line Below if desired
-        // strcat (state->call_string[slot], "  ");
-        fprintf(stderr, "No Priority "); 
-      } 
+        if((so & 0x03) == 0x01)
+        {
+          //REMUS! Uncomment Line Below if desired
+          // strcat (state->call_string[slot], "-P1");
+          fprintf(stderr, "Priority 1 ");
+        } 
+        else if((so & 0x03) == 0x02)
+        {
+          //REMUS! Uncomment Line Below if desired
+          // strcat (state->call_string[slot], "-P2");
+          fprintf(stderr, "Priority 2 ");
+        } 
+        else if((so & 0x03) == 0x03)
+        {
+          //REMUS! Uncomment Line Below if desired
+          // strcat (state->call_string[slot], "-P3");
+          fprintf(stderr, "Priority 3 ");
+        } 
+        else /* We should never go here */
+        {
+          //REMUS! Uncomment Line Below if desired
+          // strcat (state->call_string[slot], "  ");
+          fprintf(stderr, "No Priority "); 
+        } 
+      }
     }
     
+    //should rework this back into the upper portion
+    if (fid == 0x68) fprintf (stderr, "Hytera ");
+    if (is_xpt) fprintf (stderr, "XPT ");
+    if (fid == 0x68 && flco == 0x00) fprintf (stderr, "Group ");
+    if (fid == 0x68 && flco == 0x03) fprintf (stderr, "Private ");
+
     fprintf(stderr, "Call ");
     
 
@@ -365,21 +521,38 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
 
     if (state->K1 != 0 && fid == 0x68 && so & 0x40)
     {
-      fprintf (stderr, "\n");
+      if (state->K2 != 0) fprintf (stderr, "\n ");
       fprintf (stderr, "%s", KYEL);
-      fprintf (stderr, " Key %010llX ", state->K1);
+      fprintf (stderr, "Key %010llX ", state->K1);
       if (state->K2 != 0) fprintf (stderr, "%016llX ", state->K2);
       if (state->K4 != 0) fprintf (stderr, "%016llX %016llX", state->K3, state->K4);
       fprintf (stderr, "%s ", KNRM);
-    } 
+    }
+
+    if (slot == 0 && state->payload_algid == 0x21 && state->R != 0)
+    {
+      fprintf (stderr, "%s", KYEL);
+      fprintf (stderr, "Key %010llX ", state->R);
+      fprintf (stderr, "%s ", KNRM);
+    }
+
+    if (slot == 1 && state->payload_algidR == 0x21 && state->RR != 0)
+    {
+      fprintf (stderr, "%s", KYEL);
+      fprintf (stderr, "Key %010llX ", state->RR);
+      fprintf (stderr, "%s ", KNRM);
+    }
     
   }
 
   END_FLCO:
+  
+  //blank the call string here if its a TLC
+  if (type == 2) sprintf (state->call_string[slot], "%s", "                     "); //21 spaces
+
   if (unk == 1 || pf == 1)
   {
-    // fprintf(stderr, " FLCO=0x%02X FID=0x%02X SVC=0x%02X ", flco, fid, so);
-    fprintf(stderr, " FLCO=0x%02X FID=0x%02X ", flco, fid); //not all LC PDUs contain SVC bits (see TD_LC)
+    fprintf(stderr, " FLCO=0x%02X FID=0x%02X ", flco, fid);
     fprintf (stderr, "%s", KNRM);
   }
 
@@ -646,10 +819,17 @@ void dmr_slco (dsd_opts * opts, dsd_state * state, uint8_t slco_bits[])
   //Con+
   uint8_t con_netid  = (uint8_t)ConvertBitIntoBytes(&slco_bits[8], 8);
   uint8_t con_siteid = (uint8_t)ConvertBitIntoBytes(&slco_bits[16], 8);
+
   //Cap+
-  uint8_t capsite = (uint8_t)ConvertBitIntoBytes(&slco_bits[12], 4); //can't verify, just speculating
-  uint8_t restchannel = (uint8_t)ConvertBitIntoBytes(&slco_bits[16], 4); //was 12,8
-  uint8_t cap_reserved = (uint8_t)ConvertBitIntoBytes(&slco_bits[20], 8); //unknown if any significant value?
+  uint8_t capsite = (uint8_t)ConvertBitIntoBytes(&slco_bits[22], 3); //Seems more consistent
+  uint8_t restchannel = (uint8_t)ConvertBitIntoBytes(&slco_bits[16], 4); 
+  uint8_t cap_reserved = (uint8_t)ConvertBitIntoBytes(&slco_bits[20], 2); //significant value?
+
+  //Hytera XPT
+  uint8_t xpt_free = (uint8_t)ConvertBitIntoBytes(&slco_bits[12], 4); //free repeater
+  //the next two per SDRTrunk, but only 0 values ever observed here
+  uint8_t xpt_pri  = (uint8_t)ConvertBitIntoBytes(&slco_bits[16], 4); //priority repeater
+  uint8_t xpt_hash = (uint8_t)ConvertBitIntoBytes(&slco_bits[20], 8); //priority TG hash
 
   //initial line break
   fprintf (stderr, "\n");
@@ -698,20 +878,12 @@ void dmr_slco (dsd_opts * opts, dsd_state * state, uint8_t slco_bits[])
     fprintf (stderr, " SLCO Activity Update TS1: %X Hash: %02X TS2: %X Hash: %02X", ts1_act, ts1_hash, ts2_act, ts2_hash); //102 361-2 7.1.3.2 
   else if (slco == 0x9)
   {
-    //remove all setting of branding/sub from SLCO, can cause false positives even with seeming good CRC
-    
-    // state->dmr_mfid = 0x10;
-    // sprintf (state->dmr_branding, "%s", "Motorola"); 
-    // sprintf (state->dmr_branding_sub, "%s", "Con+ ");
     fprintf (stderr, " SLCO Connect Plus Voice Channel - Net ID: %d Site ID: %d", con_netid, con_siteid);
     sprintf (state->dmr_site_parms, "%d-%d ", con_netid, con_siteid);
   }
     
   else if (slco == 0xA)
   {
-    // state->dmr_mfid = 0x10;
-    // sprintf (state->dmr_branding, "%s", "Motorola");
-    // sprintf (state->dmr_branding_sub, "%s", "Con+ ");
     fprintf (stderr, " SLCO Connect Plus Control Channel - Net ID: %d Site ID: %d", con_netid, con_siteid);
     sprintf (state->dmr_site_parms, "%d-%d ", con_netid, con_siteid);
 
@@ -725,19 +897,24 @@ void dmr_slco (dsd_opts * opts, dsd_state * state, uint8_t slco_bits[])
    
   else if (slco == 0xF)
   {
-    // state->dmr_mfid = 0x10;
-    // sprintf (state->dmr_branding, "%s", "Motorola");
-    // sprintf (state->dmr_branding_sub, "%s", "Cap+ ");
-    fprintf (stderr, " SLCO Capacity Plus Site: %d - Rest Channel %d - RS: %02X", capsite+1, restchannel, cap_reserved);
-    // state->dmr_rest_channel = restchannel; //test without, may work better
+    fprintf (stderr, " SLCO Capacity Plus Site: %d - Rest Channel %d - RS: %02X", capsite, restchannel, cap_reserved);
     //assign to cc freq if available
     if (state->trunk_chan_map[restchannel] != 0)
     {
       state->p25_cc_freq = state->trunk_chan_map[restchannel];
     }
 
-    //nullify any previous TIII data (bugfix for bad assignments or system type switching)
-    // sprintf(state->dmr_site_parms, "%s", "");
+  }
+  else if (slco == 0x08)
+  {
+    //The Priority Repeater and Priority Hash values stem from SDRTrunk, but I've never seen these values not be zeroes
+    fprintf (stderr, " SLCO Hytera XPT - Free LCN %d - PRI LCN %d - PRI HASH: %02X", xpt_free, xpt_pri, xpt_hash);
+    //NOTE: on really busy systems, this free repeater assignment can lag due to the 4 TS requirment to get SLC
+    // fprintf (stderr, " SLCO Hytera XPT - Free LCN %d ", xpt_free); 
+    sprintf (state->dmr_branding_sub, "XPT ");
+
+    //add string for ncurses terminal display
+    sprintf (state->dmr_site_parms, "Free LCN - %d ", xpt_free);
   }
     
   else fprintf (stderr, " SLCO Unknown - %d ", slco);
@@ -749,6 +926,7 @@ void dmr_slco (dsd_opts * opts, dsd_state * state, uint8_t slco_bits[])
     {
       fprintf (stderr, "[%02X]", slco_bytes[i]);
     }
+    fprintf (stderr, "\n"); //if its a voice frame, we need the line break 
   }
 
   fprintf (stderr, "%s", KNRM);
@@ -789,6 +967,10 @@ void dmr_embedded_alias_blocks (dsd_opts * opts, dsd_state * state, uint8_t lc_b
   uint8_t len =  state->dmr_alias_len[slot];
   uint8_t start; //starting position depends on context of block and format
 
+  //Cap Max Variation
+  uint8_t fid = (uint8_t)ConvertBitIntoBytes(&lc_bits[8], 8);
+  if (fid == 0x10) block = block - 0x10; //CapMax adds 0x10 to its FLCO (block num) in its Embedded Aliasing
+
   //there is some issue with the next three lines of code that prevent proper assignments, not sure what.
   //if (block > 4) start = 16;
   //else if (block == 4 && format > 0) start = 23; //8-bit and 16-bit chars

src/dmr_le.c

@@ -13,6 +13,23 @@ void dmr_late_entry_mi_fragment (dsd_opts * opts, dsd_state * state, uint8_t vc,
 {
   
   uint8_t slot = state->currentslot;
+
+  //enforce RC4 due to missing PI header, but with valid SVC Opts
+  //ideally, this would be handled by VC-F single burst, but its not fully reliable compared to this
+  //due to multiple signalling occurring inside of it, depending on system type
+  if (state->M == 0x21)
+  {
+    if (slot == 0 && state->dmr_so & 0x40)
+    {
+      state->payload_algid = 0x21;
+      state->payload_keyid = 0xFF;
+    }
+    if (slot == 1 && state->dmr_soR & 0x40)
+    {
+      state->payload_algidR = 0x21;
+      state->payload_keyidR = 0xFF;
+    }
+  }
   
   //collect our fragments and place them into storage
   state->late_entry_mi_fragment[slot][vc][0] = (uint64_t)ConvertBitIntoBytes(&ambe_fr[3][0], 4);
@@ -76,6 +93,12 @@ void dmr_late_entry_mi (dsd_opts * opts, dsd_state * state)
         fprintf (stderr, " Slot 1 PI/LFSR and Late Entry MI Mismatch - %08X : %08X \n", state->payload_mi, mi_final);
         state->payload_mi = mi_final; 
         fprintf (stderr, "%s", KNRM);
+      }
+      //run afterwards, or le verification won't match up properly
+      if (state->payload_algid != 0x21)
+      {
+        LFSR64 (state);
+        fprintf (stderr, "\n");
       } 
     }
     if (slot == 1 && state->payload_algidR != 0)
@@ -86,6 +109,12 @@ void dmr_late_entry_mi (dsd_opts * opts, dsd_state * state)
         fprintf (stderr, " Slot 2 PI/LFSR and Late Entry MI Mismatch - %08X : %08X \n", state->payload_miR, mi_final);
         state->payload_miR = mi_final;
         fprintf (stderr, "%s", KNRM);
+      }
+      //run afterwards, or le verification won't match up properly
+      if (state->payload_algidR != 0x21)
+      {
+        LFSR64 (state);
+        fprintf (stderr, "\n");
       } 
     }
 
@@ -104,11 +133,13 @@ void dmr_alg_refresh (dsd_opts * opts, dsd_state * state)
       state->DMRvcL = 0;
     }
 
-    if (state->payload_algid >= 0x21)
+    if (state->payload_algid == 0x21)
     {
       LFSR (state);
       fprintf (stderr, "\n");
     }
+    //LFSR64 carried out after LE verification in order to keep it from constantly resetting the MI to the previous value
+
   }
   if (state->currentslot == 1)
   {
@@ -119,11 +150,13 @@ void dmr_alg_refresh (dsd_opts * opts, dsd_state * state)
       state->DMRvcR = 0;
     }
 
-    if (state->payload_algidR >= 0x21)
+    if (state->payload_algidR == 0x21)
     {
       LFSR (state);
       fprintf (stderr, "\n");
     }
+    //LFSR64 carried out after LE verification in order to keep it from constantly resetting the MI to the previous value
+
   }
 
 }
@@ -134,12 +167,11 @@ void dmr_alg_reset (dsd_opts * opts, dsd_state * state)
   state->dropR = 256;
   state->DMRvcL = 0;
   state->DMRvcR = 0; 
-  state->payload_miP = 0; 
+  state->payload_miP = 0;
+  state->payload_miN = 0; 
 }
 
 //handle Single Burst (Voice Burst F) or Reverse Channel Signalling 
-//(Embedded or Dedicated Outbound, not Stand Alone (MS sourced) or Direct Mode)
-//MS Sourced or Direct Mode probably would be handled poorly by the demodulator
 void dmr_sbrc (dsd_opts * opts, dsd_state * state, uint8_t power)
 {
   int i;
@@ -164,11 +196,10 @@ void dmr_sbrc (dsd_opts * opts, dsd_state * state, uint8_t power)
   //power == 1 should be reverse channel -- still need to check the interleave inside of BPTC
   if (power == 1) irr_err = BPTC_16x2_Extract_Data(sbrc_interleaved, sbrc_return, 1);
   //bad emb burst, never set a valid power indicator value (probably 9)
-  if (power > 1) goto SBRC_END; 
+  if (power > 1) goto SBRC_END;
 
   //RC Channel CRC 7 Mask = 0x7A; CRC bits are used as privacy indicators on 
   //Single Voice Burst F (see below), other moto values seem to exist there as well
-  //unknown what the other values are (see Cap+ 0x313)
   if (power == 1) //RC
   {
     crc_extracted = 0;
@@ -183,17 +214,19 @@ void dmr_sbrc (dsd_opts * opts, dsd_state * state, uint8_t power)
   }
   else crc_okay = 1; //SB
 
-  if (opts->payload == 1) //hide the sb/rc behind the payload printer, won't be useful to most people right now
+  for(i = 0; i < 11; i++)
+  {
+    sbrc_hex = sbrc_hex << 1;
+    sbrc_hex |= sbrc_return[i] & 1; //sbrc_return
+  }
+
+  if (opts->payload == 1) //hide the sb/rc behind the payload printer, won't be useful to most people
   {
     fprintf (stderr, "\n %s", KCYN);
     if (power == 0) fprintf (stderr, " SB: ");
     if (power == 1) fprintf (stderr, " RC: ");
     for(i = 0; i < 11; i++)
-    {
-      sbrc_hex = sbrc_hex << 1;
-      sbrc_hex |= sbrc_return[i] & 1; //sbrc_return
       fprintf (stderr, "%d", sbrc_return[i]);
-    }
     fprintf (stderr, " - %03X", sbrc_hex);
     fprintf (stderr, "%s", KNRM);
 
@@ -202,67 +235,66 @@ void dmr_sbrc (dsd_opts * opts, dsd_state * state, uint8_t power)
       fprintf (stderr, "%s", KRED);
       fprintf (stderr, " (CRC ERR)");
       fprintf (stderr, "%s", KNRM);
-      if (opts->payload == 1) fprintf (stderr, " CRC EXT %02X, CRC CMP %02X", crc_extracted, crc_computed);
+      fprintf (stderr, " CRC EXT %02X, CRC CMP %02X", crc_extracted, crc_computed);
     }
   }
-  
-  //sbrc_hex value of 0x313 seems to be some Cap+ Thing, 
-  //also observed 0x643 on another cap+ system (site id, status? something?)
-  //I've observed it in the Private Cap+ TXI calls as well
-  //there also seems to be a correlation between the SVC bits for TXI (reserved=3) and these extra cap+ values
+    
   uint8_t sbrc_opcode = sbrc_hex; 
-  uint8_t alg = sbrc_hex & 3;
-  uint16_t key = (sbrc_hex >> 3) & 0xFF;
+  uint8_t alg = sbrc_hex & 0x7;
+  uint8_t key = (sbrc_hex >> 3) & 0xFF;
+  uint8_t cap_site = (sbrc_hex >> 4) & 0x7; //signalling on Cap+ when voice errors (non voice VC6 is present)
 
-  if (opts->payload == 1)
+  if (1 == 1) //opts->payload == 1
   {
-    if (irr_err != 0) fprintf (stderr, "%s (FEC ERR) %d %s", KRED, irr_err, KNRM);
+    if (irr_err != 0) ; //fprintf (stderr, "\n %s SLOT %d SB/RC (FEC ERR) %d %s \n", KRED, slot, irr_err, KNRM);
     if (irr_err == 0)
     {
       if (sbrc_hex == 0) ; //NULL
-      else if (sbrc_hex == 0x313)
+      //else if (placeholder for future conditions)
+      // {
+      //   placeholder for future conditions
+      // }
+      else //Finally have a consistent set-up for this
       {
-        //Cap+ Thing? Observed On Cap+ Systems
-        // fprintf (stderr, " Cap+ Thing?");
-      } 
-      else
-      {
-
-        if (slot == 0)
+        //the signalling here is always presents on good voice frames, if errs are [3][2] then its not a VC6 voice frame, but some other 'hidden' frame
+        if (slot == 0 && state->errs < 3) 
         {
-          //key and alg only present SOME times, not all,
-          //also, intermixed with other signalling
-          //needs more study first!
           if (state->dmr_so & 0x40 && key != 0 && state->payload_keyid == 0)
           {
-            if (opts->payload == 1)
+            //if we aren't forcing a particular alg or privacy key set
+            if (state->M == 0)
             {
               fprintf (stderr, "%s ", KYEL);
-              fprintf (stderr, "\n Slot 1");
+              fprintf (stderr, " Slot 1");
               fprintf (stderr, " DMR LE SB ALG ID: %X KEY ID: %0X", alg + 0x20, key);
+              fprintf (stderr, "\n");
               fprintf (stderr, "%s ", KNRM);
+
+              state->payload_keyid = key;
+              state->payload_algid = alg + 0x20; //assuming DMRA approved alg values (moto patent)
             }
-            
-            //needs more study before assignment
-            //state->payload_keyid = key;
-            //state->payload_algid = alg + 0x20; //assuming DMRA approved alg values (moto patent)
+
           }
         }
-        if (slot == 1)
+
+        //the signalling here is always presents on good voice frames, if errs are [3][2] then its not a VC6 voice frame, but some other 'hidden' frame
+        if (slot == 1 && state->errsR < 3)
         {
           if (state->dmr_soR & 0x40 && key != 0 && state->payload_keyidR == 0)
           {
-            if (opts->payload == 1)
+            //if we aren't forcing a particular alg or privacy key set
+            if (state->M == 0)
             {
               fprintf (stderr, "%s ", KYEL);
-              fprintf (stderr, "\n Slot 2");
+              fprintf (stderr, " Slot 1");
               fprintf (stderr, " DMR LE SB ALG ID: %X KEY ID: %0X", alg + 0x20, key);
+              fprintf (stderr, "\n");
               fprintf (stderr, "%s ", KNRM);
+
+              state->payload_keyidR = key;
+              state->payload_algidR = alg + 0x20; //assuming DMRA approved alg values (moto patent)
             }
-            
-            //needs more study before assignment
-            //state->payload_keyidR = key;
-            //state->payload_algidR = alg + 0x20; //assuming DMRA approved alg values (moto patent)
+
           }
         }
 

src/dmr_pdu.c

@@ -44,21 +44,20 @@ void dmr_pdu (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR
   uint8_t padding = state->data_header_padding[slot];
   uint8_t lrrp_conf = 0;
 
-  //consider disabling on prop_head data blocks if bad/false decodes
-  //if (state->data_p_head[slot] == 0)
-   lrrp_conf = dmr_lrrp (opts, state, block_len, DMR_PDU);
+  //check for more available flag info, etc on these prior to running
+  if (DMR_PDU[0] == 0x01) dmr_locn (opts, state, block_len, DMR_PDU);
+  else dmr_lrrp (opts, state, block_len, DMR_PDU);
 
   //maybe one day we will have more things to do here
   state->data_conf_data[slot] = 0; //flag off confirmed data after processing it 
   state->data_p_head[slot] = 0; //flag off prop_head data after processing it
-  state->data_header_format[slot] = 0; //zero out so we don't keep ascii printing
   
 }
 
 //The contents of this function are mostly my reversed engineered efforts by observing DSDPlus output and matching data bytes
 //combined with a few external sources such as OK-DMR for some token values and extra data values (rad and alt)
 //this is by no means an extensive LRRP list and is prone to error (unless somebody has the manual or something)
-uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR_PDU[])
+void dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR_PDU[])
 {
   int i, j;
   uint16_t message_len = 0;
@@ -83,12 +82,15 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
 
   //lat-long-radius-alt
   uint32_t lat = 0;
-  uint8_t lat_sign = 0;
   uint32_t lon = 0;
-  uint16_t rad = 0;
+  uint16_t rad = 0; //or Azimuth in Circle 3D?
   uint8_t alt = 0;
   double lat_unit = (double)180/(double)4294967295;
   double lon_unit = (double)360/(double)4294967295;
+  double lat_fin = 0.0; //calculated values
+  double lon_fin = 0.0; //calculated values
+  int lat_sign = 1; //positive 1, or negative 1
+  int lon_sign = 1; //positive 1, or negative 1
 
   //speed/velocity
   uint16_t vel = 0;
@@ -97,28 +99,19 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
 
   //track, direction, degrees
   uint8_t degrees = 0;
-  uint8_t deg_set = 0; 
+  uint8_t deg_set = 0;
+
+  char deg_glyph[4];
+  sprintf (deg_glyph, "%s", "°");
+  // sprintf (deg_glyph, "%s", "d"); 
 
   //triggered information report
   uint8_t report = 0;
   uint8_t pot_report = 0; //potential report by finding 0x0D and backtracking a few bytes
 
-  uint8_t is_p_head = 0;
 
-  //shim for getting LRRP out of some prop head data blocks
-  if (state->data_p_head[slot] == 1)
-  {
-    if (DMR_PDU[1] != 0x10) goto LRRP_END; //check to see if FID is 0x10
-    i = 0;
-    message_len = blocks * block_len; 
-    source = state->dmr_lrrp_source[state->currentslot];
-    is_p_head = 1;
-  }
-  else i = 12; 
-
-  
   //start looking for tokens (using my best understanding of the ok-dmr library xml and python files)
-  for (i; i < ( (blocks*block_len) - (padding+4) ); i++) 
+  for (i = 0; i < ( (blocks*block_len) - (padding+4) ); i++) 
   {
 
     switch(DMR_PDU[i]){
@@ -175,20 +168,22 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
         }
         break;
       //RESULT TOKEN or Request ID!
+      case 0x22: //same comment as below, observed followed the message len
       case 0x23: //this value has been seen after the 0x0D message len, appears to be a 2-byte value, was tripping a false on time stamp 
         i += 2;
         break; 
       //answer and report tokens
       case 0x51: //circle-2d
       case 0x54: //circle-3d
-      case 0x55: //circle-3d <- false positives on one sample, so either an earlier token occurred (that we don't have) or just random data?
+      case 0x55: //circle-3d 
         if (message_len > 0 && lat == 0)
         {
-          if (DMR_PDU[i+1] & 0x80) lat_sign = 1;
-          lat = ( ( ((DMR_PDU[i+1] & 0x7F ) <<  24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
+          // lat = ( ( ((DMR_PDU[i+1] & 0x7F ) <<  24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
+          // lon = ( ( ((DMR_PDU[i+5] & 0x7F ) <<  24 ) + (DMR_PDU[i+6] << 16) + (DMR_PDU[i+7] << 8) + DMR_PDU[i+8]) * 1 );
+          lat = ( ( (DMR_PDU[i+1]           <<  24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
           lon = ( ( (DMR_PDU[i+5]           <<  24 ) + (DMR_PDU[i+6] << 16) + (DMR_PDU[i+7] << 8) + DMR_PDU[i+8]) * 1 );
           rad = (DMR_PDU[i+9] << 8) + DMR_PDU[i+10];
-          i += 10; //double check
+          i += 10; 
           if (lat > 0 && lon > 0) lrrp_confidence++; //would be better to set by absolute boundary (180 and 90?)
           else lat = 0;
         }
@@ -211,13 +206,14 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
         }
         break;
       
-      case 0x66: //point-2d
+      case 0x66: //point-2d 
         if (message_len > 0 && lat == 0)
         {
-          if (DMR_PDU[i+1] & 0x80) lat_sign = 1;
-          lat = ( ( ((DMR_PDU[i+1] & 0x7F ) <<  24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
+          // lat = ( ( ((DMR_PDU[i+1] & 0x7F ) <<  24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
+          // lon = ( ( ((DMR_PDU[i+5] & 0x7F ) <<  24 ) + (DMR_PDU[i+6] << 16) + (DMR_PDU[i+7] << 8) + DMR_PDU[i+8]) * 1 );
+          lat = ( ( (DMR_PDU[i+1]           <<  24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
           lon = ( ( (DMR_PDU[i+5]           <<  24 ) + (DMR_PDU[i+6] << 16) + (DMR_PDU[i+7] << 8) + DMR_PDU[i+8]) * 1 );
-          i += 8; //check
+          i += 8; 
           lrrp_confidence++;
         }
         break;
@@ -225,12 +221,13 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
       case 0x6A: //point-3d
         if (message_len > 0 && lat == 0)
         {
-          if (DMR_PDU[i+1] & 0x80) lat_sign = 1;
-          lat = ( ( ((DMR_PDU[i+1] & 0x7F ) <<  24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
+          // lat = ( ( ((DMR_PDU[i+1] & 0x7F ) <<  24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
+          // lon = ( ( ((DMR_PDU[i+5] & 0x7F ) <<  24 ) + (DMR_PDU[i+6] << 16) + (DMR_PDU[i+7] << 8) + DMR_PDU[i+8]) * 1 );
+          lat = ( ( (DMR_PDU[i+1]           <<  24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
           lon = ( ( (DMR_PDU[i+5]           <<  24 ) + (DMR_PDU[i+6] << 16) + (DMR_PDU[i+7] << 8) + DMR_PDU[i+8]) * 1 );
           alt =  DMR_PDU[i+9];
-          i += 9; //check
-          if (lat > 0 && lon > 0) lrrp_confidence++; //would be better to set by absolute boundary (180 and 90?)
+          i += 9; 
+          if (lat > 0 && lon > 0) lrrp_confidence++; 
           else lat = 0;
         }
         break;
@@ -274,7 +271,7 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
   {
     fprintf (stderr, "%s", KYEL);
     fprintf (stderr, "\n LRRP Confidence: %d - Message Len: %d Octets", lrrp_confidence, message_len);
-    if (lrrp_confidence >= 4) //find the sweet magical number
+    if (lrrp_confidence >= 3) //find the sweet magical number
     {
       //now we can open our lrrp file and write to it as well
       FILE * pFile; //file pointer
@@ -286,9 +283,10 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
         if (!year) fprintf (pFile, "%s\t", getDateL() ); //current date, only add this IF no included timestamp in LRRP data?
         if (!year) fprintf (pFile, "%s\t", getTimeL() ); //current timestamp, only add this IF no included timestamp in LRRP data?
         if (year) fprintf (pFile, "%04d/%02d/%02d\t%02d:%02d:%02d\t", year, month, day, hour, minute, second); //add timestamp from decoded audio if available
-        //write data header source (or destination?) if not available in lrrp data
+        //write data header source if not available in lrrp data
         if (!source) fprintf (pFile, "%08lld\t", state->dmr_lrrp_source[state->currentslot]); //source address from data header
         if (source) fprintf (pFile, "%08d\t", source); //add source form decoded audio if available, else its from the header
+
       }
 
       if (pot_report)
@@ -328,31 +326,45 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
       if (lat)
       {
         fprintf (stderr, "\n");
-        if (lat_sign) //print a '-' in front of the value
-          fprintf (stderr, "  LRRP - Lat: -%.5lf", (double)lat * lat_unit);
-        else fprintf (stderr, "  LRRP - Lat: %.5lf", (double)lat * lat_unit);
-        fprintf (stderr, "  Lon: %.5lf", (double)lon * lon_unit);
-        if (lat_sign)
-          fprintf (stderr, " (-%.5lf, %.5lf)", (double)lat * lat_unit , (double)lon * lon_unit);
-        else fprintf (stderr, " (%.5lf, %.5lf)", (double)lat * lat_unit , (double)lon * lon_unit);
+        //need to check these new calcs for accuracy accross the globe, both lat and lon
+
+        //two's compliment-ish testing on these bytes
+        if (lat & 0x80000000) //8
+        {
+          lat = lat & 0x7FFFFFFF;
+          lat_sign = -1;
+          // lat = 0x80000000 - lat; //not sure why this doesn't work here like it does on lon, extra bit? 
+        } 
+        if (lon & 0x80000000)
+        {
+          lon = lon & 0x7FFFFFFF;
+          lon_sign = -1;
+          lon = 0x80000000 - lon;
+        } 
+
+        lat_fin = (double)lat * lat_unit * lat_sign;
+        lon_fin = (double)lon * lon_unit * lon_sign;
+
+        fprintf (stderr, "  LRRP - Lat: %.5lf", lat_fin);
+        fprintf (stderr, "  Lon: %.5lf", lon_fin);
+        fprintf (stderr, " (%.5lf, %.5lf)", lat_fin , lon_fin);
 
         if (opts->lrrp_file_output == 1)
         {
-          if (lat_sign) fprintf (pFile, "-");
-          fprintf (pFile, "%.5lf\t", (double)lat * lat_unit);
-          fprintf (pFile, "%.5lf\t", (double)lon * lon_unit);
+          fprintf (pFile, "%.5lf\t", lat_fin);
+          fprintf (pFile, "%.5lf\t", lon_fin);
         }
 
       }
       if (rad)
       {
         fprintf (stderr, "\n");
-        fprintf (stderr, "  LRRP - Radius: %d", rad); //unsure of 'units' or calculation for radius (meters?)
+        fprintf (stderr, "  LRRP - Radius: %dm", rad); //unsure of 'units' or calculation for radius (meters?)
       }
       if (alt)
       {
         fprintf (stderr, "\n");
-        fprintf (stderr, "  LRRP - Altitude: %d", alt); //unsure of 'units' or calculation for alt (meters?)
+        fprintf (stderr, "  LRRP - Altitude: %dm", alt); //unsure of 'units' or calculation for alt (meters?)
       }
       if (vel_set)
       {
@@ -363,7 +375,7 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
       if (deg_set)
       {
         fprintf (stderr, "\n");
-        fprintf (stderr, "  LRRP - Track: %d Degrees", degrees);
+        fprintf (stderr, "  LRRP - Track: %d%s", degrees, deg_glyph);
         if (opts->lrrp_file_output == 1) fprintf (pFile, "%d\t",degrees);
       }
 
@@ -374,20 +386,17 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
         fclose (pFile);
       }
 
-      //save to array for ncurses
+      //save to string for ncurses
       if (!source) source = state->dmr_lrrp_source[state->currentslot];
-      char sign[8];
       char velstr[20];
       char degstr[20];
       char lrrpstr[100];
       sprintf (lrrpstr, "%s", "");
       sprintf (velstr, "%s", "");
       sprintf (degstr, "%s", "");
-      if (lat_sign) sprintf (sign, "%s", "-");
-      else sprintf (sign, "%s", ""); 
-      if (lat) sprintf (lrrpstr, "LRRP %0d (%s%lf, %lf)", source, sign, (double)lat * lat_unit, (double)lon * lon_unit);
+      if (lat) sprintf (lrrpstr, "LRRP %0d (%lf, %lf)", source, lat_fin, lon_fin);
       if (vel_set) sprintf (velstr, " %.4lf km/h", velocity * 3.6);
-      if (deg_set) sprintf (degstr, " %d deg", degrees);
+      if (deg_set) sprintf (degstr, " %d%s  ", degrees, deg_glyph);
       sprintf (state->dmr_lrrp_gps[slot], "%s%s%s", lrrpstr, velstr, degstr);
       
     }
@@ -400,16 +409,126 @@ uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t
     fprintf (stderr, "  Potential ARRP/LRRP Report (Debug): 0x%02X", report);
   }
 
-  // else //debug only, disabled
-  // {
-  //   fprintf (stderr, "\n");
-  //   fprintf (stderr, "\n LRRP Confidence: %d - Message Len: %d Octets", lrrp_confidence, message_len);
-  // }
-
   LRRP_END:
 
   fprintf (stderr, "%s", KNRM);
   
-  
-  return (lrrp_confidence);
+}
+
+void dmr_locn (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR_PDU[])
+{
+  int i, j;
+  uint8_t slot = state->currentslot;
+  uint8_t blocks = state->data_header_blocks[slot];
+  uint8_t padding = state->data_header_padding[slot];
+  uint8_t source = state->dmr_lrrp_source[slot];
+
+  //flags if certain data type is present
+  uint8_t time = 0;
+  uint8_t lat  = 0;
+  uint8_t lon  = 0;
+
+  //date-time variables
+  uint8_t hour = 0;
+  uint8_t minute = 0;
+  uint8_t second = 0;
+  uint8_t year = 0;
+  uint8_t month = 0;
+  uint8_t day = 0;
+
+  //need to experiment best way to do this portion
+  uint8_t  lat_deg = 0;
+  uint8_t  lat_min = 0;
+  uint16_t lat_sec = 0;
+
+  uint8_t  lon_deg = 0;
+  uint8_t  lon_min = 0;
+  uint16_t lon_sec = 0;
+
+  char lat_ord[2];
+  char lon_ord[2];
+  sprintf (lat_ord, "%s", "N");
+  sprintf (lon_ord, "%s", "E");
+
+  char deg_glyph[4];
+  sprintf (deg_glyph, "%s", "°");
+  // sprintf (deg_glyph, "%s", "d");
+
+  //more strings...
+  char locnstr[50];
+  char latstr[75];
+  char lonstr[75];
+  sprintf (locnstr, "%s", "     ");
+  sprintf (latstr, "%s", "     ");
+  sprintf (lonstr, "%s", "     ");
+
+  //TODO: conversion to decimal format
+  //DD = d + (min/60) + (sec/3600)
+  //N is positive, E is positive?? Assuming its like a 2D plane
+  int lat_sign = 1; //positive 1 or negative 1
+  int lon_sign = 1; //positive 1 or negative 1
+  double lat_fin = 0;
+  double lon_fin = 0;
+
+  //start looking for specific bytes corresponding to 'letters' A (time), NSEW (ordinal directions), etc
+  for (i = 0; i < ( (blocks*block_len) - (padding+4) ); i++)
+  {
+    switch(DMR_PDU[i]){
+      case 0x41: //A -- time and date
+        time   = 1;
+        hour   = ((DMR_PDU[i+1] - 0x30) << 4) | (DMR_PDU[i+2] - 0x30);
+        minute = ((DMR_PDU[i+3] - 0x30) << 4) | (DMR_PDU[i+4] - 0x30);
+        second = ((DMR_PDU[i+5] - 0x30) << 4) | (DMR_PDU[i+6] - 0x30);
+        //think this is in day, mon, year format
+        day   = ((DMR_PDU[i+7] -  0x30) << 4) | (DMR_PDU[i+8] - 0x30);
+        month = ((DMR_PDU[i+9] -  0x30) << 4) | (DMR_PDU[i+10] - 0x30);
+        year  = ((DMR_PDU[i+11] - 0x30) << 4) | (DMR_PDU[i+12] - 0x30);
+        i += 12; 
+        break;
+      
+      case 0x53: //S -- South
+        sprintf (lat_ord, "%s", "S");
+        lat_sign = -1;
+      case 0x4E: //N -- North
+        lat     = 1;
+        lat_deg = ((DMR_PDU[i+1] - 0x30) << 4) | (DMR_PDU[i+2] - 0x30);
+        lat_min = ((DMR_PDU[i+3] - 0x30) << 4) | (DMR_PDU[i+4] - 0x30);
+        lat_sec = ((DMR_PDU[i+6] - 0x30) << 12) | ((DMR_PDU[i+7] - 0x30) << 8) | ((DMR_PDU[i+8] - 0x30) << 4) | ((DMR_PDU[i+9] - 0x30) << 0);
+        i += 8;
+        break;
+      
+      case 0x57: //W -- West
+        sprintf (lon_ord, "%s", "W");
+        lon_sign = -1;
+      case 0x45: //E -- East
+        lon     = 1; 
+        lon_deg = ((DMR_PDU[i+1] - 0x30) << 8) | ((DMR_PDU[i+2] - 0x30) << 4) | ((DMR_PDU[i+3] - 0x30) << 0);
+        lon_min = ((DMR_PDU[i+4] - 0x30) << 4) | (DMR_PDU[i+5] - 0x30);
+        lon_sec = ((DMR_PDU[i+7] - 0x30) << 12) | ((DMR_PDU[i+8] - 0x30) << 8) | ((DMR_PDU[i+9] - 0x30) << 4) | ((DMR_PDU[i+10] - 0x30) << 0);
+        i += 8;
+        break;
+
+      default:
+        //do nothing
+        break;
+
+    } //end switch
+
+  } //for i 
+
+  if (lat && lon)
+  {
+    fprintf (stderr, "%s", KYEL);
+    fprintf (stderr, "\n LOCN Report - Source: [%d]\n", source);
+    if (time) fprintf (stderr, "  20%02X/%02X/%02X %02X:%02X:%02X ", year, month, day, hour, minute, second);
+    fprintf (stderr, "Lat: %s %02X%s%02X\"%04X' Lon: %s %02X%s%02X\"%04X' ", lat_ord, lat_deg, deg_glyph, lat_min, lat_sec, lon_ord, lon_deg, deg_glyph, lon_min, lon_sec);
+
+    //string manip for ncurses terminal display
+    sprintf (locnstr, "LOCN %d ", source);
+    sprintf (latstr, "%s %02X%s%02X\"%04X' ", lat_ord, lat_deg, deg_glyph, lat_min, lat_sec);
+    sprintf (lonstr, "%s %02X%s%02X\"%04X' ", lon_ord, lon_deg, deg_glyph, lon_min, lon_sec);
+    sprintf (state->dmr_lrrp_gps[slot], "%s%s%s", locnstr, latstr, lonstr);
+
+  } 
+
 }

src/dmr_pi.c

@@ -15,15 +15,11 @@ void dmr_pi (dsd_opts * opts, dsd_state * state, uint8_t PI_BYTE[], uint32_t CRC
 
   if((IrrecoverableErrors == 0)) 
   {
+
     if (state->currentslot == 0)
     {
-
-      if (0 == 0) 
-      {
-        state->payload_algid = PI_BYTE[0];
-        state->payload_keyid = PI_BYTE[2];
-      }
-
+      state->payload_algid = PI_BYTE[0];
+      state->payload_keyid = PI_BYTE[2];
       state->payload_mi    = ( ((PI_BYTE[3]) << 24) + ((PI_BYTE[4]) << 16) + ((PI_BYTE[5]) << 8) + (PI_BYTE[6]) );
       if (state->payload_algid < 0x26) 
       {
@@ -31,27 +27,26 @@ void dmr_pi (dsd_opts * opts, dsd_state * state, uint8_t PI_BYTE[], uint32_t CRC
         fprintf (stderr, "\n Slot 1");
         fprintf (stderr, " DMR PI H- ALG ID: 0x%02X KEY ID: 0x%02X MI: 0x%08X", state->payload_algid, state->payload_keyid, state->payload_mi);
         fprintf (stderr, "%s ", KNRM);
+        if (state->payload_algid != 0x21)
+        {
+          fprintf (stderr, "\n");
+          LFSR64 (state);
+        } 
       }
 
       if (state->payload_algid >= 0x26)
       {
-        if (0 == 0) 
-        {
-          state->payload_algid = 0;
-          state->payload_keyid = 0;
-          state->payload_mi = 0;
-        }
+        state->payload_algid = 0;
+        state->payload_keyid = 0;
+        state->payload_mi = 0;
       }
     }
 
     if (state->currentslot == 1)
     {
-      if (0 == 0) 
-      {
-        state->payload_algidR = PI_BYTE[0];
-        state->payload_keyidR = PI_BYTE[2];
-      }
 
+      state->payload_algidR = PI_BYTE[0];
+      state->payload_keyidR = PI_BYTE[2];
       state->payload_miR    = ( ((PI_BYTE[3]) << 24) + ((PI_BYTE[4]) << 16) + ((PI_BYTE[5]) << 8) + (PI_BYTE[6]) );
       if (state->payload_algidR < 0x26) 
       {
@@ -59,20 +54,23 @@ void dmr_pi (dsd_opts * opts, dsd_state * state, uint8_t PI_BYTE[], uint32_t CRC
         fprintf (stderr, "\n Slot 2");
         fprintf (stderr, " DMR PI H- ALG ID: 0x%02X KEY ID: 0x%02X MI: 0x%08X", state->payload_algidR, state->payload_keyidR, state->payload_miR);
         fprintf (stderr, "%s ", KNRM);
+        if (state->payload_algidR != 0x21)
+        {
+          fprintf (stderr, "\n");
+          LFSR64 (state);
+        } 
       }
 
       if (state->payload_algidR >= 0x26)
       {
-        if (0== 0) 
-        {
-          state->payload_algidR = 0;
-          state->payload_keyidR = 0;
-          state->payload_miR = 0;
-        }
+        state->payload_algidR = 0;
+        state->payload_keyidR = 0;
+        state->payload_miR = 0;
       }
+
     }
+
   }
-  
 }
 
 void LFSR(dsd_state * state)
@@ -95,27 +93,64 @@ void LFSR(dsd_state * state)
 
   if (state->currentslot == 0)
   {
-    if (1 == 1)
-    {
-      fprintf (stderr, "%s", KYEL);
-      fprintf (stderr, " Slot 1");
-      fprintf (stderr, " DMR PI C- ALG ID: 0x%02X KEY ID: 0x%02X", state->payload_algid, state->payload_keyid);
-      fprintf(stderr, " Next MI: 0x%08X", lfsr);
-      fprintf (stderr, "%s", KNRM);
-    }
+    fprintf (stderr, "%s", KYEL);
+    fprintf (stderr, " Slot 1");
+    fprintf (stderr, " DMR PI C- ALG ID: 0x%02X KEY ID: 0x%02X", state->payload_algid, state->payload_keyid);
+    fprintf(stderr, " MI: 0x%08X", lfsr);
+    fprintf (stderr, "%s", KNRM);
     state->payload_mi = lfsr;
   }
 
   if (state->currentslot == 1) 
   {
-    if (1 == 1)
+
+    fprintf (stderr, "%s", KYEL);
+    fprintf (stderr, " Slot 2");
+    fprintf (stderr, " DMR PI C- ALG ID: 0x%02X KEY ID: 0x%02X", state->payload_algidR, state->payload_keyidR);
+    fprintf(stderr, " MI: 0x%08X", lfsr);
+    fprintf (stderr, "%s", KNRM);
+    state->payload_miR = lfsr;
+  }
+}
+
+void LFSR64(dsd_state * state)
+{
+	{
+    unsigned long long int lfsr = 0;
+
+		if (state->currentslot == 0)
+		{
+			lfsr = (uint64_t) state->payload_mi; 
+		}
+    else lfsr = (uint64_t) state->payload_miR; 
+
+    uint8_t cnt = 0;
+
+    for(cnt=0;cnt<32;cnt++) 
     {
+			unsigned long long int bit = ( (lfsr >> 31) ^ (lfsr >> 21) ^ (lfsr >> 1) ^ (lfsr >> 0) ) & 0x1;
+      lfsr = (lfsr << 1) | bit;
+    }
+
+		if (state->currentslot == 0)
+		{
+      fprintf (stderr, "%s", KYEL);
+      fprintf (stderr, " Slot 1");
+      fprintf (stderr, " DMR PI C- ALG ID: 0x%02X KEY ID: 0x%02X", state->payload_algid, state->payload_keyid);
+      fprintf (stderr, " MI: 0x%016llX", lfsr);
+      fprintf (stderr, "%s", KNRM);
+			state->payload_mi = lfsr & 0xFFFFFFFF; //truncate for next repitition and le verification
+		}
+
+		if (state->currentslot == 1)
+		{
       fprintf (stderr, "%s", KYEL);
       fprintf (stderr, " Slot 2");
       fprintf (stderr, " DMR PI C- ALG ID: 0x%02X KEY ID: 0x%02X", state->payload_algidR, state->payload_keyidR);
-      fprintf(stderr, " Next MI: 0x%08X", lfsr);
+      fprintf (stderr, " MI: 0x%016llX", lfsr);
       fprintf (stderr, "%s", KNRM);
-    }
-    state->payload_miR = lfsr;
-  }
+			state->payload_miR = lfsr & 0xFFFFFFFF; //truncate for next repitition and le verification
+		}
+
+	}
 }

src/dmr_utils.c

@@ -325,15 +325,15 @@ uint8_t ComputeCrc5Bit(uint8_t * DMRData)
   return CRC;
 } /* End ComputeCrc5Bit() */
 
-uint32_t ConvertBitIntoBytes(uint8_t * BufferIn, uint32_t BitLength)
+uint64_t ConvertBitIntoBytes(uint8_t * BufferIn, uint32_t BitLength)
  {
-   uint32_t Output = 0;
+   uint64_t Output = 0;
    uint32_t i;
 
    for(i = 0; i < BitLength; i++)
    {
      Output <<= 1;
-     Output |= (uint32_t)(BufferIn[i] & 1);
+     Output |= (uint64_t)(BufferIn[i] & 1);
    }
 
    return Output;

src/dsd_audio.c

@@ -545,6 +545,9 @@ openAudioInDevice (dsd_opts * opts)
   const char ch = '.';
   extension = strrchr(opts->audio_in_dev, ch); //return extension if this is a .wav or .bin file
 
+  //if no extension set, give default of .wav -- bugfix for github issue #105
+  // if (extension == NULL) extension = ".wav";
+
   // get info of device/file
 	if (strncmp(opts->audio_in_dev, "-", 1) == 0)
 	{
@@ -597,7 +600,15 @@ openAudioInDevice (dsd_opts * opts)
   }
   else if(strncmp(opts->audio_in_dev, "rtl", 3) == 0)
   {
+    #ifdef USE_RTLSDR
     opts->audio_in_type = 3;
+    #elif AERO_BUILD
+    opts->audio_in_type = 5;
+    sprintf (opts->audio_in_dev, "/dev/dsp");
+    #else
+    opts->audio_in_type = 0;
+    sprintf (opts->audio_in_dev, "pulse");
+    #endif
   }
   else if(strncmp(opts->audio_in_dev, "pulse", 5) == 0)
   {
@@ -607,6 +618,25 @@ openAudioInDevice (dsd_opts * opts)
   {
     opts->audio_in_type = 5;
   }
+
+  //if no extension set, treat as named pipe or extensionless wav file -- bugfix for github issue #105
+  else if (extension == NULL)
+  {
+    opts->audio_in_type = 2;
+    opts->audio_in_file_info = calloc(1, sizeof(SF_INFO));
+    opts->audio_in_file_info->samplerate = opts->wav_sample_rate;
+    opts->audio_in_file_info->channels = 1;
+    opts->audio_in_file_info->seekable = 0;
+    opts->audio_in_file_info->format = SF_FORMAT_RAW | SF_FORMAT_PCM_16 | SF_ENDIAN_LITTLE;
+    opts->audio_in_file = sf_open(opts->audio_in_dev, SFM_READ, opts->audio_in_file_info);
+
+    if (opts->audio_in_file == NULL)
+    {
+      fprintf(stderr, "Error, couldn't open file/pipe with libsndfile: %s\n", sf_strerror(NULL));
+      exit(1);
+    }
+  }
+
   else if (strncmp(extension, ".bin", 3) == 0)
 	{
     struct stat stat_buf;

src/dsd_dibit.c

@@ -283,13 +283,12 @@ static int digitize (dsd_opts* opts, dsd_state* state, int symbol)
 
       valid = 0;
 
-      //only run estimate_symbol when we aren't trunking, otherwise noise/gain levels on other rf channels may impact performance severely
-      //honestly can't say I've seen any improvement when using heuristics, but is detrimental to playing back multiple p25 samples
-      if (state->synctype == 1 && opts->p25_trunk == 0) 
-        {
-          // Use the P25 heuristics if available
-          //valid = estimate_symbol(state->rf_mod, &(state->inv_p25_heuristics), state->last_dibit, symbol, &dibit);
-        }
+      //testing again, either on Voice channels only (when tuned) or with trunk disabled
+      if (state->synctype == 1 && (opts->p25_is_tuned == 1 || opts->p25_trunk == 0) && opts->use_heuristics == 1)
+      {
+        // Use the P25p1 heuristics if available
+        valid = estimate_symbol(state->rf_mod, &(state->inv_p25_heuristics), state->last_dibit, symbol, &dibit);
+      }
 
       if (valid == 0)
         {
@@ -348,13 +347,12 @@ static int digitize (dsd_opts* opts, dsd_state* state, int symbol)
 
       valid = 0;
 
-      //only run estimate_symbol when we aren't trunking, otherwise noise/gain levels on other rf channels may impact performance severely
-      //honestly can't say I've seen any improvement when using heuristics, but is detrimental to playing back multiple p25 samples
-      if (state->synctype == 0 && opts->p25_trunk == 0)
-        {
-          // Use the P25 heuristics if available
-          //valid = estimate_symbol(state->rf_mod, &(state->p25_heuristics), state->last_dibit, symbol, &dibit);
-        }
+      //testing again, either on Voice channels only (when tuned) or with trunk disabled
+      if (state->synctype == 0 && (opts->p25_is_tuned == 1 || opts->p25_trunk == 0) && opts->use_heuristics == 1)
+      {
+        // Use the P25p1 heuristics if available
+        valid = estimate_symbol(state->rf_mod, &(state->p25_heuristics), state->last_dibit, symbol, &dibit);
+      }
 
       if (valid == 0)
         {

src/dsd_frame.c

@@ -486,10 +486,6 @@ processFrame (dsd_opts * opts, dsd_state * state)
       state->currentslot = 0;
       sprintf (state->fsubtype, " LDU1         ");
       state->numtdulc = 0;
-      if (state->payload_algid == 0x81)
-      {
-        fprintf (stderr, "\n");
-      }
 
       processLDU1 (opts, state);
     }
@@ -542,8 +538,8 @@ processFrame (dsd_opts * opts, dsd_state * state)
         if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state);
       }
       mbe_initMbeParms (state->cur_mp, state->prev_mp, state->prev_mp_enhanced);
-      state->lasttg = 0;
-      state->lastsrc = 0;
+      // state->lasttg = 0;
+      // state->lastsrc = 0;
       state->lastp25type = 0;
       state->err_str[0] = 0;
       sprintf (state->fsubtype, " TDULC        ");
@@ -604,10 +600,11 @@ processFrame (dsd_opts * opts, dsd_state * state)
     }
   else if (strcmp (duid, "30") == 0)
     {
+      state->dmrburstL = 29;
       if (opts->errorbars == 1)
       {
         printFrameInfo (opts, state);
-        fprintf (stderr," PDU\n"); //multi block/packet PDU
+        fprintf (stderr," MBF\n"); //multi block format PDU
       }
       if (opts->mbe_out_dir[0] != 0)
       {
@@ -619,79 +616,11 @@ processFrame (dsd_opts * opts, dsd_state * state)
         resumeScan (opts, state);
       }
       state->lastp25type = 4;
-      sprintf (state->fsubtype, " PDU          ");
+      sprintf (state->fsubtype, " MBF          ");
+
+      processMPDU(opts, state);
     }
 
-  // try to guess based on previous frame if unknown type
-  // disabling the guessing game on P1
-
-  // else if (state->lastp25type == 1)
-  //   {
-  //     if (opts->errorbars == 1)
-  //       {
-  //         printFrameInfo (opts, state);
-  //         fprintf (stderr,"(LDU2) ");
-  //       }
-  //     // if (opts->mbe_out_dir[0] != 0)
-  //     //   {
-  //     //     if (opts->mbe_out_f == NULL)
-  //     //       {
-  //     //         openMbeOutFile (opts, state);
-  //     //       }
-  //     //   }
-  //     //state->lastp25type = 0;
-  //     // Guess that the state is LDU2
-  //     state->lastp25type = 2;
-  //     sprintf (state->fsubtype, "(LDU2)        ");
-  //     state->numtdulc = 0;
-  //     processLDU2 (opts, state);
-  //   }
-  // else if (state->lastp25type == 2)
-  //   {
-  //     if (opts->errorbars == 1)
-  //       {
-  //         printFrameInfo (opts, state);
-  //         fprintf (stderr,"(LDU1) ");
-  //       }
-  //     if (opts->mbe_out_dir[0] != 0)
-  //       {
-  //         if (opts->mbe_out_f == NULL)
-  //           {
-  //             openMbeOutFile (opts, state);
-  //           }
-  //       }
-  //     //state->lastp25type = 0;
-  //     // Guess that the state is LDU1
-  //     state->lastp25type = 1;
-  //     sprintf (state->fsubtype, "(LDU1)        ");
-  //     state->numtdulc = 0;
-  //     processLDU1 (opts, state);
-  //   }
-  // else if (state->lastp25type == 3)
-  //   {
-  //     if (opts->errorbars == 1)
-  //       {
-  //         printFrameInfo (opts, state);
-  //         fprintf (stderr," (TSBK)\n");
-  //       }
-  //     //state->lastp25type = 0;
-  //     // Guess that the state is TSBK
-  //     state->lastp25type = 3;
-  //     sprintf (state->fsubtype, "(TSBK)        ");
-
-  //     // Now processing NID
-  //     skipDibit (opts, state, 328-25);
-  //   }
-  // else if (state->lastp25type == 4)
-  //   {
-  //     if (opts->errorbars == 1)
-  //       {
-  //         printFrameInfo (opts, state);
-  //         fprintf (stderr," (PDU)\n");
-  //       }
-  //     state->lastp25type = 0;
-  //   }
-
   else
   {
     state->lastp25type = 0;
@@ -699,8 +628,8 @@ processFrame (dsd_opts * opts, dsd_state * state)
     if (opts->errorbars == 1)
     {
       printFrameInfo (opts, state);
-      fprintf (stderr," duid:%s *Unknown DUID*\n", duid); //prints on dPMR frame 3
-      // fprintf (stderr, "\n"); //prints on dPMR frame 3
+      // fprintf (stderr," duid:%s *Unknown DUID*\n", duid);
+      fprintf (stderr," duid:%s \n", duid); //DUID ERR
     }
   }
 }

src/dsd_frame_sync.c

@@ -150,7 +150,7 @@ getFrameSync (dsd_opts * opts, dsd_state * state)
 
   //start control channel hunting if using trunking, time needs updating on each successful sync
   //will need to assign frequencies to a CC array for P25 since that isn't imported from CSV
-  if (state->dmr_rest_channel == -1 && opts->p25_is_tuned == 0 && opts->p25_trunk == 1 && ( (time(NULL) - state->last_cc_sync_time) > (opts->trunk_hangtime + 2) ) )
+  if (state->dmr_rest_channel == -1 && opts->p25_is_tuned == 0 && opts->p25_trunk == 1 && ( (time(NULL) - state->last_cc_sync_time) > (opts->trunk_hangtime + 0) ) ) //was 3, go to hangtime value
   {
 
     //test to switch back to 10/4 P1 QPSK for P25 FDMA CC
@@ -163,10 +163,23 @@ getFrameSync (dsd_opts * opts, dsd_state * state)
     //start going through the lcn/frequencies CC/signal hunting
     fprintf (stderr, "Control Channel Signal Lost. Searching for Control Channel.\n");
     //make sure our current roll value doesn't exceed value of frequencies imported
-    if (state->lcn_freq_roll > state->lcn_freq_count)
+    if (state->lcn_freq_roll >= state->lcn_freq_count) //fixed this to skip the extra wait out at the end of the list
     {
       state->lcn_freq_roll = 0; //reset to zero
     }
+    //roll an extra value up if the current is the same as what's already loaded -- faster hunting on Cap+, etc
+    if (state->lcn_freq_roll != 0)
+    {
+      if (state->trunk_lcn_freq[state->lcn_freq_roll-1] == state->trunk_lcn_freq[state->lcn_freq_roll])
+      {
+        state->lcn_freq_roll++;
+        //check roll again if greater than expected, then go back to zero
+        if (state->lcn_freq_roll >= state->lcn_freq_count) 
+        {
+          state->lcn_freq_roll = 0; //reset to zero
+        } 
+      }
+    }
     //check that we have a non zero value first, then tune next frequency
     if (state->trunk_lcn_freq[state->lcn_freq_roll] != 0) 
     {
@@ -176,13 +189,15 @@ getFrameSync (dsd_opts * opts, dsd_state * state)
         if (opts->setmod_bw != 0 )  SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
         SetFreq(opts->rigctl_sockfd, state->trunk_lcn_freq[state->lcn_freq_roll]);
       }
-      //rtludp
+      //rtl
       if (opts->audio_in_type == 3)
       {
-        rtl_udp_tune (opts, state, state->trunk_lcn_freq[state->lcn_freq_roll]);
+        #ifdef USE_RTLSDR
+        rtl_dev_tune (opts, state->trunk_lcn_freq[state->lcn_freq_roll]);
+        #endif
       }
       
-      fprintf (stderr, "Tuning to Control Channel Frequency: %.06lf MHz\n", 
+      fprintf (stderr, "Tuning to Frequency: %.06lf MHz\n", 
                 (double)state->trunk_lcn_freq[state->lcn_freq_roll]/1000000);
 
     }
@@ -218,10 +233,10 @@ getFrameSync (dsd_opts * opts, dsd_state * state)
   {
     t_max = 12; //based on Frame_Sync_2 pattern
   }
-  //if Phase 2 (or YSF in future), then only 20
+  //if Phase 2 (or YSF in future), then only 19
   else if (state->lastsynctype == 35 || state->lastsynctype == 36) //P2
   {
-    t_max = 20; 
+    t_max = 19; //Phase 2 S-ISCH is only 19
   }
   else t_max = 24; //24 for everything else
 
@@ -433,6 +448,21 @@ getFrameSync (dsd_opts * opts, dsd_state * state)
               state->minref = state->min;
             }
 
+
+          //if using an rtl input method, do not look for sync patterns if the rms value is lower than our 'soft squelch' level
+          if (opts->audio_in_type == 3 && opts->rtl_rms < opts->rtl_squelch_level) //tests show floor level around 40, and signal breaking 100, default is 100 for level
+          {
+            if (opts->frame_nxdn48 == 1 || opts->frame_nxdn96 == 1 || opts->frame_dpmr == 1)
+            {
+              //should we update min/max here? yes or no?
+
+              // state->max = ((state->max) + lmax) / 2;
+              // state->min = ((state->min) + lmin) / 2;
+
+              goto SYNC_TEST_END;
+            }
+          }
+
           strncpy (synctest, (synctest_p - 23), 24);
           if (opts->frame_p25p1 == 1)
             {
@@ -1263,7 +1293,9 @@ getFrameSync (dsd_opts * opts, dsd_state * state)
                  }
 
             }
-          
+
+          #ifdef NXDNOLDSYNC //Use FSW vs strncmperr method
+
           //NXDN FSW sync and handling - moved to very bottom of sync stack for falsing sanity
           else if ((opts->frame_nxdn96 == 1) || (opts->frame_nxdn48 == 1))
           {
@@ -1279,9 +1311,11 @@ getFrameSync (dsd_opts * opts, dsd_state * state)
               state->min = ((state->min) + lmin) / 2;
               state->lastsynctype = 28;
               state->last_cc_sync_time = time(NULL);
-              //if (opts->payload == 1) fprintf (stderr, "PANDF ");
+              // if (opts->payload == 1) fprintf (stderr, "PANDF ");
+              // fprintf (stderr, " %s ", synctest19);
               return (28);
             }
+            
             else if ( (strncmperr (synctest19, INV_NXDN_PANDFSW, 19, 1) == 0) )
             {
               state->carrier = 1;
@@ -1290,7 +1324,8 @@ getFrameSync (dsd_opts * opts, dsd_state * state)
               state->min = ((state->min) + lmin) / 2;
               state->lastsynctype = 29;
               state->last_cc_sync_time = time(NULL);
-              //if (opts->payload == 1) fprintf (stderr, "PANDF ");
+              // if (opts->payload == 1) fprintf (stderr, "PANDF ");
+              // fprintf (stderr, " %s ", synctest19);
               return (29);
             }
 
@@ -1304,7 +1339,8 @@ getFrameSync (dsd_opts * opts, dsd_state * state)
               if (state->lastsynctype == 28) 
               {
                 state->last_cc_sync_time = time(NULL);
-                //if (opts->payload == 1) fprintf (stderr, "FSW   ");
+                // if (opts->payload == 1) fprintf (stderr, "FSW   ");
+                // fprintf (stderr, " %s ", synctest10);
                 return (28);
               }
               state->lastsynctype = 28; //need two consecutive patterns to continue
@@ -1321,7 +1357,8 @@ getFrameSync (dsd_opts * opts, dsd_state * state)
               if (state->lastsynctype == 29) 
               {
                 state->last_cc_sync_time = time(NULL);
-                //if (opts->payload == 1) fprintf (stderr, "FSW   ");
+                // if (opts->payload == 1) fprintf (stderr, "FSW   ");
+                // fprintf (stderr, " %s ", synctest10);
                 return (29);
               }
               state->lastsynctype = 29; //need two consecutive patterns to continue
@@ -1329,6 +1366,216 @@ getFrameSync (dsd_opts * opts, dsd_state * state)
             }
           }
 
+          #else //use Current FSW Pattern
+
+          //NXDN FSW sync and handling - using more exact frame sync values
+          else if ((opts->frame_nxdn96 == 1) || (opts->frame_nxdn48 == 1))
+          {
+            strncpy (synctest10, (synctest_p - 9), 10); //FSW only
+            strncpy (synctest19, (synctest_p - 18), 19); //Preamble + FSW
+
+            //Using Hard Coded Sync Strings with variations for the areas where the symbol
+            //error will occur due to the demodulation issues internally
+
+            //Disabling the Preamble+FSW version for now
+            //its nearly impossible to catch it
+
+            //Preamble plus FSW, proceed right away
+            // if ( 
+                
+            //         (strcmp (synctest19, "3131133313131331131") == 0 )
+            //      || (strcmp (synctest19, "3131133313331331131") == 0 )
+            //      || (strcmp (synctest19, "3131133313131331111") == 0 )
+            //      || (strcmp (synctest19, "3131133313331331111") == 0 )   
+                 
+            //     )
+            // {
+            //   //state->carrier = 1;
+            //   state->offset = synctest_pos;
+            //   state->max = ((state->max) + lmax) / 2;
+            //   state->min = ((state->min) + lmin) / 2;
+            //   state->lastsynctype = 28;
+            //   state->last_cc_sync_time = time(NULL);
+              
+            //   // if (opts->payload == 1)
+            //     // fprintf (stderr, "\n +PANDF ");
+            //   // if (opts->payload == 1)
+            //     // fprintf (stderr, " %s \n", synctest19);
+            //   return (28);
+            // }
+            // else if ( 
+
+            //              (strcmp (synctest19, "1313311133131331131") == 0 )
+            //           || (strcmp (synctest19, "1313311133331331131") == 0 )
+            //           || (strcmp (synctest19, "1313311133131331111") == 0 )
+            //           || (strcmp (synctest19, "1313311133331331111") == 0 )   
+                      
+            //         )
+            // {
+            //   // state->carrier = 1;
+            //   state->carrier = 1;
+            //   state->offset = synctest_pos;
+            //   state->max = ((state->max) + lmax) / 2;
+            //   state->min = ((state->min) + lmin) / 2;
+            //   state->lastsynctype = 29;
+            //   state->last_cc_sync_time = time(NULL);
+              
+            //   // if (opts->payload == 1)
+            //     // fprintf (stderr, "\n -PANDF ");
+            //   // if (opts->payload == 1)
+            //     // fprintf (stderr, " %s \n", synctest19);
+            //   return (29);
+            // }
+            // else if (
+            if (
+                         (strcmp (synctest10, "3131331131") == 0 ) //this seems to be the most common 'correct' pattern on Type-C
+                      || (strcmp (synctest10, "3331331131") == 0 ) //this one hits on new sync but gives a bad lich code
+                      || (strcmp (synctest10, "3131331111") == 0 )
+                      || (strcmp (synctest10, "3331331111") == 0 )
+                      || (strcmp (synctest10, "3131311131") == 0 ) //First few FSW on NXDN48 Type-C seems to hit this for some reason
+                      
+                    )
+            {
+
+              // state->carrier = 1;
+              state->offset = synctest_pos;
+              state->max = ((state->max) + lmax) / 2;
+              state->min = ((state->min) + lmin) / 2;
+              // state->last_cc_sync_time = time(NULL);
+
+              if (state->lastsynctype == 28) 
+              {
+                state->last_cc_sync_time = time(NULL);
+                // if (opts->payload == 1)
+                //   fprintf (stderr, "\n +FSW   ");
+                // if (opts->payload == 1)
+                //   fprintf (stderr, " %s \n", synctest10);
+                return (28);
+              }
+              state->lastsynctype = 28;
+            }
+
+            else if ( 
+                      
+                         (strcmp (synctest10, "1313113313") == 0 )
+                      || (strcmp (synctest10, "1113113313") == 0 )
+                      || (strcmp (synctest10, "1313113333") == 0 )
+                      || (strcmp (synctest10, "1113113333") == 0 )
+                      || (strcmp (synctest10, "1313133313") == 0 ) //
+                      
+                    )
+            {
+
+              // state->carrier = 1;
+              state->offset = synctest_pos;
+              state->max = ((state->max) + lmax) / 2;
+              state->min = ((state->min) + lmin) / 2;
+              // state->last_cc_sync_time = time(NULL);
+
+              if (state->lastsynctype == 29) 
+              {
+                state->last_cc_sync_time = time(NULL);
+                // if (opts->payload == 1)
+                  // fprintf (stderr, "\n -FSW   ");
+                // if (opts->payload == 1)
+                  // fprintf (stderr, " %s \n", synctest10);
+                return (29);
+              }
+              state->lastsynctype = 29;
+            }
+          }
+
+          #endif //NXDN Sync Type Selection
+
+          //Provoice Conventional -- Some False Positives due to shortened frame sync pattern, so use squelch if possible
+          #ifdef PVCONVENTIONAL
+          if (opts->frame_provoice == 1)
+          {
+            memset (synctest32, 0, sizeof(synctest32)); 
+            strncpy (synctest32, (synctest_p - 31), 16); //short sync grab here on 32
+            char pvc_txs[9]; //string (symbol) value of TX Address
+            char pvc_rxs[9]; //string (symbol) value of RX Address
+            uint8_t pvc_txa = 0; //actual value of TX Address
+            uint8_t pvc_rxa = 0; //actual value of RX Address
+            strncpy (pvc_txs, (synctest_p - 15), 8); //copy string value of TX Address
+            strncpy (pvc_rxs, (synctest_p - 7), 8); //copy string value of RX Address
+            if ((strcmp (synctest32, INV_PROVOICE_CONV_SHORT) == 0))
+            {
+                if (state->lastsynctype == 15) //use this condition, like NXDN, to migitage false positives due to short sync pattern
+                {
+                  state->carrier = 1;
+                  state->offset = synctest_pos;
+                  state->max = ((state->max) + lmax) / 2;
+                  state->min = ((state->min) + lmin) / 2;
+                  sprintf (state->ftype, "ProVoice ");
+                  // fprintf (stderr, "Sync Pattern = %s ", synctest32);
+                  // fprintf (stderr, "TX = %s ", pvc_txs);
+                  // fprintf (stderr, "RX = %s ", pvc_rxs);
+                  for (int i = 0; i < 8; i++)
+                  {
+                    pvc_txa = pvc_txa << 1;
+                    pvc_rxa = pvc_rxa << 1;
+                    //symbol 1 is binary 1 on inverted
+                    //I hate working with strings, has to be a better way to evaluate this
+                    memset (pvc_txs, 0, sizeof (pvc_txs));
+                    memset (pvc_rxs, 0, sizeof (pvc_rxs));
+                    strncpy (pvc_txs, (synctest_p - 15+i), 1);
+                    strncpy (pvc_rxs, (synctest_p - 7+i), 1);
+                    if ((strcmp (pvc_txs, "1") == 0))
+                      pvc_txa = pvc_txa + 1;
+                    if ((strcmp (pvc_rxs, "1") == 0))
+                      pvc_rxa = pvc_rxa + 1;
+                  }
+                  printFrameSync (opts, state, "-PV_C ", synctest_pos + 1, modulation);
+                  fprintf (stderr, "TX: %d ", pvc_txa);
+                  fprintf (stderr, "RX: %d ", pvc_rxa);
+                  if (pvc_txa == 172) fprintf (stderr, "ALL CALL ");
+                  state->lastsynctype = 15;
+                  return (15);
+                }
+                state->lastsynctype = 15;
+            }
+            else if ((strcmp (synctest32, PROVOICE_CONV_SHORT) == 0))
+            {
+                if (state->lastsynctype == 14) //use this condition, like NXDN, to migitage false positives due to short sync pattern
+                {
+                  state->carrier = 1;
+                  state->offset = synctest_pos;
+                  state->max = ((state->max) + lmax) / 2;
+                  state->min = ((state->min) + lmin) / 2;
+                  sprintf (state->ftype, "ProVoice ");
+                  // fprintf (stderr, "Sync Pattern = %s ", synctest32);
+                  // fprintf (stderr, "TX = %s ", pvc_txs);
+                  // fprintf (stderr, "RX = %s ", pvc_rxs);
+                  for (int i = 0; i < 8; i++)
+                  {
+                    pvc_txa = pvc_txa << 1;
+                    pvc_rxa = pvc_rxa << 1;
+                    //symbol 3 is binary 1 on positive
+                    //I hate working with strings, has to be a better way to evaluate this
+                    memset (pvc_txs, 0, sizeof (pvc_txs));
+                    memset (pvc_rxs, 0, sizeof (pvc_rxs));
+                    strncpy (pvc_txs, (synctest_p - 15+i), 1);
+                    strncpy (pvc_rxs, (synctest_p - 7+i), 1);
+                    if ((strcmp (pvc_txs, "3") == 0))
+                      pvc_txa = pvc_txa + 1;
+                    if ((strcmp (pvc_rxs, "3") == 0))
+                      pvc_rxa = pvc_rxa + 1;
+                  }
+                  printFrameSync (opts, state, "+PV_C ", synctest_pos + 1, modulation);
+                  fprintf (stderr, "TX: %d ", pvc_txa);
+                  fprintf (stderr, "RX: %d ", pvc_rxa);
+                  if (pvc_txa == 172) fprintf (stderr, "ALL CALL ");
+                  state->lastsynctype = 14;
+                  return (14);
+                }
+                state->lastsynctype = 14;
+            }
+          }
+          #endif //End Provoice Conventional
+
+          SYNC_TEST_END: ; //do nothing
+
         } // t >= 10
 
       if (exitflag == 1)

src/dsd_import.c

@@ -146,11 +146,77 @@ int csvChanImport(dsd_opts * opts, dsd_state * state) //channel map import
   return 0;
 }
 
-int csvKeyImport(dsd_opts * opts, dsd_state * state) //multi-key support for NXDN
+//Decimal Variant of Key Import
+int csvKeyImportDec(dsd_opts * opts, dsd_state * state) //multi-key support
 {
   char filename[1024] = "filename.csv"; 
   sprintf (filename, "%s", opts->key_in_file);
 
+  char buffer[BSIZE];
+  FILE * fp;
+  fp = fopen(filename, "r");
+  if (fp == NULL) {
+    printf("Unable to open file '%s'\n", filename);
+    exit(1);
+  }
+  int row_count = 0;
+  int field_count = 0;
+  
+  unsigned long long int keynumber = 0;
+  unsigned long long int keyvalue = 0;
+
+  uint16_t hash = 0;
+  uint8_t hash_bits[24];
+  memset (hash_bits, 0, sizeof(hash_bits));
+
+  while (fgets(buffer, BSIZE, fp)) {
+    field_count = 0;
+    row_count++;
+    if (row_count == 1)
+      continue; //don't want labels
+    char * field = strtok(buffer, ","); //seperate by comma
+    while (field) {
+
+      if (field_count == 0)
+      {
+        sscanf (field, "%lld", &keynumber);
+        if (keynumber > 0xFFFF) //if larger than 16-bits, get its hash instead
+        {
+          keynumber = keynumber & 0xFFFFFF; //truncate to 24-bits (max allowed)
+          for (int i = 0; i < 24; i++)
+          {
+            hash_bits[i] = ((keynumber << i) & 0x800000) >> 23; //load into array for CRC16 
+          }
+          hash = ComputeCrcCCITT16d (hash_bits, 24);
+          keynumber = hash & 0xFFFF; //make sure its no larger than 16-bits
+          fprintf (stderr, "Hashed ");
+        }
+        
+      }
+
+      if (field_count == 1)
+      {
+        sscanf (field, "%lld", &keyvalue);
+        state->rkey_array[keynumber] = keyvalue & 0xFFFFFFFFFF; //doesn't exceed 40-bit value
+      }
+      
+      field = strtok(NULL, ",");
+      field_count++;
+    }
+    fprintf (stderr, "Key [%03lld] [%05lld]", keynumber, state->rkey_array[keynumber]);
+    fprintf (stderr, "\n");
+    hash = 0;
+    
+  }
+  fclose(fp);
+  return 0;
+}
+
+//Hex Variant of Key Import
+int csvKeyImportHex(dsd_opts * opts, dsd_state * state) //key import for rc4 keys
+{
+  char filename[1024] = "filename.csv";
+  sprintf (filename, "%s", opts->key_in_file);
   char buffer[BSIZE];
   FILE * fp;
   fp = fopen(filename, "r");
@@ -172,18 +238,18 @@ int csvKeyImport(dsd_opts * opts, dsd_state * state) //multi-key support for NXD
 
       if (field_count == 0)
       {
-        sscanf (field, "%lld", &keynumber);
+        sscanf (field, "%llX", &keynumber);
       }
 
       if (field_count == 1)
       {
-        sscanf (field, "%lld", &state->rkey_array[keynumber]);
+        sscanf (field, "%llX", &state->rkey_array[keynumber]);
       }
       
       field = strtok(NULL, ",");
       field_count++;
     }
-    fprintf (stderr, "Key [%03lld] [%05lld]", keynumber, state->rkey_array[keynumber]);
+    fprintf (stderr, "Key [%04llX] [%016llX]", keynumber, state->rkey_array[keynumber]);
     fprintf (stderr, "\n");
     
   }

src/dsd_mbe.c

@@ -17,6 +17,56 @@
 
 #include "dsd.h"
 
+//test for potential clashing with other key loading mechanisms (bp key loading on tgid, nxdn key loading, etc)
+void keyring(dsd_opts * opts, dsd_state * state)
+{
+	//keys now loaded from csv files with the -K key.csv file (capital K)
+  if (state->currentslot == 0)
+		state->R = state->rkey_array[state->payload_keyid];
+
+	if (state->currentslot == 1)
+		state->RR = state->rkey_array[state->payload_keyidR];
+
+}
+
+void RC4(int drop, uint8_t keylength, uint8_t messagelength, uint8_t key[], uint8_t cipher[], uint8_t plain[])
+{
+	int i, j, count;
+  uint8_t t, b;
+
+	//init Sbox
+	uint8_t S[256];
+  for(int i = 0; i < 256; i++) S[i] = i;
+
+	//Key Scheduling
+	j = 0;
+	for(i = 0; i < 256; i++)
+	{
+		j = (j + S[i] + key[i % keylength]) % 256;
+		t = S[i];
+		S[i] = S[j];
+		S[j] = t;
+	}
+
+	//Drop Bytes and Cipher Byte XOR
+	i = j = 0;
+	for(count = 0; count < (messagelength + drop); count++)
+	{
+		i = (i + 1) % 256;
+		j = (j + S[i]) % 256;
+		t = S[i];
+		S[i] = S[j];
+		S[j] = t;
+		b = S[(S[i] + S[j]) % 256];
+
+    //return mbe payload byte here
+		if (count >= drop)
+      plain[count - drop] = b^cipher[count - drop];
+
+	}
+
+}
+
 int Pr[256] = {
 0x0000, 0x1F00, 0xE300, 0xFC00, 0x2503, 0x3A03, 0xC603, 0xD903,
 0x4A05, 0x5505, 0xA905, 0xB605, 0x6F06, 0x7006, 0x8C06, 0x9306,
@@ -140,6 +190,18 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
   unsigned long long int k;
   int x;
 
+  //these conditions should ensure no clashing with the BP/HBP/Scrambler key loading machanisms already coded in
+  if (state->currentslot == 0 && state->payload_algid != 0 && state->payload_algid != 0x80 && state->payload_keyid != 0 && state->keyloader == 1)
+    keyring (opts, state);
+
+  if (state->currentslot == 1 && state->payload_algidR != 0 && state->payload_algidR != 0x80 && state->payload_keyidR != 0 && state->keyloader == 1)
+    keyring (opts, state);
+
+  //24-bit TG to 16-bit hash
+  uint32_t hash = 0;
+  uint8_t hash_bits[24];
+  memset (hash_bits, 0, sizeof(hash_bits));
+
   int preempt = 0; //TDMA dual voice slot preemption(when using OSS output)
 
 
@@ -187,7 +249,73 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
 			mbe_demodulateImbe7200x4400Data (imbe_fr);
 			state->errs2 = mbe_eccImbe7200x4400Data (imbe_fr, imbe_d);
 
+      //P25p1 RC4 Handling
+      if (state->payload_algid == 0xAA && state->R != 0)
+      {
+        uint8_t cipher[11] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+        uint8_t plain[11]  = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+        uint8_t rckey[13]  = {0x00, 0x00, 0x00, 0x00, 0x00, // <- RC4 Key
+                              0x00, 0x00, 0x00, 0x00, 0x00, // <- MI
+                              0x00, 0x00, 0x00}; // <- MI cont.
 
+        //easier to manually load up rather than make a loop
+        rckey[0] = ((state->R & 0xFF00000000) >> 32);
+        rckey[1] = ((state->R & 0xFF000000) >> 24);
+        rckey[2] = ((state->R & 0xFF0000) >> 16);
+        rckey[3] = ((state->R & 0xFF00) >> 8);
+        rckey[4] = ((state->R & 0xFF) >> 0);
+
+        // load valid MI from state->payload_miP
+        rckey[5]  = ((state->payload_miP & 0xFF00000000000000) >> 56);
+        rckey[6]  = ((state->payload_miP & 0xFF000000000000) >> 48);
+        rckey[7]  = ((state->payload_miP & 0xFF0000000000) >> 40);
+        rckey[8]  = ((state->payload_miP & 0xFF00000000) >> 32);
+        rckey[9]  = ((state->payload_miP & 0xFF000000) >> 24);
+        rckey[10] = ((state->payload_miP & 0xFF0000) >> 16);
+        rckey[11] = ((state->payload_miP & 0xFF00) >> 8);
+        rckey[12] = ((state->payload_miP & 0xFF) >> 0);
+
+        // if (state->p25vc == 0)
+				// {
+				// 	fprintf (stderr, "%s", KYEL);
+				// 	fprintf (stderr, "\n RC4K ");
+				// 	for (short o = 0; o < 13; o++)
+				// 	{
+				// 		fprintf (stderr, "%02X", rckey[o]);
+				// 	}
+				// 	fprintf (stderr, "%s", KNRM);
+				// }
+
+        //load imbe_d into imbe_cipher octets
+				int z = 0;
+				for (i = 0; i < 11; i++)
+			  {
+			    cipher[i] = 0;
+					plain[i] = 0;
+			    for (short int j = 0; j < 8; j++)
+			    {
+			      cipher[i] = cipher[i] << 1;
+			      cipher[i] = cipher[i] + imbe_d[z];
+						imbe_d[z] = 0;
+			      z++;
+			    }
+				}
+
+        RC4(state->dropL, 13, 11, rckey, cipher, plain);
+        state->dropL += 11;
+
+        z = 0;
+				for (short p = 0; p < 11; p++)
+				{
+					for (short o = 0; o < 8; o++)
+					{
+						imbe_d[z] = (plain[p] & 0x80) >> 7;
+						plain[p] = plain[p] << 1;
+						z++;
+					}
+        }
+
+      }
 
 			mbe_processImbe4400Dataf (state->audio_out_temp_buf, &state->errs, &state->errs2, state->err_str,
 																imbe_d, state->cur_mp, state->prev_mp, state->prev_mp_enhanced, opts->uvquality);
@@ -213,17 +341,16 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
 			//state->errs2 = state->errs;
 			mbe_demodulateImbe7100x4400Data (imbe7100_fr);
 			state->errs2 = mbe_eccImbe7100x4400Data (imbe7100_fr, imbe_d);
-			mbe_convertImbe7100to7200(imbe_d); //needs extra conversion step apparently
 
+      if (opts->payload == 1)
+			{
+				PrintIMBEData (opts, state, imbe_d);
+			}
+
+			mbe_convertImbe7100to7200(imbe_d);
 			mbe_processImbe4400Dataf (state->audio_out_temp_buf, &state->errs, &state->errs2, state->err_str,
 																imbe_d, state->cur_mp, state->prev_mp, state->prev_mp_enhanced, opts->uvquality);
 
-			//below line the old way of doing this
-      // mbe_processImbe7100x4400Framef (state->audio_out_temp_buf, &state->errs, &state->errs2, state->err_str, imbe7100_fr, imbe_d, state->cur_mp, state->prev_mp, state->prev_mp_enhanced, opts->uvquality);
-      if (opts->payload == 1)
-      {
-        PrintIMBEData (opts, state, imbe_d);
-      }
       if (opts->mbe_out_f != NULL)
       {
         saveImbe4400Data (opts, state, imbe_d);
@@ -293,6 +420,34 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
         mbe_demodulateAmbe3600x2450Data (ambe_fr);
         state->errs2 = mbe_eccAmbe3600x2450Data (ambe_fr, ambe_d);
 
+        //EXPERIMENTAL!!
+        //load basic privacy key number from array by the tg value (if not forced)
+        //currently only Moto BP and Hytera 10 Char BP
+        if (state->M == 0 && state->payload_algid == 0)
+        {
+          //see if we need to hash a value larger than 16-bits
+          hash = state->lasttg & 0xFFFFFF;
+          // fprintf (stderr, "TG: %lld Hash: %ld ", state->lasttg, hash); 
+          if (hash > 0xFFFF) //if greater than 16-bits
+          {
+            for (int i = 0; i < 24; i++)
+            {
+              hash_bits[i] = ((hash << i) & 0x800000) >> 23; //load into array for CRC16 
+            }
+            hash = ComputeCrcCCITT16d (hash_bits, 24);
+            hash = hash & 0xFFFF; //make sure its no larger than 16-bits
+            // fprintf (stderr, "Hash: %d ", hash);
+          }
+          if (state->rkey_array[hash] != 0)
+          {
+            state->K = state->rkey_array[hash] & 0xFF; //doesn't exceed 255
+            state->K1 = state->H = state->rkey_array[hash] & 0xFFFFFFFFFF; //doesn't exceed 40-bit limit
+            opts->dmr_mute_encL = 0;
+            // fprintf (stderr, "Key: %X ", state->rkey_array[hash]);
+          }
+          // else opts->dmr_mute_encL = 1; //may cause issues for manual key entry (non-csv)
+        }
+
 		    if ( (state->K > 0 && state->dmr_so & 0x40 && state->payload_keyid == 0 && state->dmr_fid == 0x10) ||
               (state->K > 0 && state->M == 1) )
         {
@@ -368,6 +523,155 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
 					state->DMRvcL++;
 				}
 
+        //DMR RC4, Slot 1
+        if (state->currentslot == 0 && state->payload_algid == 0x21 && state->R != 0)
+				{
+					uint8_t cipher[7] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+					uint8_t plain[7]  = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+					uint8_t rckey[9]  = {0x00, 0x00, 0x00, 0x00, 0x00, // <- RC4 Key
+												 			 0x00, 0x00, 0x00, 0x00}; // <- MI
+
+					//easier to manually load up rather than make a loop
+					rckey[0] = ((state->R & 0xFF00000000) >> 32);
+					rckey[1] = ((state->R & 0xFF000000) >> 24);
+					rckey[2] = ((state->R & 0xFF0000) >> 16);
+					rckey[3] = ((state->R & 0xFF00) >> 8);
+					rckey[4] = ((state->R & 0xFF) >> 0);
+					rckey[5] = ((state->payload_mi & 0xFF000000) >> 24);
+					rckey[6] = ((state->payload_mi & 0xFF0000) >> 16);
+					rckey[7] = ((state->payload_mi & 0xFF00) >> 8);
+					rckey[8] = ((state->payload_mi & 0xFF) >> 0);
+
+					// if (opts->payload == 1)
+					// {
+					// 	fprintf (stderr, "%s", KYEL);
+					// 	fprintf (stderr, " RC4K ");
+					// 	for (short o = 0; o < 9; o++)
+					// 	{
+					// 		fprintf (stderr, "%02X", rckey[o]);
+					// 	}
+					// 	fprintf (stderr, "%s", KNRM);
+					// 	fprintf (stderr, "\n");
+					// }
+
+	 				short k = 0;
+	 				for (short o = 0; o < 7; o++)
+	 				{
+		 				short b = 0;
+		 				for (short p = 0; p < 8; p++)
+		 				{
+			 				b = b << 1;
+			 				b = b + ambe_d[k];
+			 				k++;
+			 				if (k == 49)
+			 				{
+				 				cipher[6] = ((b << 3) & 0x80); //set 7th octet/bit 49 accordingly
+				 				break;
+			 				}
+		 				}
+		 			  cipher[o] = b;
+	 				}
+
+          RC4(state->dropL, 9, 7, rckey, cipher, plain);
+          state->dropL += 7;
+
+          short z = 0;
+          for (short p = 0; p < 6; p++)
+          {
+            //convert bytes back to bits and load into ambe_d array.
+            short b = 0; //reset b to use again
+            for (short o = 0; o < 8; o++)
+            {
+              b = (( (plain[p] << o) & 0x80) >> 7);
+              ambe_d[z] = b;
+              z++;
+              if (z == 49)
+              {
+                ambe_d[48] = ( (plain[p] << o) & 0x80);
+                break;
+              }
+            }
+          }
+				}
+
+        //P25p2 RC4 Handling, VCH 0
+        if (state->currentslot == 0 && state->payload_algid == 0xAA && state->R != 0 && ((state->synctype == 35) || (state->synctype == 36)))
+				{
+					uint8_t cipher[7] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+					uint8_t plain[7]  = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+					uint8_t rckey[13] = {0x00, 0x00, 0x00, 0x00, 0x00, // <- RC4 Key
+												 			 0x00, 0x00, 0x00, 0x00, 0x00, // <- MI
+                               0x00, 0x00, 0x00}; // <- MI cont.
+
+					//easier to manually load up rather than make a loop
+					rckey[0] = ((state->R & 0xFF00000000) >> 32);
+					rckey[1] = ((state->R & 0xFF000000) >> 24);
+					rckey[2] = ((state->R & 0xFF0000) >> 16);
+					rckey[3] = ((state->R & 0xFF00) >> 8);
+					rckey[4] = ((state->R & 0xFF) >> 0);
+
+					// load valid MI from state->payload_miP
+					rckey[5]  = ((state->payload_miP & 0xFF00000000000000) >> 56);
+					rckey[6]  = ((state->payload_miP & 0xFF000000000000) >> 48);
+					rckey[7]  = ((state->payload_miP & 0xFF0000000000) >> 40);
+					rckey[8]  = ((state->payload_miP & 0xFF00000000) >> 32);
+					rckey[9]  = ((state->payload_miP & 0xFF000000) >> 24);
+					rckey[10] = ((state->payload_miP & 0xFF0000) >> 16);
+					rckey[11] = ((state->payload_miP & 0xFF00) >> 8);
+					rckey[12] = ((state->payload_miP & 0xFF) >> 0);
+
+					// if (opts->payload == 1)
+					// {
+					// 	fprintf (stderr, "%s", KYEL);
+					// 	fprintf (stderr, " RC4K ");
+					// 	for (short o = 0; o < 13; o++)
+					// 	{
+					// 		fprintf (stderr, "%02X", rckey[o]);
+					// 	}
+					// 	fprintf (stderr, "%s", KNRM);
+					// 	fprintf (stderr, "\n");
+					// }
+
+	 				short k = 0;
+	 				for (short o = 0; o < 7; o++)
+	 				{
+		 				short b = 0;
+		 				for (short p = 0; p < 8; p++)
+		 				{
+			 				b = b << 1;
+			 				b = b + ambe_d[k];
+			 				k++;
+			 				if (k == 49)
+			 				{
+				 				cipher[6] = ((b << 3) & 0x80); //set 7th octet/bit 49 accordingly
+				 				break;
+			 				}
+		 				}
+		 			  cipher[o] = b;
+	 				}
+
+          RC4(state->dropL, 13, 7, rckey, cipher, plain);
+          state->dropL += 7;
+
+          short z = 0;
+          for (short p = 0; p < 6; p++)
+          {
+            //convert bytes back to bits and load into ambe_d array.
+            short b = 0; //reset b to use again
+            for (short o = 0; o < 8; o++)
+            {
+              b = (( (plain[p] << o) & 0x80) >> 7);
+              ambe_d[z] = b;
+              z++;
+              if (z == 49)
+              {
+                ambe_d[48] = ( (plain[p] << o) & 0x80);
+                break;
+              }
+            }
+          }
+				}
+
       	mbe_processAmbe2450Dataf (state->audio_out_temp_buf, &state->errs, &state->errs2, state->err_str,
                                 	ambe_d, state->cur_mp, state->prev_mp, state->prev_mp_enhanced, opts->uvquality);
 
@@ -395,6 +699,34 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
         mbe_demodulateAmbe3600x2450Data (ambe_fr);
         state->errs2R = mbe_eccAmbe3600x2450Data (ambe_fr, ambe_d);
 
+        //EXPERIMENTAL!!
+        //load basic privacy key number from array by the tg value (if not forced)
+        //currently only Moto BP and Hytera 10 Char BP
+        if (state->M == 0 && state->payload_algidR == 0)
+        {
+          //see if we need to hash a value larger than 16-bits
+          hash = state->lasttgR & 0xFFFFFF; 
+          // fprintf (stderr, "TG: %lld Hash: %ld ", state->lasttgR, hash);
+          if (hash > 0xFFFF) //if greater than 16-bits
+          {
+            for (int i = 0; i < 24; i++)
+            {
+              hash_bits[i] = ((hash << i) & 0x800000) >> 23; //load into array for CRC16 
+            }
+            hash = ComputeCrcCCITT16d (hash_bits, 24);
+            hash = hash & 0xFFFF; //make sure its no larger than 16-bits
+            // fprintf (stderr, "Hash: %d ", hash);
+          }
+          if (state->rkey_array[hash] != 0)
+          {
+            state->K = state->rkey_array[hash] & 0xFF; //doesn't exceed 255
+            state->K1 = state->H = state->rkey_array[hash] & 0xFFFFFFFFFF; //doesn't exceed 40-bit limit
+            opts->dmr_mute_encR = 0;
+            // fprintf (stderr, "Key: %X ", state->rkey_array[hash]);
+          }
+          // else opts->dmr_mute_encR = 1; //may cause issues for manual key entry (non-csv)
+        }
+
         if ( (state->K > 0 && state->dmr_soR & 0x40 && state->payload_keyidR == 0 && state->dmr_fidR == 0x10) ||
               (state->K > 0 && state->M == 1) )
         {
@@ -470,6 +802,155 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
 					state->DMRvcR++;
 				}
 
+        //DMR RC4, Slot 2
+        if (state->currentslot == 1 && state->payload_algidR == 0x21 && state->RR != 0)
+				{
+					uint8_t cipher[7] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+					uint8_t plain[7]  = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+					uint8_t rckey[9]  = {0x00, 0x00, 0x00, 0x00, 0x00, // <- RC4 Key
+												 			 0x00, 0x00, 0x00, 0x00}; // <- MI
+
+					//easier to manually load up rather than make a loop
+					rckey[0] = ((state->RR & 0xFF00000000) >> 32);
+					rckey[1] = ((state->RR & 0xFF000000) >> 24);
+					rckey[2] = ((state->RR & 0xFF0000) >> 16);
+					rckey[3] = ((state->RR & 0xFF00) >> 8);
+					rckey[4] = ((state->RR & 0xFF) >> 0);
+					rckey[5] = ((state->payload_miR & 0xFF000000) >> 24);
+					rckey[6] = ((state->payload_miR & 0xFF0000) >> 16);
+					rckey[7] = ((state->payload_miR & 0xFF00) >> 8);
+					rckey[8] = ((state->payload_miR & 0xFF) >> 0);
+
+					// if (opts->payload == 1)
+					// {
+					// 	fprintf (stderr, "%s", KYEL);
+					// 	fprintf (stderr, " RC4K ");
+					// 	for (short o = 0; o < 9; o++)
+					// 	{
+					// 		fprintf (stderr, "%02X", rckey[o]);
+					// 	}
+					// 	fprintf (stderr, "%s", KNRM);
+					// 	fprintf (stderr, "\n");
+					// }
+
+	 				short k = 0;
+	 				for (short o = 0; o < 7; o++)
+	 				{
+		 				short b = 0;
+		 				for (short p = 0; p < 8; p++)
+		 				{
+			 				b = b << 1;
+			 				b = b + ambe_d[k];
+			 				k++;
+			 				if (k == 49)
+			 				{
+				 				cipher[6] = ((b << 3) & 0x80); //set 7th octet/bit 49 accordingly
+				 				break;
+			 				}
+		 				}
+		 			  cipher[o] = b;
+	 				}
+
+          RC4(state->dropR, 9, 7, rckey, cipher, plain);
+          state->dropR += 7;
+
+          short z = 0;
+          for (short p = 0; p < 6; p++)
+          {
+            //convert bytes back to bits and load into ambe_d array.
+            short b = 0; //reset b to use again
+            for (short o = 0; o < 8; o++)
+            {
+              b = (( (plain[p] << o) & 0x80) >> 7);
+              ambe_d[z] = b;
+              z++;
+              if (z == 49)
+              {
+                ambe_d[48] = ( (plain[p] << o) & 0x80);
+                break;
+              }
+            }
+          }
+				}
+
+        //P25p2 RC4 Handling, VCH 1
+        if (state->currentslot == 1 && state->payload_algidR == 0xAA && state->RR != 0 && ((state->synctype == 35) || (state->synctype == 36)))
+				{
+					uint8_t cipher[7] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+					uint8_t plain[7]  = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+					uint8_t rckey[13] = {0x00, 0x00, 0x00, 0x00, 0x00, // <- RC4 Key
+												 			 0x00, 0x00, 0x00, 0x00, 0x00, // <- MI
+                               0x00, 0x00, 0x00}; // <- MI cont.
+
+					//easier to manually load up rather than make a loop
+					rckey[0] = ((state->RR & 0xFF00000000) >> 32);
+					rckey[1] = ((state->RR & 0xFF000000) >> 24);
+					rckey[2] = ((state->RR & 0xFF0000) >> 16);
+					rckey[3] = ((state->RR & 0xFF00) >> 8);
+					rckey[4] = ((state->RR & 0xFF) >> 0);
+
+					//state->payload_miN for VCH1/slot 2
+					rckey[5]  = ((state->payload_miN & 0xFF00000000000000) >> 56);
+					rckey[6]  = ((state->payload_miN & 0xFF000000000000) >> 48);
+					rckey[7]  = ((state->payload_miN & 0xFF0000000000) >> 40);
+					rckey[8]  = ((state->payload_miN & 0xFF00000000) >> 32);
+					rckey[9]  = ((state->payload_miN & 0xFF000000) >> 24);
+					rckey[10] = ((state->payload_miN & 0xFF0000) >> 16);
+					rckey[11] = ((state->payload_miN & 0xFF00) >> 8);
+					rckey[12] = ((state->payload_miN & 0xFF) >> 0);
+
+					// if (opts->payload == 1)
+					// {
+					// 	fprintf (stderr, "%s", KYEL);
+					// 	fprintf (stderr, " RC4K ");
+					// 	for (short o = 0; o < 13; o++)
+					// 	{
+					// 		fprintf (stderr, "%02X", rckey[o]);
+					// 	}
+					// 	fprintf (stderr, "%s", KNRM);
+					// 	fprintf (stderr, "\n");
+					// }
+
+	 				short k = 0;
+	 				for (short o = 0; o < 7; o++)
+	 				{
+		 				short b = 0;
+		 				for (short p = 0; p < 8; p++)
+		 				{
+			 				b = b << 1;
+			 				b = b + ambe_d[k];
+			 				k++;
+			 				if (k == 49)
+			 				{
+				 				cipher[6] = ((b << 3) & 0x80); //set 7th octet/bit 49 accordingly
+				 				break;
+			 				}
+		 				}
+		 			  cipher[o] = b;
+	 				}
+
+          RC4(state->dropR, 13, 7, rckey, cipher, plain);
+          state->dropR += 7;
+
+          short z = 0;
+          for (short p = 0; p < 6; p++)
+          {
+            //convert bytes back to bits and load into ambe_d array.
+            short b = 0; //reset b to use again
+            for (short o = 0; o < 8; o++)
+            {
+              b = (( (plain[p] << o) & 0x80) >> 7);
+              ambe_d[z] = b;
+              z++;
+              if (z == 49)
+              {
+                ambe_d[48] = ( (plain[p] << o) & 0x80);
+                break;
+              }
+            }
+          }
+				}
+
 				mbe_processAmbe2450Dataf (state->audio_out_temp_bufR, &state->errsR, &state->errs2R, state->err_strR,
 	                                ambe_d, state->cur_mp2, state->prev_mp2, state->prev_mp_enhanced2, opts->uvquality);
 
@@ -524,7 +1005,10 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
 		}
     else state->dmr_encL = 0;
 
-    //second checkdown for P25-2 WACN, SYSID, and CC set
+    //check for available R key
+    if (state->R != 0) state->dmr_encL = 0;
+
+    //second checkdown for P25p2 WACN, SYSID, and CC set
 		if (state->synctype == 35 || state->synctype == 36)
 		{
 			if (state->p2_wacn == 0 || state->p2_sysid == 0 || state->p2_cc == 0)
@@ -551,13 +1035,16 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
     }
     //end reverse mute test
 
+    #ifdef AERO_BUILD //FUN FACT: OSS stutters only on Cygwin, using padsp in linux, it actually opens two virtual /dev/dsp audio streams for output
     //OSS Specific Voice Preemption if dual voices on TDMA and one slot has preference over the other
-    if (opts->slot_preference == 1 && opts->audio_out_type == 5 && opts->audio_out == 1 && state->dmrburstR == 16) 
+    if (opts->slot_preference == 1 && opts->audio_out_type == 5 && opts->audio_out == 1 && (state->dmrburstR == 16 || state->dmrburstR == 21) ) 
     {
       opts->audio_out = 0;
       preempt = 1;
-      if (opts->payload == 0) fprintf (stderr, " *MUTED*"); 
+      if (opts->payload == 0)
+        fprintf (stderr, " *MUTED*"); 
     }
+    #endif
 
     if (state->dmr_encL == 0 || opts->dmr_mute_encL == 0)
     {
@@ -588,7 +1075,10 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
 		}
     else state->dmr_encR = 0;
 
-    //second checkdown for P25-2 WACN, SYSID, and CC set
+    //check for available RR key
+    if (state->RR != 0) state->dmr_encR = 0;
+
+    //second checkdown for P25p2 WACN, SYSID, and CC set
 		if (state->synctype == 35 || state->synctype == 36)
 		{
 			if (state->p2_wacn == 0 || state->p2_sysid == 0 || state->p2_cc == 0)
@@ -615,13 +1105,16 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
     }
     //end reverse mute test
 
+    #ifdef AERO_BUILD //FUN FACT: OSS stutters only on Cygwin, using padsp in linux, it actually opens two virtual /dev/dsp audio streams for output
     //OSS Specific Voice Preemption if dual voices on TDMA and one slot has preference over the other
-    if (opts->slot_preference == 0 && opts->audio_out_type == 5 && opts->audio_out == 1 && state->dmrburstL == 16) 
+    if (opts->slot_preference == 0 && opts->audio_out_type == 5 && opts->audio_out == 1 && (state->dmrburstL == 16 || state->dmrburstL == 21) ) 
     {
       opts->audio_out = 0;
       preempt = 1;
-      if (opts->payload == 0) fprintf (stderr, " *MUTED*"); 
+      if (opts->payload == 0) 
+        fprintf (stderr, " *MUTED*"); 
     }
+    #endif
 
     if (state->dmr_encR == 0 || opts->dmr_mute_encR == 0)
     {

src/dsd_reset.c

@@ -2,26 +2,59 @@
 #include "dsd.h"
 #include "p25p1_heuristics.h"
 
-void
-resetState (dsd_state * state)
+//fixed the memory leak, but now random segfaults occur -- double free or corruption (out) or (!prev)
+void resetState (dsd_state * state)
 {
 
   int i, j;
 
+  //Dibit Buffer -- Free Allocated Memory
+  // free (state->dibit_buf);
+
+  //Dibit Buffer -- Memset/Init/Allocate Memory
   // state->dibit_buf = malloc (sizeof (int) * 1000000);
-  // state->dibit_buf_p = state->dibit_buf + 200;
-  // memset (state->dibit_buf, 0, sizeof (int) * 200);
-  state->repeat = 0; //not sure yet
-  //state->audio_out_buf = malloc (sizeof (short) * 1000000);
-  //memset (state->audio_out_buf, 0, 100 * sizeof (short));
-  //state->audio_out_buf_p = state->audio_out_buf + 100;
-  //state->audio_out_float_buf = malloc (sizeof (float) * 1000000);
-  //memset (state->audio_out_float_buf, 0, 100 * sizeof (float));
-  //state->audio_out_float_buf_p = state->audio_out_float_buf + 100;
-  //state->audio_out_idx = 0;
-  //state->audio_out_idx2 = 0;
-  //state->audio_out_temp_buf_p = state->audio_out_temp_buf;
-  //state->wav_out_bytes = 0;
+  
+  state->dibit_buf_p = state->dibit_buf + 200;
+  memset (state->dibit_buf, 0, sizeof (int) * 200);
+  state->repeat = 0; //repeat frame?
+
+  //Audio Buffer -- Free Allocated Memory
+  free (state->audio_out_buf);
+  free (state->audio_out_float_buf);
+  free (state->audio_out_bufR);
+  free (state->audio_out_float_bufR);
+
+  //Audio Buffer -- Memset/Init/Allocate Memory per slot
+
+  //slot 1
+  state->audio_out_float_buf = malloc (sizeof (float) * 1000000);
+  state->audio_out_buf = malloc (sizeof (short) * 1000000);
+
+  memset (state->audio_out_buf, 0, 100 * sizeof (short));
+  state->audio_out_buf_p = state->audio_out_buf + 100;
+  
+  memset (state->audio_out_float_buf, 0, 100 * sizeof (float));
+  state->audio_out_float_buf_p = state->audio_out_float_buf + 100;
+
+  state->audio_out_idx = 0;
+  state->audio_out_idx2 = 0;
+  state->audio_out_temp_buf_p = state->audio_out_temp_buf;
+
+  //slot 2
+  state->audio_out_bufR = malloc (sizeof (short) * 1000000);
+  state->audio_out_float_bufR = malloc (sizeof (float) * 1000000);
+
+  memset (state->audio_out_bufR, 0, 100 * sizeof (short));
+  state->audio_out_buf_pR = state->audio_out_bufR + 100;
+  
+  memset (state->audio_out_float_bufR, 0, 100 * sizeof (float));
+  state->audio_out_float_buf_pR = state->audio_out_float_bufR + 100;
+
+  state->audio_out_idxR = 0;
+  state->audio_out_idx2R = 0;
+  state->audio_out_temp_buf_pR = state->audio_out_temp_bufR;
+
+  //Sync
   state->center = 0;
   state->jitter = -1;
   state->synctype = -1;
@@ -31,76 +64,73 @@ resetState (dsd_state * state)
   state->umid = 0;
   state->minref = -12000;
   state->maxref = 12000;
+
   state->lastsample = 0;
   for (i = 0; i < 128; i++)
-    {
-      state->sbuf[i] = 0;
-    }
+  {
+    state->sbuf[i] = 0;
+  }
   state->sidx = 0;
   for (i = 0; i < 1024; i++)
-    {
-      state->maxbuf[i] = 15000;
-    }
+  {
+    state->maxbuf[i] = 15000;
+  }
   for (i = 0; i < 1024; i++)
-    {
-      state->minbuf[i] = -15000;
-    }
+  {
+    state->minbuf[i] = -15000;
+  }
+
   state->midx = 0;
-  state->err_str[0] = 0;
-  sprintf (state->fsubtype, "              ");
-  sprintf (state->ftype, "             ");
   state->symbolcnt = 0;
-  state->rf_mod = 0;
+
   state->numflips = 0;
   state->lastsynctype = -1;
   state->lastp25type = 0;
   state->offset = 0;
   state->carrier = 0;
-  for (i = 0; i < 25; i++)
-    {
-      for (j = 0; j < 16; j++)
-        {
-          state->tg[i][j] = 48;
-        }
-    }
-  state->tgcount = 0;
-  state->lasttg = 0;
-  state->lastsrc = 0;
-  state->nac = 0;
+
+  //Reset Voice Errors in C0 and C1 (or remaining Codewords in IMBE)
   state->errs = 0;
   state->errs2 = 0;
-  state->mbe_file_type = -1;
+  state->errsR = 0;
+  state->errs2R = 0;
+
+  //Misc -- may not be needed
   state->optind = 0;
   state->numtdulc = 0;
   state->firstframe = 0;
-  sprintf (state->slot0light, " slot0 ");
-  sprintf (state->slot1light, " slot1 ");
-  state->aout_gain = 25;
-  memset (state->aout_max_buf, 0, sizeof (float) * 200);
-  state->aout_max_buf_p = state->aout_max_buf;
-  state->aout_max_buf_idx = 0;
-  state->samplesPerSymbol = 10;
-  state->symbolCenter = 4;
-  sprintf (state->algid, "________");
-  sprintf (state->keyid, "________________");
-  state->currentslot = 0;
-  state->cur_mp = malloc (sizeof (mbe_parms));
-  state->prev_mp = malloc (sizeof (mbe_parms));
-  state->prev_mp_enhanced = malloc (sizeof (mbe_parms));
-  mbe_initMbeParms (state->cur_mp, state->prev_mp, state->prev_mp_enhanced);
-  state->p25kid = 0;
 
-  state->debug_audio_errors = 0;
-  state->debug_header_errors = 0;
-  state->debug_header_critical_errors = 0;
+  //unsure if these are still used or ever were used, 
+  // memset (state->aout_max_buf, 0, sizeof (float) * 200);
+  // state->aout_max_buf_p = state->aout_max_buf;
+  // state->aout_max_buf_idx = 0;
 
-  state->nxdn_last_ran = 0;
-  // state->payload_algid = 0;
-  // state->payload_algidR = 0;
-  state->dmr_encL = 0;
-  state->dmr_encR = 0;
+  // //MBE Specific 
+  // //free the memory before allocating it again -- may not use this
+  // free (state->cur_mp);
+  // free (state->prev_mp);
+  // free (state->prev_mp_enhanced);
 
-  //each time you run this, it increses memory use by 4MB, massive memory leak
-  //need to revisit this sometime and look into only resetting only the necesary items to let P25 switch between signals (C4FM or Wide) without needing a restart
-  initialize_p25_heuristics(&state->p25_heuristics); //see if we want to re-init this or not, currently seems to cause memory leak when running over and over, mitigated with a reset flag
+  // //memory allocation and init on mbe -- may not use this
+  // state->cur_mp = malloc (sizeof (mbe_parms));
+  // state->prev_mp = malloc (sizeof (mbe_parms));
+  // state->prev_mp_enhanced = malloc (sizeof (mbe_parms));
+  // mbe_initMbeParms (state->cur_mp, state->prev_mp, state->prev_mp_enhanced);
+
+  //rest the heurestics, we want to do this on each tune, each RF frequency can deviate quite a bit in strength
+  initialize_p25_heuristics(&state->p25_heuristics);
+  initialize_p25_heuristics(&state->inv_p25_heuristics);
+}
+
+//simple function to reset the dibit buffer
+void reset_dibit_buffer(dsd_state * state)
+{
+	//Dibit Buffer -- Free Allocated Memory
+  // free (state->dibit_buf);
+
+  //Dibit Buffer -- Memset/Init/Allocate Memory
+  // state->dibit_buf = malloc (sizeof (int) * 1000000);
+
+  state->dibit_buf_p = state->dibit_buf + 200;
+  memset (state->dibit_buf, 0, sizeof (int) * 200);
 }

src/dsd_rigctl.c

@@ -250,6 +250,7 @@ int UDPBind (char *hostname, int portno)
     return sockfd;
 }
 
+//going to leave this function available, even if completely switched over to rtl_dev_tune now, may be useful in the future
 void rtl_udp_tune(dsd_opts * opts, dsd_state * state, long int frequency) 
 {
     int handle; 
@@ -274,8 +275,5 @@ void rtl_udp_tune(dsd_opts * opts, dsd_state * state, long int frequency)
     address.sin_port = htons(udp_port);
     sendto(handle, data, 5, 0, (const struct sockaddr * ) & address, sizeof(struct sockaddr_in));
 
-    //BUGFIX: This was causing an indefinite number of UDP sockets to stay open on each tune request
-    //we open a new socket with each request, so we need to close the socket after writing to it
-    //this would cause the tuning to stop after x number of tune attempts (few hours? on a busy system)
     close (handle); //close socket after sending.
 }

src/dsd_symbol.c

@@ -119,7 +119,11 @@ getSymbol (dsd_opts * opts, dsd_state * state, int have_sync)
             openPulseInput(opts); //open pulse input
           } 
           //else cleanup and exit
-          else cleanupAndExit(opts, state);             
+          else
+          {
+            if (opts->use_ncurses_terminal == 1) ncursesClose(opts);
+            cleanupAndExit(opts, state);     
+          }        
         }
       }
       else if (opts->audio_in_type == 3)
@@ -133,28 +137,135 @@ getSymbol (dsd_opts * opts, dsd_state * state, int have_sync)
           state->pulse_raw_out_buffer = sample; //steal raw out buffer sample here?
           pa_simple_write(opts->pulse_raw_dev_out, (void*)&state->pulse_raw_out_buffer, 2, NULL);
         }
+        opts->rtl_rms = rtl_return_rms();
 
 #endif
       }
-      //tcp socket input from SDR++
+
+      //tcp socket input from SDR++ -- now with 1 retry if connection is broken
       else if (opts->audio_in_type == 8)
       {
+        #ifdef AERO_BUILD
         result = sf_read_short(opts->tcp_file_in, &sample, 1);
         if(result == 0) {
+          fprintf (stderr, "\nConnection to TCP Server Interrupted. Trying again in 3 seconds.\n");
+          sample = 0;
+          sf_close(opts->tcp_file_in); //close current connection on this end
+          sleep (3); //halt all processing and wait 3 seconds
 
-          fprintf (stderr, "Connection to TCP Server Disconnected.\n");
-          //open pulse input if we are pulse output AND using ncurses terminal
-          if (opts->audio_out_type == 0 && opts->use_ncurses_terminal == 1)
+          //attempt to reconnect to socket
+          opts->tcp_sockfd = 0;  
+          opts->tcp_sockfd = Connect(opts->tcp_hostname, opts->tcp_portno);
+          if (opts->tcp_sockfd != 0)
           {
+            //reset audio input stream
+            opts->audio_in_file_info = calloc(1, sizeof(SF_INFO));
+            opts->audio_in_file_info->samplerate=opts->wav_sample_rate;
+            opts->audio_in_file_info->channels=1;
+            opts->audio_in_file_info->seekable=0;
+            opts->audio_in_file_info->format=SF_FORMAT_RAW|SF_FORMAT_PCM_16|SF_ENDIAN_LITTLE;
+            opts->tcp_file_in = sf_open_fd(opts->tcp_sockfd, SFM_READ, opts->audio_in_file_info, 0);
+
+            if(opts->tcp_file_in == NULL)
+            {
+              fprintf(stderr, "Error, couldn't Reconnect to TCP with libsndfile: %s\n", sf_strerror(NULL));
+            }
+            else fprintf (stderr, "TCP Socket Reconnected Successfully.\n");
+          }
+          else fprintf (stderr, "TCP Socket Connection Error.\n");          
+
+          //now retry reading sample
+          result = sf_read_short(opts->tcp_file_in, &sample, 1);
+          if (result == 0) {
+            sf_close(opts->tcp_file_in);
             opts->audio_in_type = 0; //set input type
-            openPulseInput(opts); //open pulse input
-          } 
-          //else cleanup and exit
-          else cleanupAndExit(opts, state);
+            opts->tcp_sockfd = 0; //added this line so we will know if it connected when using ncurses terminal keyboard shortcut
+            //openPulseInput(opts); //open pulse inpput
+            sample = 0; //zero sample on bad result, keep the ball rolling
+            //open pulse input if we are pulse output AND using ncurses terminal
+            if (opts->audio_out_type == 0 && opts->use_ncurses_terminal == 1)
+            {
+              fprintf (stderr, "Connection to TCP Server Disconnected.\n");
+              fprintf (stderr, "Opening Pulse Audio Input.\n");
+              opts->audio_in_type = 0; //set input type
+              openPulseInput(opts); //open pulse input
+            } 
+            //else cleanup and exit
+            else 
+            {
+              fprintf (stderr, "Connection to TCP Server Disconnected.\n");
+              fprintf (stderr, "Closing DSD-FME.\n");
+              if (opts->use_ncurses_terminal == 1) ncursesClose(opts);
+              cleanupAndExit(opts, state);
+            }
+            
+          }
           
         }
+        #else
+        result = sf_read_short(opts->tcp_file_in, &sample, 1);
+        if(result == 0) {
+          fprintf (stderr, "\nConnection to TCP Server Interrupted. Trying again in 3 seconds.\n");
+          sample = 0;
+          sf_close(opts->tcp_file_in); //close current connection on this end
+          sleep (3); //halt all processing and wait 3 seconds
+
+          //attempt to reconnect to socket
+          opts->tcp_sockfd = 0;  
+          opts->tcp_sockfd = Connect(opts->tcp_hostname, opts->tcp_portno);
+          if (opts->tcp_sockfd != 0)
+          {
+            //reset audio input stream
+            opts->audio_in_file_info = calloc(1, sizeof(SF_INFO));
+            opts->audio_in_file_info->samplerate=opts->wav_sample_rate;
+            opts->audio_in_file_info->channels=1;
+            opts->audio_in_file_info->seekable=0;
+            opts->audio_in_file_info->format=SF_FORMAT_RAW|SF_FORMAT_PCM_16|SF_ENDIAN_LITTLE;
+            opts->tcp_file_in = sf_open_fd(opts->tcp_sockfd, SFM_READ, opts->audio_in_file_info, 0);
+
+            if(opts->tcp_file_in == NULL)
+            {
+              fprintf(stderr, "Error, couldn't Reconnect to TCP with libsndfile: %s\n", sf_strerror(NULL));
+            }
+            else fprintf (stderr, "TCP Socket Reconnected Successfully.\n");
+          }
+          else fprintf (stderr, "TCP Socket Connection Error.\n");          
+
+          //now retry reading sample
+          result = sf_read_short(opts->tcp_file_in, &sample, 1);
+          if (result == 0) {
+            sf_close(opts->tcp_file_in);
+            opts->audio_in_type = 0; //set input type
+            opts->tcp_sockfd = 0; //added this line so we will know if it connected when using ncurses terminal keyboard shortcut
+            openPulseInput(opts); //open pulse inpput
+            sample = 0; //zero sample on bad result, keep the ball rolling
+            fprintf (stderr, "Connection to TCP Server Disconnected.\n");
+          }
+          
+        }
+        #endif
+        
       }
 
+      //tcp socket input from SDR++ -- old method to open pulse or quit right away
+      // else if (opts->audio_in_type == 8)
+      // {
+      //   result = sf_read_short(opts->tcp_file_in, &sample, 1);
+      //   if(result == 0) {
+
+      //     fprintf (stderr, "Connection to TCP Server Disconnected.\n");
+      //     //open pulse input if we are pulse output AND using ncurses terminal
+      //     if (opts->audio_out_type == 0 && opts->use_ncurses_terminal == 1)
+      //     {
+      //       opts->audio_in_type = 0; //set input type
+      //       openPulseInput(opts); //open pulse input
+      //     } 
+      //     //else cleanup and exit
+      //     else cleanupAndExit(opts, state);
+          
+      //   }
+      // }
+
       //UDP Socket input...not working correct. Reads samples, but no sync
       // else if (opts->audio_in_type == 6)
       // {
@@ -419,7 +530,11 @@ getSymbol (dsd_opts * opts, dsd_state * state, int have_sync)
         openPulseInput(opts); //open pulse input
       } 
       //else cleanup and exit
-      else cleanupAndExit(opts, state);
+      else
+      {
+        if (opts->use_ncurses_terminal == 1) ncursesClose(opts);
+        cleanupAndExit(opts, state);
+      }
     }
 
     //assign symbol/dibit values based on modulation type

src/edacs-fme.c

@@ -298,9 +298,11 @@ void edacs(dsd_opts * opts, dsd_state * state)
 
             if (opts->audio_in_type == 3) //rtl dongle
             {
-              rtl_udp_tune(opts, state, state->trunk_lcn_freq[lcn-1]);
+              #ifdef USE_RTLSDR
+              rtl_dev_tune (opts, state->trunk_lcn_freq[lcn-1]);
               state->edacs_tuned_lcn = lcn;
-              opts->p25_is_tuned = 1; 
+              opts->p25_is_tuned = 1;
+              #endif
             }
 
           }
@@ -428,9 +430,11 @@ void edacs(dsd_opts * opts, dsd_state * state)
 
               if (opts->audio_in_type == 3) //rtl dongle
               {
-                rtl_udp_tune(opts, state, state->trunk_lcn_freq[lcn-1]);
+                #ifdef USE_RTLSDR
+                rtl_dev_tune (opts, state->trunk_lcn_freq[lcn-1]);
                 state->edacs_tuned_lcn = lcn;
-                opts->p25_is_tuned = 1; 
+                opts->p25_is_tuned = 1;
+                #endif
               }
 
             }

src/nxdn_convolution.c

@@ -49,14 +49,14 @@ static const unsigned int CNXDNConvolution_NUM_OF_STATES = 16U;
 static const uint32_t     CNXDNConvolution_M = 4U;
 static const unsigned int CNXDNConvolution_K = 5U;
 
-static uint16_t   m_metrics1[16U] = {0};
-static uint16_t   m_metrics2[16U] = {0};
-static uint64_t   m_decisions[300U] = {0};
+//NOTE:
+static uint16_t   m_metrics1[16U];
+static uint16_t   m_metrics2[16U];
+static uint64_t   m_decisions[300U]; //300
 static uint16_t * m_oldMetrics = NULL;
 static uint16_t * m_newMetrics = NULL;
 static uint64_t * m_dp = NULL;
 
-
 /* Functions ----------------------------------------------------------------*/
 
 void CNXDNConvolution_decode(uint8_t s0, uint8_t s1)
@@ -158,13 +158,15 @@ void CNXDNConvolution_encode(const unsigned char* in, unsigned char* out, unsign
 
 void CNXDNConvolution_start(void)
 {
-  memset(m_metrics1, 0x00U, CNXDNConvolution_NUM_OF_STATES * sizeof(uint16_t));
-  memset(m_metrics2, 0x00U, CNXDNConvolution_NUM_OF_STATES * sizeof(uint16_t));
 
   m_oldMetrics = m_metrics1;
   m_newMetrics = m_metrics2;
   m_dp = m_decisions;
 
+  memset(m_metrics1, 0x00U, sizeof(m_metrics1));
+  memset(m_metrics2, 0x00U, sizeof(m_metrics2));
+  memset(m_decisions, 0x00U, sizeof(m_decisions));
+
   for (int x = 0; x < 4; x++) CNXDNConvolution_decode(0U, 0U);
 }
 

src/nxdn_deperm.c

@@ -42,7 +42,8 @@ static const int PARITY[] = {
 //decoding functions here
 void nxdn_descramble(uint8_t dibits[], int len)
 {
-	for (int i=0; i<sizeof(scramble_t); i++) {
+	for (int i=0; i<len; i++)
+	{
 		if (scramble_t[i] >= len)
 			break;
 		dibits[scramble_t[i]] ^= 0x2;	// invert sign of scrambled dibits
@@ -51,13 +52,15 @@ void nxdn_descramble(uint8_t dibits[], int len)
 
 void nxdn_deperm_facch(dsd_opts * opts, dsd_state * state, uint8_t bits[144])
 {
-	uint8_t deperm[144];
-	uint8_t depunc[192];
-	uint8_t trellis_buf[96];
+	uint8_t deperm[200]; //144
+	uint8_t depunc[200]; //192
+	uint8_t trellis_buf[400]; //96
 	uint16_t crc = 0; //crc calculated by function
 	uint16_t check = 0; //crc from payload for comparison
 	int out;
-	char buf[128];
+
+	memset (deperm, 0, sizeof(deperm));
+	memset (depunc, 0, sizeof(depunc));
 
 	for (int i=0; i<144; i++) 
 		deperm[PERM_16_9[i]] = bits[i]; 
@@ -73,7 +76,7 @@ void nxdn_deperm_facch(dsd_opts * opts, dsd_state * state, uint8_t bits[144])
 	uint8_t temp[210];
 	uint8_t s0;
   uint8_t s1;
-	uint8_t m_data[13];
+	uint8_t m_data[20]; //13
 	memset (temp, 0, sizeof(temp));
 	memset (m_data, 0, sizeof(m_data));
 	memset (trellis_buf, 0, sizeof(trellis_buf));
@@ -111,38 +114,46 @@ void nxdn_deperm_facch(dsd_opts * opts, dsd_state * state, uint8_t bits[144])
     trellis_buf[(i*8)+7] = (m_data[i] >> 0) & 1;
   }
 
-	//load tail 16 bits into check variable to compare vs computed crc value
+	crc = crc12f (trellis_buf, 84); //80
 	for (int i = 0; i < 12; i++)
 	{
 		check = check << 1;
-		check = check + trellis_buf[80+i];
+		check = check | trellis_buf[84+i]; //80
 	}
 
-	crc = crc12f (trellis_buf, 80);
-
 	if (crc == check) NXDN_Elements_Content_decode(opts, state, 1, trellis_buf); 
-	//else if (opts->payload == 1) NXDN_Elements_Content_decode(opts, state, 0, trellis_buf);
+	else if (opts->aggressive_framesync == 0) NXDN_Elements_Content_decode(opts, state, 0, trellis_buf);
 
 	if (opts->payload == 1)
 	{
 		fprintf (stderr, "\n");
-		fprintf (stderr, " FACCH Payload ");
+		fprintf (stderr, " FACCH1 Payload ");
 		for (int i = 0; i < 12; i++)
 		{
 			fprintf (stderr, "[%02X]", m_data[i]); 
 		}
-		fprintf (stderr, " - %03X %03X", crc, check);
+		if (crc != check && opts->payload == 1)
+		{
+			fprintf (stderr, "%s", KRED);
+			fprintf (stderr, " (CRC ERR)");
+			fprintf (stderr, "%s", KNRM);
+		}
 	}
 
 }
 
-//new sacch
+//sacch
 void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
 {
-	uint8_t deperm[60];
-	uint8_t depunc[72];
-	uint8_t trellis_buf[32];
-	uint8_t answer[26];
+	//see about initializing these variables
+	uint8_t deperm[200]; //60 
+	uint8_t depunc[200]; //72
+	uint8_t trellis_buf[400]; //32
+
+	memset (deperm, 0, sizeof(deperm));
+	memset (depunc, 0, sizeof(depunc));
+	memset (trellis_buf, 0, sizeof(trellis_buf));
+
 	int o = 0;
 	uint8_t crc = 0; //value computed by crc6 on payload
 	uint8_t check = 0; //value pulled from last 6 bits
@@ -171,7 +182,7 @@ void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
 	uint8_t temp[90];
 	uint8_t s0;
   uint8_t s1;
-	uint8_t m_data[5];
+	uint8_t m_data[10]; //5
 
 	memset (temp, 0, sizeof (temp));
 	memset (m_data, 0, sizeof (m_data));
@@ -188,7 +199,7 @@ void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
 	}
 
 	CNXDNConvolution_start();
-  for (int i = 0U; i < 40U; i++) 
+  for (int i = 0U; i < 36U; i++) //40
   {
     s0 = temp[(2*i)];
     s1 = temp[(2*i)+1];
@@ -197,7 +208,7 @@ void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
   }
 
 	//stored as 5 bytes, will need to convert to trellis_buf after running
-  CNXDNConvolution_chainback(m_data, 36U); 
+  CNXDNConvolution_chainback(m_data, 32U); //36
 
 	for(int i = 0; i < 4; i++)
   {
@@ -211,11 +222,11 @@ void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
     trellis_buf[(i*8)+7] = (m_data[i] >> 0) & 1;
   }
 
-	crc = crc6(trellis_buf, 32);
+	crc = crc6(trellis_buf, 26); //32
 	for (int i = 0; i < 6; i++)
 	{
 		check = check << 1;
-		check = check + trellis_buf[i+26];
+		check = check | trellis_buf[i+26];
 	}
 
 	//FIRST! If part of a non_superframe, and CRC is good, send directly to NXDN_Elements_Content_decode
@@ -224,24 +235,49 @@ void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
 		if (state->nxdn_last_ran != -1) fprintf (stderr, " RAN %02d ", state->nxdn_last_ran);
 		else fprintf (stderr, "        ");
 
-		uint8_t nsf_sacch[26];
+		uint8_t nsf_sacch[400];
 		memset (nsf_sacch, 0, sizeof(nsf_sacch));
 		for (int i = 0; i < 26; i++)
 		{
 			nsf_sacch[i] = trellis_buf[i+8];
 		}
 
-		if (crc == 0) NXDN_Elements_Content_decode(opts, state, 1, nsf_sacch);
+		if (crc == check)
+		{
+			ran = (trellis_buf[2] << 5) | (trellis_buf[3] << 4) | (trellis_buf[4] << 3) | (trellis_buf[5] << 2) | (trellis_buf[6] << 1) | trellis_buf[7];
+			state->nxdn_last_ran = ran;
+		} 
+
+		fprintf (stderr, "PF 1/1");
+
+		if (crc == check) NXDN_Elements_Content_decode(opts, state, 1, nsf_sacch); 
+		// else if (opts->aggressive_framesync == 0) NXDN_Elements_Content_decode(opts, state, 0, nsf_sacch);
+
+		//I'm placing this here, my observation is that SACCH NSF 
+		//is almost always, if not always, just IDLE
+		else fprintf (stderr, " IDLE");
 
 		if (opts->payload == 1)
 		{ 
 			fprintf (stderr, "\n SACCH NSF ");
-			for (int i = 0; i < 5; i++)
+			for (int i = 0; i < 4; i++)
 			{
 				fprintf (stderr, "[%02X]", m_data[i]);
 			}
-			if (crc != 0) fprintf (stderr, " CRC ERR - %02X %02X", crc, check);
+
+			if (crc != check)
+			{
+
+				fprintf (stderr, "%s", KRED);
+				fprintf (stderr, " (CRC ERR)");
+				fprintf (stderr, "%s", KNRM);
+			}
+
 		}
+		
+		//reset the sacch field -- Github Issue #118
+		memset (state->nxdn_sacch_frame_segment, 1, sizeof(state->nxdn_sacch_frame_segment));
+		memset (state->nxdn_sacch_frame_segcrc, 1, sizeof(state->nxdn_sacch_frame_segcrc));
 
 	}
 	
@@ -251,7 +287,7 @@ void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
 		//sf and ran together are denoted as SR in the manual (more confusing acronyms)
 		//sf (structure field) and RAN will always exist in first 8 bits of each SACCH, then the next 18 bits are the fragment of the superframe
 		sf = (trellis_buf[0] << 1) | trellis_buf[1];
-		ran = (trellis_buf[2] << 5) | (trellis_buf[3] << 4) | (trellis_buf[4] << 3) | (trellis_buf[5] << 2) | (trellis_buf[6] << 1) | trellis_buf[7];
+
 		if      (sf == 3) part_of_frame = 0;
 		else if (sf == 2) part_of_frame = 1;
 		else if (sf == 1) part_of_frame = 2;
@@ -262,12 +298,22 @@ void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
 		if (state->nxdn_last_ran != -1) fprintf (stderr, " RAN %02d ", state->nxdn_last_ran);
 		else fprintf (stderr, "        ");
 		fprintf (stderr, "%s", KNRM);
+
+		fprintf (stderr, "PF %d/4", part_of_frame+1);
+
+		if (crc != check)
+		{
+			fprintf (stderr, "%s", KRED);
+			fprintf (stderr, " (CRC ERR)");
+			fprintf (stderr, "%s", KNRM);
+		}
 		
 		//reset scrambler seed to key value on new superframe
 		if (part_of_frame == 0 && state->nxdn_cipher_type == 0x1) state->payload_miN = 0;
 
-		if (crc == 0)
+		if (crc == check)
 		{
+			ran = (trellis_buf[2] << 5) | (trellis_buf[3] << 4) | (trellis_buf[4] << 3) | (trellis_buf[5] << 2) | (trellis_buf[6] << 1) | trellis_buf[7];
 			state->nxdn_ran = state->nxdn_last_ran = ran;
 			state->nxdn_sf = sf;
 			state->nxdn_part_of_frame = part_of_frame;
@@ -290,28 +336,32 @@ void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
 			NXDN_SACCH_Full_decode (opts, state);
 		} 
 
-		if (opts->payload == 1)
-		{ 
-			fprintf (stderr, "\n"); 
-			fprintf (stderr, " SACCH SF Segment #%d ", part_of_frame+1);
-			for (int i = 0; i < 5; i++)
-			{
-				fprintf (stderr, "[%02X]", m_data[i]);
-			}
-			if (crc != 0) fprintf (stderr, " CRC ERR - %02X %02X", crc, check);
-		}
+		// if (opts->payload == 1)
+		// { 
+		// 	fprintf (stderr, "\n"); 
+		// 	fprintf (stderr, " SACCH SF Segment #%d ", part_of_frame+1);
+		// 	for (int i = 0; i < 4; i++)
+		// 	{
+		// 		fprintf (stderr, "[%02X]", m_data[i]);
+		// 	}
+		// 	// if (crc != check) fprintf (stderr, " CRC ERR - %02X %02X", crc, check);
+		// }
+
 	}	
 	
 }
 
-void nxdn_deperm_facch2_udch(dsd_opts * opts, dsd_state * state, uint8_t bits[348])
+void nxdn_deperm_facch2_udch(dsd_opts * opts, dsd_state * state, uint8_t bits[348], uint8_t type)
 {
-
-	uint8_t deperm[348];
-	uint8_t depunc[406];
-	uint8_t trellis_buf[199];
+	uint8_t deperm[500]; //348
+	uint8_t depunc[500]; //406
+	uint8_t trellis_buf[400]; //199
 	int id = 0;
 	uint16_t crc = 0;
+	uint16_t check = 0;
+
+	memset (deperm, 0, sizeof(deperm));
+	memset (depunc, 0, sizeof(depunc));
 
 	for (int i=0; i<348; i++) {
 		deperm[PERM_12_29[i]] = bits[i];
@@ -334,10 +384,10 @@ void nxdn_deperm_facch2_udch(dsd_opts * opts, dsd_state * state, uint8_t bits[34
 	}
 	
 	//switch to the convolutional decoder
-	uint8_t temp[220];
+	uint8_t temp[500]; //220, this one was way too small
 	uint8_t s0;
   uint8_t s1;
-	uint8_t m_data[26];
+	uint8_t m_data[52]; //26
 	memset (trellis_buf, 0, sizeof(trellis_buf));
 	memset (temp, 0, sizeof (temp));
 	memset (m_data, 0, sizeof (m_data));
@@ -377,8 +427,18 @@ void nxdn_deperm_facch2_udch(dsd_opts * opts, dsd_state * state, uint8_t bits[34
   }
 
 	crc = crc15(trellis_buf, 199);
+	for (int i = 0; i < 15; i++)
+	{
+		check = check << 1;
+		check = check | trellis_buf[i+184];
+	}
 
-	uint8_t f2u_message_buffer[199];
+	fprintf (stderr, "%s", KYEL);
+	if (type == 0) fprintf (stderr, " UDCH");
+	if (type == 1) fprintf (stderr, " FACCH2");
+	fprintf (stderr, "%s", KNRM);
+
+	uint8_t f2u_message_buffer[400]; //199
 	memset (f2u_message_buffer, 0, sizeof(f2u_message_buffer));
 
 	//just going to leave this all here in case its needed, like in cac,
@@ -388,36 +448,66 @@ void nxdn_deperm_facch2_udch(dsd_opts * opts, dsd_state * state, uint8_t bits[34
 		f2u_message_buffer[i] = trellis_buf[i+8]; 
 	}
 	
-	if (crc == 0)
+	if (crc == check)
+	{ 
+		if (type == 1) NXDN_Elements_Content_decode(opts, state, 1, f2u_message_buffer);
+		if (type == 0) ; //need handling for user data (text messages and AVL)
+	} 
+	else if (opts->aggressive_framesync == 0)
 	{
-		fprintf (stderr, " F2/U   "); 
-		//NXDN_Elements_Content_decode(opts, state, 1, trellis_buf); 
-		NXDN_Elements_Content_decode(opts, state, 1, f2u_message_buffer); 
+		if (type == 1) NXDN_Elements_Content_decode(opts, state, 0, f2u_message_buffer);
+		if (type == 0) ; //need handling for user data (text messages and AVL)
 	} 
 
 	if (opts->payload == 1)
 	{
 		fprintf (stderr, "\n");
-		fprintf (stderr, " F2/U Payload\n  ");
+		if (type == 0) fprintf (stderr, " UDCH");
+		if (type == 1) fprintf (stderr, " FACCH2");
+		fprintf (stderr, " Payload\n  ");
 		for (int i = 0; i < 26; i++)
 		{
+			if (i == 13) fprintf (stderr, "\n  ");
 			fprintf (stderr, "[%02X]", m_data[i]); 
-			if (i == 12) fprintf (stderr, "\n  ");
 		}
-		if (crc != 0) fprintf (stderr, " CRC ERR ");
+		
+		if (crc != check)
+		{
+			fprintf (stderr, "%s", KRED);
+			fprintf (stderr, " (CRC ERR)");
+			fprintf (stderr, "%s", KNRM);
+		}
+
+		// if (crc != check) fprintf (stderr, " CRC ERR ");
+
+		if (type == 0)
+		{
+			fprintf (stderr, "\n UDCH Data: ASCII - "  );
+			for (int i = 0; i < 24; i++) //remove crc portion
+			{
+				if (m_data[i] <= 0x7E && m_data[i] >=0x20)
+				{
+					fprintf (stderr, "%c", m_data[i]);
+				}
+				else fprintf (stderr, " ");
+			}
+		}
 	}  
 
 }
 
 void nxdn_deperm_cac(dsd_opts * opts, dsd_state * state, uint8_t bits[300])
 {
-
-	uint8_t deperm[300];
-	uint8_t depunc[350];
-	uint8_t trellis_buf[171];
+	uint8_t deperm[500]; //300
+	uint8_t depunc[500]; //350
+	uint8_t trellis_buf[400]; //171
 	int id = 0;
+	int ran = 0;
 	uint16_t crc = 0;
 
+	memset (deperm, 0, sizeof(deperm));
+	memset (depunc, 0, sizeof(depunc));
+
 	for (int i=0; i<300; i++) {
 		deperm[PERM_12_25[i]] = bits[i];
 	}
@@ -442,7 +532,7 @@ void nxdn_deperm_cac(dsd_opts * opts, dsd_state * state, uint8_t bits[300])
 	uint8_t temp[360];
 	uint8_t s0;
   uint8_t s1;
-	uint8_t m_data[26];
+	uint8_t m_data[52]; //26
 	memset (trellis_buf, 0, sizeof(trellis_buf));
 	memset (temp, 0, sizeof (temp));
 	memset (m_data, 0, sizeof (m_data));
@@ -452,11 +542,6 @@ void nxdn_deperm_cac(dsd_opts * opts, dsd_state * state, uint8_t bits[300])
 		temp[i] = depunc[i] << 1; 
 	}
 
-	for (int i = 0; i < 8; i++)
-	{
-		temp[i+350] = 0; 
-	}
-
 	CNXDNConvolution_start();
   for (int i = 0U; i < 179U; i++) 
   {
@@ -482,30 +567,38 @@ void nxdn_deperm_cac(dsd_opts * opts, dsd_state * state, uint8_t bits[300])
 
 	crc = crc16cac(trellis_buf, 171); 
 
-	//message type will probably be neccesary beforehand on single/dual meessage runs
-	//run message, check len, load into a seperate buffer, send to element, do same with other piece?
-	uint8_t MessageType = 0;
-	for (int i = 0; i < 6; i++)
-	{
-		MessageType = MessageType << 1;
-		MessageType = MessageType + trellis_buf[i+2]; //double check this on CAC
-	}
-
-	uint8_t cac_message_buffer[171];
+	uint8_t cac_message_buffer[400]; //171
 	memset (cac_message_buffer, 0, sizeof(cac_message_buffer));
 
-	//shift the cac_message into the appropriate byte arrangement for element_decoder
-	for (int i = 0; i < 160; i++) //in future, we can use this to send multiple messages to decoder, if present
+	//shift the cac_message into the appropriate byte arrangement for element_decoder -- skip SR field
+	for (int i = 0; i < 160; i++)
 	{
 		cac_message_buffer[i] = trellis_buf[i+8];
 	}
 
+	if (state->nxdn_last_ran != -1) fprintf (stderr, " RAN %02d ", state->nxdn_last_ran);
+	else fprintf (stderr, "        ");
+
 	if (crc == 0)
 	{
-		fprintf (stderr, " CAC    ");
-		NXDN_Elements_Content_decode(opts, state, 1, cac_message_buffer);
+		ran = (trellis_buf[2] << 5) | (trellis_buf[3] << 4) | (trellis_buf[4] << 3) | (trellis_buf[5] << 2) | (trellis_buf[6] << 1) | trellis_buf[7];
+		state->nxdn_last_ran = ran;
 	} 
 
+	fprintf (stderr, "%s", KYEL);
+	fprintf (stderr, " CAC");
+	fprintf (stderr, "%s", KNRM);
+
+	if (crc != 0)
+	{
+		fprintf (stderr, "%s", KRED);
+		fprintf (stderr, " (CRC ERR)");
+		fprintf (stderr, "%s", KNRM);
+	}
+
+	if (crc == 0) NXDN_Elements_Content_decode(opts, state, 1, cac_message_buffer);
+	else if (opts->aggressive_framesync == 0) NXDN_Elements_Content_decode(opts, state, 0, cac_message_buffer);  
+
 	if (opts->payload == 1)
 	{
 		fprintf (stderr, "\n");
@@ -515,32 +608,326 @@ void nxdn_deperm_cac(dsd_opts * opts, dsd_state * state, uint8_t bits[300])
 			fprintf (stderr, "[%02X]", m_data[i]); 
 			if (i == 10) fprintf (stderr, "\n  ");
 		}
-		if (crc != 0) fprintf (stderr, " CRC ERR ");
+		// if (crc != 0) fprintf (stderr, " CRC ERR ");
 
 	} 
 
 }
 
+//Type-D "IDAS" 
+void nxdn_deperm_scch(dsd_opts * opts, dsd_state * state, uint8_t bits[60], uint8_t direction)
+{
+	fprintf (stderr, "%s", KYEL);
+	fprintf (stderr, " SCCH");
+
+	//see about initializing these variables
+	uint8_t deperm[200]; //60 
+	uint8_t depunc[200]; //72
+	uint8_t trellis_buf[400]; //32
+
+	memset (deperm, 0, sizeof(deperm));
+	memset (depunc, 0, sizeof(depunc));
+	memset (trellis_buf, 0, sizeof(trellis_buf));
+
+	int o = 0;
+	uint8_t crc = 0; //value computed by crc7 on payload
+	uint8_t check = 0; //value pulled from last 7 bits
+	int sf = 0;
+	int part_of_frame = 0;
+
+	for (int i=0; i<60; i++) 
+		deperm[PERM_12_5[i]] = bits[i];
+	for (int p=0; p<60; p+= 10) {
+		depunc[o++] = deperm[p+0];
+		depunc[o++] = deperm[p+1];
+		depunc[o++] = deperm[p+2];
+		depunc[o++] = deperm[p+3];
+		depunc[o++] = deperm[p+4];
+		depunc[o++] = 0;
+		depunc[o++] = deperm[p+5];
+		depunc[o++] = deperm[p+6];
+		depunc[o++] = deperm[p+7];
+		depunc[o++] = deperm[p+8];
+		depunc[o++] = deperm[p+9];
+		depunc[o++] = 0;
+	}
+
+	//switch to the convolutional decoder
+	uint8_t temp[90];
+	uint8_t s0;
+  uint8_t s1;
+	uint8_t m_data[10]; //5
+
+	memset (temp, 0, sizeof (temp));
+	memset (m_data, 0, sizeof (m_data));
+	memset (trellis_buf, 0, sizeof(trellis_buf));
+
+	for (int i = 0; i < 72; i++)
+	{
+		temp[i] = depunc[i] << 1; 
+	}
+
+	for (int i = 0; i < 8; i++)
+	{
+		temp[i+72] = 0; 
+	}
+
+	CNXDNConvolution_start();
+  for (int i = 0U; i < 36U; i++) 
+  {
+    s0 = temp[(2*i)];
+    s1 = temp[(2*i)+1];
+
+    CNXDNConvolution_decode(s0, s1);
+  }
+
+  CNXDNConvolution_chainback(m_data, 32U);
+
+	for(int i = 0; i < 4; i++)
+  {
+    trellis_buf[(i*8)+0] = (m_data[i] >> 7) & 1;
+    trellis_buf[(i*8)+1] = (m_data[i] >> 6) & 1;
+    trellis_buf[(i*8)+2] = (m_data[i] >> 5) & 1;
+    trellis_buf[(i*8)+3] = (m_data[i] >> 4) & 1;
+    trellis_buf[(i*8)+4] = (m_data[i] >> 3) & 1;
+    trellis_buf[(i*8)+5] = (m_data[i] >> 2) & 1;
+    trellis_buf[(i*8)+6] = (m_data[i] >> 1) & 1;
+    trellis_buf[(i*8)+7] = (m_data[i] >> 0) & 1;
+  }
+
+	crc = crc7_scch(trellis_buf, 25);
+	for (int i = 0; i < 7; i++)
+	{
+		check = check << 1;
+		check = check | trellis_buf[i+25];
+	}
+
+	//check the sf early for scrambler reset, if required
+	sf = (trellis_buf[0] << 1) | trellis_buf[1];
+	if      (sf == 3) part_of_frame = 0;
+	else if (sf == 2) part_of_frame = 1;
+	else if (sf == 1) part_of_frame = 2;
+	else if (sf == 0) part_of_frame = 3;
+	else part_of_frame = 0; 
+
+	//reset scrambler seed to key value on new superframe
+	if (part_of_frame == 0 && state->nxdn_cipher_type == 0x1) state->payload_miN = 0;
+
+	/*
+	4.3.2. Mapping to Functional Channel
+		When Subscriber Unit performs voice communication in RTCH2, SCCH is allocated as
+		described below.
+
+		SCCH has super Frame Structure with 4 frame unit during communication, and has non
+		super Frame Structure with single frame unit at the start time and end time of sending.
+		Allocation of the other channel is not specified particularly.
+	*/
+
+	//English Translation: Superframe when voice, Non Superframe when not voice
+
+	//What I've found is that by not using the superframe structure, and decoding each 'unit'
+	//individually instead, we can get more expedient decoding on elements without having to 
+	//sacrifice an entire superframe for one bad CRC, also each element cleanly divides into a 
+	//single 'unit' except for enc parms IV, which can be stored seperately if needed
+
+	//NOTE: scch has its own message format, and thus, doesn't go to content element decoding
+	//like everything else does
+
+	if (crc == check) NXDN_decode_scch (opts, state, trellis_buf, direction);
+	else if (opts->aggressive_framesync == 0) NXDN_decode_scch (opts, state, trellis_buf, direction);
+
+	fprintf (stderr, "%s", KNRM);
+
+	if (opts->payload == 1)
+	{ 
+		fprintf (stderr, "\n SCCH Payload ");
+		for (int i = 0; i < 4; i++)
+		{
+			fprintf (stderr, "[%02X]", m_data[i]);
+		}
+
+		if (crc != check)
+		{
+			fprintf (stderr, "%s", KRED);
+			fprintf (stderr, " (CRC ERR)");
+			fprintf (stderr, "%s", KNRM);
+		} 
+	}
+
+	fprintf (stderr, "%s", KNRM);
+	
+}
+
+void nxdn_deperm_facch3_udch2(dsd_opts * opts, dsd_state * state, uint8_t bits[288], uint8_t type)
+{
+	uint8_t deperm[300]; //144
+	uint8_t depunc[300]; //192
+	uint8_t trellis_buf[600]; //96
+	uint8_t f3_udch2[288]; //completed bitstream without crc and tailing bits attached
+	uint8_t f3_udch2_bytes[36]; //completed bytes - with crc and tail
+	uint16_t crc[2]; //crc calculated by function
+	uint16_t check[2]; //crc from payload for comparison
+	int out;
+
+	//switch to the convolutional decoder
+	uint8_t temp[500];
+	uint8_t s0;
+  uint8_t s1;
+	uint8_t m_data[40]; //13
+	memset (temp, 0, sizeof(temp));
+	memset (m_data, 0, sizeof(m_data));
+	memset (trellis_buf, 0, sizeof(trellis_buf));
+	memset (deperm, 0, sizeof(deperm));
+	memset (depunc, 0, sizeof(depunc));
+	memset (crc, 0, sizeof(crc));
+	memset (check, 0, sizeof(check));
+	memset (f3_udch2, 0, sizeof(f3_udch2));
+	memset (f3_udch2_bytes, 0, sizeof(f3_udch2_bytes));
+
+	for (int j=0; j<2; j++)
+	{
+		for (int i=0; i<144; i++) 
+			deperm[PERM_16_9[i]] = bits[i+(j*144)]; 
+		out = 0;
+		for (int i=0; i<144; i+=3) {
+			depunc[out++] = deperm[i+0];
+			depunc[out++] = 0; 
+			depunc[out++] = deperm[i+1];
+			depunc[out++] = deperm[i+2];
+		}
+
+		for (int i = 0; i < 192; i++)
+		{
+			temp[i] = depunc[i] << 1; 
+		}
+
+		for (int i = 0; i < 8; i++)
+		{
+			temp[i+192] = 0;
+		}
+
+		CNXDNConvolution_start();
+		for (int i = 0U; i < 100U; i++) 
+		{
+			s0 = temp[(2*i)];
+			s1 = temp[(2*i)+1];
+
+			CNXDNConvolution_decode(s0, s1);
+		}
+
+		CNXDNConvolution_chainback(m_data, 96U);
+
+		for(int i = 0; i < 12; i++)
+		{
+			trellis_buf[(i*8)+0] = (m_data[i] >> 7) & 1;
+			trellis_buf[(i*8)+1] = (m_data[i] >> 6) & 1;
+			trellis_buf[(i*8)+2] = (m_data[i] >> 5) & 1;
+			trellis_buf[(i*8)+3] = (m_data[i] >> 4) & 1;
+			trellis_buf[(i*8)+4] = (m_data[i] >> 3) & 1;
+			trellis_buf[(i*8)+5] = (m_data[i] >> 2) & 1;
+			trellis_buf[(i*8)+6] = (m_data[i] >> 1) & 1;
+			trellis_buf[(i*8)+7] = (m_data[i] >> 0) & 1;
+		}
+
+		crc[j] = crc12f (trellis_buf, 84); //84
+		for (int i = 0; i < 12; i++)
+		{
+			check[j] = check[j] << 1;
+			check[j] = check[j] | trellis_buf[84+i]; //84
+		
+		}
+		//transfer to storage sans crc and tail bits
+		for (int i = 0; i < 80; i++) f3_udch2[i+(j*80)] = trellis_buf[i];
+		for (int i = 0; i < 12; i++) f3_udch2_bytes[i+(j*12)] = m_data[i];
+	}
+
+	fprintf (stderr, "%s", KYEL);
+	if (type == 0) fprintf (stderr, " UDCH2");
+	if (type == 1) fprintf (stderr, " FACCH3");
+	fprintf (stderr, "%s", KNRM);
+
+
+	if (crc[0] == check[0] && crc[1] == check[1])
+	{
+		if (type == 1) NXDN_Elements_Content_decode(opts, state, 1, trellis_buf);
+		if (type == 0) ; //need handling for user data (text messages and AVL)
+	}  
+	else if (opts->aggressive_framesync == 0) 
+	{
+		if (type == 1) NXDN_Elements_Content_decode(opts, state, 0, trellis_buf);
+		if (type == 0) ; //need handling for user data (text messages and AVL)
+	}
+
+	if (opts->payload == 1)
+	{
+		fprintf (stderr, "\n");
+		if (type == 0) fprintf (stderr, " UDCH2");
+		if (type == 1) fprintf (stderr, " FACCH3");
+		fprintf (stderr, " Payload \n  ");
+		for (int i = 0; i < 24; i++)
+		{
+			if (i == 12) fprintf (stderr, "\n  ");
+			fprintf (stderr, "[%02X]", f3_udch2_bytes[i]); 
+		}
+
+		if ( (crc[0] != check[0] || crc[1] != check[1]) && opts->payload == 1)
+		{
+
+			fprintf (stderr, "%s", KRED);
+			fprintf (stderr, " (CRC ERR)");
+			fprintf (stderr, "%s", KNRM);
+
+			// fprintf (stderr, " - %03X %03X", check[0], crc[0]);
+			// fprintf (stderr, " - %03X %03X", check[1], crc[1]);
+		}
+
+		if (type == 0)
+		{
+			fprintf (stderr, "\n UDCH2 Data: ASCII - "  );
+			for (int i = 0; i < 22; i++) //all but last crc portion
+			{
+				if (i == 12) i = 14;  //skip first crc portion
+				if (f3_udch2_bytes[i] <= 0x7E && f3_udch2_bytes[i] >=0x20)
+				{
+					fprintf (stderr, "%c", f3_udch2_bytes[i]);
+				}
+				else fprintf (stderr, " ");
+			}
+		}
+		
+	}
+
+}
+
 void nxdn_message_type (dsd_opts * opts, dsd_state * state, uint8_t MessageType)
 {
 
+	//NOTE: Most Req/Resp (request and respone) share same message type but differ depending on channel type
+	//RTCH Outbound will take precedent when differences may occur (except CALL_ASSGN)
 	fprintf (stderr, "%s", KYEL);
 	if      (MessageType == 0x10) fprintf(stderr, " IDLE");
-	else if (MessageType == 0x11) fprintf(stderr, " DISC"); //disconnect
+	else if (MessageType == 0x00) fprintf(stderr, " CALL_RESP");
 	else if (MessageType == 0x01) fprintf(stderr, " VCALL");
-	else if (MessageType == 0x03) fprintf(stderr, " VCALL IV");
-	
-	else if (MessageType == 0x07) fprintf(stderr, " TX_REL_EX");
-	else if (MessageType == 0x08) fprintf(stderr, " TX_REL");
-
+	else if (MessageType == 0x02) fprintf(stderr, " VCALL_REC_REQ");
+	else if (MessageType == 0x03) fprintf(stderr, " VCALL_IV");
 	else if (MessageType == 0x04) fprintf(stderr, " VCALL_ASSGN");
 	else if (MessageType == 0x05) fprintf(stderr, " VCALL_ASSGN_DUP");
+	else if (MessageType == 0x06) fprintf(stderr, " CALL_CONN_RESP");
+	else if (MessageType == 0x07) fprintf(stderr, " TX_REL_EX");
+	else if (MessageType == 0x08) fprintf(stderr, " TX_REL");
+	else if (MessageType == 0x09) fprintf(stderr, " DCALL_HEADER");
+	else if (MessageType == 0x0A) fprintf(stderr, " DCALL_REC_REQ");
+	else if (MessageType == 0x0B) fprintf(stderr, " DCALL_UDATA");
+	else if (MessageType == 0x0C) fprintf(stderr, " DCALL_ACK");
+	else if (MessageType == 0x0D) fprintf(stderr, " DCALL_ASSGN_DUP");
 	else if (MessageType == 0x0E) fprintf(stderr, " DCALL_ASSGN");
+	else if (MessageType == 0x11) fprintf(stderr, " DISC");
+	else if (MessageType == 0x17) fprintf(stderr, " DST_ID_INFO");
 	else if (MessageType == 0x18) fprintf(stderr, " SITE_INFO");
-	else if (MessageType == 0x19) fprintf(stderr, " SRV_INFO"); 
-	else if (MessageType == 0x1C) fprintf(stderr, " FAIL_STAT_INFO"); 
+	else if (MessageType == 0x19) fprintf(stderr, " SRV_INFO");
 	else if (MessageType == 0x1A) fprintf(stderr, " CCH_INFO");
 	else if (MessageType == 0x1B) fprintf(stderr, " ADJ_SITE_INFO");
+	else if (MessageType == 0x1C) fprintf(stderr, " FAIL_STAT_INFO");
 	else if (MessageType == 0x20) fprintf(stderr, " REG_RESP");
 	else if (MessageType == 0x22) fprintf(stderr, " REG_C_RESP");
 	else if (MessageType == 0x24) fprintf(stderr, " GRP_REG_RESP");
@@ -549,24 +936,23 @@ void nxdn_message_type (dsd_opts * opts, dsd_state * state, uint8_t MessageType)
 	else if (MessageType == 0x38) fprintf(stderr, " SDCALL_REQ_HEADER");
 	else if (MessageType == 0x39) fprintf(stderr, " SDCALL_REQ_USERDATA");
 	else if (MessageType == 0x3B) fprintf(stderr, " SDCALL_RESP");
-
 	else if (MessageType == 0x3F) fprintf(stderr, " ALIAS"); 
-	else if (MessageType == 0x0C) fprintf(stderr, " DCALL_ACK"); 
 	else fprintf(stderr, " Unknown M-%02X", MessageType);
 	fprintf (stderr, "%s", KNRM);
 
-	//zero out stale values so they won't persist after a transmit release
-	//disable if random messages wipe out the alias
-	if (MessageType == 0x08 || MessageType == 0x10) //idle, tx_rel
+	//Zero out stale values on DISC or TX_REL only (IDLE messaages occur often on NXDN96 VCH, and randomly on Type-C FACCH1 steals for some reason)
+	if (MessageType == 0x08 || MessageType == 0x11)
 	{
 		memset (state->nxdn_alias_block_segment, 0, sizeof(state->nxdn_alias_block_segment));
 		state->nxdn_last_rid = 0;
 		state->nxdn_last_tg = 0;
-		state->nxdn_cipher_type = 0;
+		state->nxdn_cipher_type = 0; //force will reactivate it if needed during voice tx
+		if (state->keyloader == 1) state->R = 0;
 		memset (state->nxdn_sacch_frame_segcrc, 1, sizeof(state->nxdn_sacch_frame_segcrc));
-		memset (state->nxdn_sacch_frame_segment, 0, sizeof(state->nxdn_sacch_frame_segment));
+		memset (state->nxdn_sacch_frame_segment, 1, sizeof(state->nxdn_sacch_frame_segment));
 		sprintf (state->nxdn_call_type, "%s", "");
-	} 
+	}
+	 
 }
 
 //voice descrambler
@@ -669,13 +1055,32 @@ static uint16_t crc15(const uint8_t buf[], int len)
 
 static uint16_t crc16cac(const uint8_t buf[], int len)
 {
-	int crc = 0xc3ee;
-        int poly = (1<<12) + (1<<5) + 1;
-	for (int i=0;i<len;i++) {
-                crc = ((crc << 1) | buf[i]) & 0x1ffff;
-                if(crc & 0x10000)
-                        crc = (crc & 0xffff) ^ poly;
+	uint32_t crc = 0xc3ee; //not sure why this though
+	uint32_t poly = (1<<12) + (1<<5) + 1; //poly is fine
+	for (int i=0;i<len;i++) 
+	{
+		crc = ((crc << 1) | buf[i]) & 0x1ffff;
+		if(crc & 0x10000) crc = (crc & 0xffff) ^ poly;
 	}
-        crc = crc ^ 0xffff;
-        return crc & 0xffff;
+	crc = crc ^ 0xffff;
+	return crc & 0xffff;
+}
+
+static uint8_t crc7_scch(uint8_t bits[], int len)
+{
+	uint8_t s[7];
+	uint8_t a;
+	for (int i=0;i<7;i++)
+		s[i] = 1;
+	for (int i=0;i<len;i++) {
+		a = bits[i] ^ s[0];
+		s[0] = s[1];
+		s[1] = s[2]; 
+		s[2] = s[3]; 
+		s[3] = a ^ s[4];
+		s[4] = s[5];
+		s[5] = s[6]; 
+		s[6] = a;
+	}
+	return load_i(s, 7);
 }

src/nxdn_frame.c

@@ -32,53 +32,74 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
   // length is implicitly 192, with frame sync in first 10 dibits
 	uint8_t dbuf[182]; 
 	uint8_t lich;
-	int answer_len=0;
+	int answer_len = 0;
 	uint8_t answer[32];
 	uint8_t sacch_answer[32];
 	int lich_parity_received;
 	int lich_parity_computed;
-	int voice=0;
-	int facch=0;
-	int facch2=0;
-	int sacch=0;
-	int cac=0;
+	int voice = 0;
+	int facch = 0;
+	int facch2 = 0;
+	int udch = 0;
+	int sacch = 0;
+	int cac = 0;
 	int sr_structure;
 	int sr_ran;
 
-	uint8_t lich_dibits[8] = {0}; 
-	uint8_t sacch_bits[60] = {0};
-	uint8_t facch_bits_a[144] = {0};
-	uint8_t facch_bits_b[144] = {0};
-	uint8_t cac_bits[300] = {0};
-	uint8_t facch2_bits[348] = {0}; //facch2 or udch, same amount of bits
+	//new, and even more confusing NXDN Type-D / "IDAS" acronyms
+	int idas = 0;
+	int scch = 0;
+	int facch3 = 0;
+	int udch2 = 0;
 
-  //nxdn bit buffer, for easy assignment handling
-  int nxdn_bit_buffer[364] = {0}; 
-	int nxdn_dibit_buffer[182] = {0};
+	//new breakdown of lich codes
+	uint8_t lich_rf = 0; //RF Channel Type
+	uint8_t lich_fc = 0; //Functional Channel Type
+	uint8_t lich_op = 0; //Options
+	uint8_t direction; //inbound or outbound direction
 
+	uint8_t lich_dibits[8]; 
+	uint8_t sacch_bits[60];
+	uint8_t facch_bits_a[144];
+	uint8_t facch_bits_b[144];
+	uint8_t cac_bits[300];
+	uint8_t facch2_bits[348]; //facch2 or udch, same amount of bits
+	uint8_t facch3_bits[288]; //facch3 or udch2, same amount of bits
+
+	//nxdn bit buffer, for easy assignment handling
+	int nxdn_bit_buffer[364]; 
+	int nxdn_dibit_buffer[182];
+
+	//init all arrays
 	memset (dbuf, 0, sizeof(dbuf));
+	memset (answer, 0, sizeof(answer));
+	memset (sacch_answer, 0, sizeof(sacch_answer));
+	memset (lich_dibits, 0, sizeof(lich_dibits));
+	memset (sacch_bits, 0, sizeof(sacch_bits));
+	memset (facch_bits_b, 0, sizeof(facch_bits_b));
+	memset (facch_bits_a, 0, sizeof(facch_bits_a));
+	memset (cac_bits, 0, sizeof(cac_bits));
+	memset (facch2_bits, 0, sizeof(facch2_bits));
+
+	memset (nxdn_bit_buffer, 0, sizeof(nxdn_bit_buffer));
+	memset (nxdn_dibit_buffer, 0, sizeof(nxdn_dibit_buffer));
 
 	//collect lich bits first, if they are good, then we can collect the rest of them
-  for (int i = 0; i < 8; i++) 
-  {
-		lich_dibits[i] = dbuf[i] = getDibit(opts, state);
-  }
+	for (int i = 0; i < 8; i++) lich_dibits[i] = dbuf[i] = getDibit(opts, state);
 
 	nxdn_descramble (lich_dibits, 8);
 	
 	lich = 0;
-	for (int i=0; i<8; i++)
-  {
-    lich |= (lich_dibits[i] >> 1) << (7-i);
-  }
+	for (int i=0; i<8; i++) lich |= (lich_dibits[i] >> 1) << (7-i);
 		
 	lich_parity_received = lich & 1;
 	lich_parity_computed = ((lich >> 7) + (lich >> 6) + (lich >> 5) + (lich >> 4)) & 1;
 	lich = lich >> 1;
 	if (lich_parity_received != lich_parity_computed)
-  {
-    //fprintf(stderr, "NXDN lich parity error, ignoring frame \n");
-		return;
+	{
+		if (opts->payload == 1) fprintf(stderr, "  Lich Parity Error %02X\n", lich);
+		state->lastsynctype = -1; //set to -1 so we don't jump back here too quickly 
+		goto END;
 	}
   
 	voice = 0;
@@ -86,6 +107,16 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
 	facch2 = 0;
 	sacch = 0;
 	cac = 0;
+
+	//test for inbound direction lich when trunking (false positive) and skip
+	//all inbound lich are even value (lsb is set to 0 for inbound direction)
+	if (lich % 2 == 0 && opts->p25_trunk == 1)
+	{
+		if (opts->payload == 1) fprintf(stderr, "  Simplex/Inbound NXDN lich on trunking system - type 0x%02X\n", lich);
+		state->lastsynctype = -1; //set to -1 so we don't jump back here too quickly 
+		goto END;
+	}
+
 	switch(lich) { //cases without breaks continue to flow downwards until they hit the break
 	case 0x01:	// CAC types
 	case 0x05:
@@ -93,21 +124,20 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
 		break;
 	case 0x28:  //facch2 types
 	case 0x29:
-	case 0x2e:
-	case 0x2f:
 	case 0x48:
 	case 0x49:
+		facch2 = 1;
+		break;
+	case 0x2e: //udch types
+	case 0x2f:
 	case 0x4e:
 	case 0x4f:
-	case 0x69:
-	case 0x6f:
-		facch2 = 1;
+		udch = 1;
 		break;
 	case 0x32:  //facch in 1, vch in 2
 	case 0x33:
 	case 0x52:
 	case 0x53:
-	case 0x73:
 		voice = 2;	
 		facch = 1;
 		sacch = 1;
@@ -115,17 +145,15 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
 	case 0x34:  //vch in 1, facch in 2
 	case 0x35:
 	case 0x54:
-	case 0x55:
-	case 0x75:
+	case 0x55: //disabled for testing, IDAS system randomly triggers this one, probably due to poor signal
 		voice = 1;	
 		facch = 2;
 		sacch = 1;
 		break;
 	case 0x36:  //vch in both
 	case 0x37:
-	case 0x56:
+	case 0x56: 
 	case 0x57: 
-	case 0x77:
 		voice = 3;	
 		facch = 0;
 		sacch = 1;
@@ -138,8 +166,6 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
 	case 0x41:
 	case 0x50:
 	case 0x51:
-	case 0x61:
-	case 0x71:
 		voice = 0;
 		facch = 3;	
 		sacch = 1;
@@ -148,10 +174,63 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
 	case 0x39:
 		sacch = 1;
 		break;
+
+	//NXDN "Type-D" or "IDAS" Specific Lich Codes
+	case 0x76: //normal vch voice (in one and two)
+	case 0x77: 
+		idas = 1;
+		scch = 1;
+		voice = 3;
+		break;
+	case 0x74: //vch in 1, facch1 in 2 (facch 2 steal)
+	case 0x75:
+		idas = 1;
+		scch = 1;
+		voice = 1;
+		facch = 2;
+		break;
+	case 0x72: //facch in 1, vch in 2 (facch 1 steal)
+	case 0x73:
+		idas = 1;
+		scch = 1;
+		voice = 2;
+		facch = 1;
+		break;
+	case 0x70: //facch steal in vch 1 and vch 2 (during voice only)
+	case 0x71:
+		idas = 1;
+		scch = 1;
+		facch = 3;
+		break;
+	case 0x6E: //udch2
+	case 0x6F:
+		idas = 1;
+		scch = 1;
+		udch2 = 1;
+		break;
+	case 0x68:
+	case 0x69: //facch3
+		idas = 1;
+		scch = 1;
+		facch3 = 1;
+		break;
+	case 0x62:
+	case 0x63: //facch1 in 1, null data and post field in 2
+		idas = 1;
+		scch = 1;
+		facch = 1;
+		break;
+	case 0x60:
+	case 0x61: //facch1 in both (non vch)
+		idas = 1;
+		scch = 1;
+		facch = 3;
+		break;
+
 	default:
     if (opts->payload == 1) fprintf(stderr, "  false sync or unsupported NXDN lich type 0x%02X\n", lich);
 		//reset the sacch field, we probably got a false sync and need to wipe or give a bad crc
-		memset (state->nxdn_sacch_frame_segment, 0, sizeof(state->nxdn_sacch_frame_segment));
+		memset (state->nxdn_sacch_frame_segment, 1, sizeof(state->nxdn_sacch_frame_segment));
 		memset (state->nxdn_sacch_frame_segcrc, 1, sizeof(state->nxdn_sacch_frame_segcrc));
 		state->lastsynctype = -1; //set to -1 so we don't jump back here too quickly 
 		voice = 0;
@@ -159,17 +238,29 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
 		break;
 	} // end of switch(lich)
 
+	//enable these after good lich parity and known lich value
+	state->carrier = 1;
+	state->last_cc_sync_time = time(NULL);
+
 	//printframesync after determining we have a good lich and it has something in it
-	if (voice || facch || sacch || facch2 || cac)
+	if (idas)
+	{
+		if (opts->frame_nxdn48 == 1)
+		{
+			printFrameSync (opts, state, "IDAS D ", 0, "-");
+		}
+		if (opts->payload == 1) 
+			fprintf (stderr, "L%02X - ", lich);
+	}
+	else if (voice || facch || sacch || facch2 || udch || cac)
 	{
-		// if (state->synctype == 28) fprintf (stderr, " +");
-		// else fprintf (stderr, " -");
 		if (opts->frame_nxdn48 == 1)
 		{
 			printFrameSync (opts, state, "NXDN48 ", 0, "-");
 		}
 		else printFrameSync (opts, state, "NXDN96 ", 0, "-");
-		if (opts->payload == 1) fprintf (stderr, "L%02X -", lich);
+		if (opts->payload == 1)
+			fprintf (stderr, "L%02X - ", lich);
 	}
 
 	//now that we have a good LICH, we can collect all of our dibits
@@ -188,7 +279,7 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
 		nxdn_bit_buffer[i*2+1] = dbuf[i] & 1;
 	}
 
-	//sacch
+	//sacch or scch bits
 	for (int i = 0; i < 60; i++)
 	{
 		sacch_bits[i] = nxdn_bit_buffer[i+16];
@@ -213,23 +304,122 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
 		facch2_bits[i] = nxdn_bit_buffer[i+16];
 	}
 
+	//udch2 or facch3
+	for (int i = 0; i < 288; i++)
+	{
+		facch3_bits[i] = nxdn_bit_buffer[i+16+60];
+	}
+
 	//vch frames stay inside dbuf, easier to assign that to ambe_fr frames
 	//sacch needs extra handling depending on superframe or non-superframe variety
 
-	if (voice)
+	//Add advanced decoding of LICH (RF, FC, OPT, and Direction
+	lich_rf = (lich >> 5) & 0x3;
+	lich_fc = (lich >> 3) & 0x3;
+	lich_op = (lich >> 1) & 0x3;
+	if (lich % 2 == 0) direction = 0;
+	else direction = 1;
+
+	// RF Channel Type
+	if (lich_rf == 0) fprintf (stderr, "RCCH ");
+	else if (lich_rf == 1) fprintf (stderr, "RTCH ");
+	else if (lich_rf == 2) fprintf (stderr, "RDCH ");
+	else
+	{
+		if (lich < 0x60) fprintf (stderr, "RTCH_C ");
+		else fprintf (stderr, "RTCH2 ");
+	}
+
+	// Functional Channel Type -- things start to get really convoluted here
+	// These will echo when handled, either with the decoded message type, or relevant crc err
+	// if (lich_rf == 0) //CAC Type
+	// {
+	// 	//Technically, we should be checking direction as well, but the fc never has split meaning on CAC
+	// 	if (lich_fc == 0) fprintf (stderr, "CAC ");
+	// 	else if (lich_fc == 1) fprintf (stderr, "Long CAC ");
+	// 	else if (lich_fc == 3) fprintf (stderr, "Short CAC ");
+	// 	else fprintf (stderr, "Reserved ");
+	// }
+	// else //USC Type
+	// {
+	// 	if (lich_fc == 0) fprintf (stderr, "NSF SACCH ");
+	// 	else if (lich_fc == 1) fprintf (stderr, "UDCH ");
+	// 	else if (lich_fc == 2) fprintf (stderr, "SF SACCH ");
+	// 	else if (lich_fc == 3) fprintf (stderr, "SF SACCH/IDLE ");
+	// }
+
+#ifdef LIMAZULUTWEAKS
+
+  //LimaZulu specific tweak, load keys from frequency value, if avalable -- test before VCALL
+	//needs to be loaded here, if superframe data pair, then we need to run the LFSR on it as well
+
+	if (voice) //can this run TOO frequently?
+	{
+		long int freq = 0;
+		uint8_t hash_bits[24];
+		memset (hash_bits, 0, sizeof(hash_bits));
+		uint16_t limazulu = 0;
+			
+		//if not available, then poll rigctl if its available
+		if (opts->use_rigctl == 1)
+			freq = GetCurrentFreq (opts->rigctl_sockfd);
+
+		//if using rtl input, we can ask for the current frequency tuned
+		else if (opts->audio_in_type == 3)
+			freq = (long int)opts->rtlsdr_center_freq;
+
+		// freq = 167831250; //hardset for  testing
+
+		//since a frequency value will be larger than the 16-bit max, we need to hash it first
+		//the hash has to be run the same way as the import, so at a 24-bit depth, which hopefully
+		//will not lead to any duplicate key loads due to multiple CRC16 collisions on a larger value?
+		for (int i = 0; i < 24; i++)
+			hash_bits[i] = ((freq << i) & 0x800000) >> 23; //load into array for CRC16 
+
+		if (freq) limazulu = ComputeCrcCCITT16d (hash_bits, 24);
+		limazulu = limazulu & 0xFFFF; //make sure no larger than 16-bits
+
+		fprintf (stderr, "%s", KYEL);
+		if (freq) fprintf (stderr, "\n Freq: %ld - Freq Hash: %d", freq, limazulu);
+		if (state->rkey_array[limazulu] != 0) fprintf (stderr, " - Key Loaded: %lld", state->rkey_array[limazulu]);
+		fprintf (stderr, "%s", KNRM);
+
+		if (state->rkey_array[limazulu] != 0) 
+			state->R = state->rkey_array[limazulu];
+
+		if (state->R != 0 && state->M == 1) state->nxdn_cipher_type = 0x1;
+
+		//add additional time to last_sync_time for LimaZulu to hold on current frequency
+		//a little longer without affecting normal scan time on trunk_hangtime variable
+		state->last_cc_sync_time = time(NULL) + 2; //ask him for an ideal wait timer
+	}
+
+#endif //end LIMAZULUTWEAKS
+
+	if (opts->scanner_mode == 1)
+		state->last_cc_sync_time = time(NULL) + 2; //add a little extra hangtime between resuming scan
+
+	//Option/Steal Flags echoed in Voice, V+F, or Data 
+	if (voice && !facch) //voice only, no facch steal
 	{
 		fprintf (stderr, "%s", KGRN);
 		fprintf (stderr, " Voice ");
 		fprintf (stderr, "%s", KNRM);
 	}
-	else
+	else if (voice && facch) //voice with facch1 steal
+	{
+		fprintf (stderr, "%s", KGRN);
+		fprintf (stderr, " V%d+F%d ", 3 - facch, facch); //print which position on each
+		fprintf (stderr, "%s", KNRM);
+	}
+	else //Covers FACCH1 in both, FACCH2, UDCH, UDCH2, CAC
 	{
 		fprintf (stderr, "%s", KCYN);
 		fprintf (stderr, " Data  ");
 		fprintf (stderr, "%s", KNRM);
 
 		//roll the voice scrambler LFSR here if key available to advance seed (usually just needed on NXDN96)
-		if (state->nxdn_cipher_type == 0x1 && state->R != 0) //!voice, or voice == 0
+		if (state->nxdn_cipher_type == 0x1 && state->R != 0) 
 		{
 			char ambe_temp[49] = {0};
 			char ambe_d[49] = {0};
@@ -239,39 +429,98 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
 			}
 		}
 
-	}  
+	}
 
-	state->nxdn_sacch_non_superframe = (lich == 0x20 || lich == 0x21 || lich == 0x61 || lich == 0x40 || lich == 0x41) ? true : false;
-	if (sacch)nxdn_deperm_sacch(opts, state, sacch_bits);
-	if (cac) nxdn_deperm_cac(opts, state, cac_bits); 
-	if (facch2) nxdn_deperm_facch2_udch(opts, state, facch2_bits);
+	if (voice && facch == 1) //facch steal 1 -- before voice
+	{
+		//force scrambler here, but with unspecified key (just use what's loaded)
+		if (state->M == 1 && state->R != 0) state->nxdn_cipher_type = 0x1; 
+		//roll the voice scrambler LFSR here if key available to advance seed -- half rotation on a facch steal
+		if (state->nxdn_cipher_type == 0x1 && state->R != 0)
+		{
+			char ambe_temp[49] = {0};
+			char ambe_d[49] = {0};
+			for (int i = 0; i < 2; i++)
+			{
+				LFSRN(ambe_temp, ambe_d, state);
+			}
+		}  
+	}
+
+	if (lich == 0x20 || lich == 0x21 || lich == 0x61 || lich == 0x40 || lich == 0x41) state->nxdn_sacch_non_superframe = TRUE;
+	else state->nxdn_sacch_non_superframe = FALSE;
+
+	//TODO Later: Add Direction and/or LICH to all decoding functions
+	if (scch) nxdn_deperm_scch (opts, state, sacch_bits, direction);
+
+	if (udch2)  nxdn_deperm_facch3_udch2(opts, state, facch3_bits, 0);
+	if (facch3) nxdn_deperm_facch3_udch2(opts, state, facch3_bits, 1);
+
+	if (sacch)  nxdn_deperm_sacch(opts, state, sacch_bits);
+	if (cac)    nxdn_deperm_cac(opts, state, cac_bits);
+
+	//Seperated UDCH user data from facch2 data 
+	if (udch)   nxdn_deperm_facch2_udch(opts, state, facch2_bits, 0);
+	if (facch2) nxdn_deperm_facch2_udch(opts, state, facch2_bits, 1);
+
+	//SHOULD be okay to run facch1's again on steal frames, will need testing
+	// if (facch & 1) nxdn_deperm_facch(opts, state, facch_bits_a);
+	// if (facch & 2) nxdn_deperm_facch(opts, state, facch_bits_b);
+
+	//only run facch in second slot if its not equal to the first one
+	//ideally, this would work better AFTER decoding/FEC
 	if (facch & 1) nxdn_deperm_facch(opts, state, facch_bits_a);
-	if (facch & 2) nxdn_deperm_facch(opts, state, facch_bits_b);
+	if (facch & 2)
+	{
+		if (memcmp (facch_bits_a, facch_bits_b, 144) != 0)
+			nxdn_deperm_facch(opts, state, facch_bits_b);
+	}
+
 	if (voice)
 	{
 		//restore MBE file open here
 		if ((opts->mbe_out_dir[0] != 0) && (opts->mbe_out_f == NULL)) openMbeOutFile (opts, state);
 		//update last voice sync time
 		state->last_vc_sync_time = time(NULL);
+		//turn on scrambler if forced by user option
+		if (state->M == 1 && state->R != 0) state->nxdn_cipher_type = 0x1;
 		//process voice frame
 		nxdn_voice (opts, state, voice, dbuf); 
 	}
+
 	//close MBE file if no voice and its open
 	if (!voice)
 	{
 		if (opts->mbe_out_f != NULL)
 		{
-			if (opts->frame_nxdn96 == 1) //nxdn96 has voice and data mixed together, so we will need to do a time check first
+			if (opts->frame_nxdn96 == 1) //nxdn96 has pure voice and data frames mixed together, so we will need to do a time check first
 			{
 				if ( (time(NULL) - state->last_vc_sync_time) > 1) //test for optimal time, 1 sec should be okay
 				{
 					closeMbeOutFile (opts, state);
 				} 
 			}
-			if (opts->frame_nxdn48 == 1) closeMbeOutFile (opts, state); //okay to close right away if nxdn48, no data/voice mixing
+			//may need to reconsider this, due to double FACCH1 steals on some Type-C (ASSGN_DUP, etc) and Conventional Systems (random IDLE FACCH1 steal for no reason)
+			if (opts->frame_nxdn48 == 1) closeMbeOutFile (opts, state); //okay to close right away if nxdn48, no data/voice frames mixing
 		} 
-	} 
+	}
+
+	if (voice && facch == 2) //facch steal 2 -- after voice 1
+	{
+		//roll the voice scrambler LFSR here if key available to advance seed -- half rotation on a facch steal
+		if (state->nxdn_cipher_type == 0x1 && state->R != 0)
+		{
+			char ambe_temp[49] = {0};
+			char ambe_d[49] = {0};
+			for (int i = 0; i < 2; i++)
+			{
+				LFSRN(ambe_temp, ambe_d, state);
+			}
+		}  
+	}
+	
+	if (opts->payload == 1 && !voice) fprintf (stderr, "\n");
+	else if (opts->payload == 0) fprintf (stderr, "\n");
 
-	fprintf (stderr, "\n");
 	END: ; //do nothing
 }

src/p25_frequency.c

@@ -2,7 +2,7 @@
  * p25_frequency.c
  * P25 Channel to Frequency Calculator
  *
- * NXDN Channel to Frequency, Courtesy of IcomIcR20 and EricCottrell (base values)
+ * NXDN Channel to Frequency Calculator
  * 
  * LWVMOBILE
  * 2022-11 DSD-FME Florida Man Edition
@@ -59,16 +59,16 @@ long int process_channel_to_freq (dsd_opts * opts, dsd_state * state, int channe
 
 }
 
-//NXDN Channel to Frequency, Courtesy of IcomIcR20 on RR Forums
 long int nxdn_channel_to_frequency(dsd_opts * opts, dsd_state * state, uint16_t channel)
 {
 	long int freq;
 	long int base = 0;
+	long int step = 0;
 
-	//the base freq value is per EricCottrell in the Understanding NXDN Trunking Forum Thread
-	//will need to do some research or tests to confirm these values are accurate
+	//reworked to include Direct Frequency Assignment if available
 
-	//first, check channel map
+	//first, check channel map for imported value, DFA systems most likely won't need an import,
+	//unless it has 'system definable' attributes
 	if (state->trunk_chan_map[channel] != 0)
 	{
 		freq = state->trunk_chan_map[channel];
@@ -76,33 +76,41 @@ long int nxdn_channel_to_frequency(dsd_opts * opts, dsd_state * state, uint16_t
 		return (freq);
 	}
 
-	//if not found, attempt to find it via calculation 
-	else
+	//then, let's see if its DFA instead -- 6.5.36
+	else if (state->nxdn_rcn == 1)
 	{
-		if ((channel > 0) && (channel <= 400))
-		{
-			if (opts->frame_nxdn48 == 1) base = 450000000;
-			else base = 451000000;
+		//determine the base frequency in Hz
+		if (state->nxdn_base_freq == 1)				base = 100000000; //100 MHz
+		else if (state->nxdn_base_freq == 2) 	base = 330000000; //330 Mhz
+		else if (state->nxdn_base_freq == 3)	base = 400000000; //400 Mhz
+		else if (state->nxdn_base_freq == 4)	base = 750000000; //750 Mhz
+		else base = 0; //just set to zero, will be system definable most likely and won't be able to calc
 
-			freq = base + (channel - 1) * 12500;
-			fprintf (stderr, "\n  Frequency [%.6lf] MHz", (double)freq/1000000);
+		//determine the step value in Hz
+		if (state->nxdn_step = 2)				step = 1250; //1.25 kHz
+		else if (state->nxdn_step = 3)	step = 3125; //3.125 kHz
+		else step = 0; //just set to zero, will be system definable most likely and won't be able to calc
+
+		//if we have a valid base and step, then calc frequency
+		//6.5.45. Outbound/Inbound Frequency Number (OFN/IFN)
+		if (base && step)
+		{
+			freq = base + (channel * step);
+			fprintf (stderr, "\n  DFA Frequency [%.6lf] MHz", (double)freq/1000000);
 			return (freq);
 		}
-		else if ((channel >= 401) && (channel <= 800))
+		else 
 		{
-			if (opts->frame_nxdn48 == 1) base = 460000000;
-			else base = 461000000;
-
-			freq = base + (channel - 401) * 12500;
-			fprintf (stderr, "\n  Frequency [%.6lf] MHz", (double)freq/1000000);
-			return (freq);
-		}
-		else
-		{
-			fprintf(stderr, "\n  Non-standard frequency or channel not found in import file");
+			fprintf(stderr, "\n    Custom DFA Settings -- Unknown Freq;");
 			return (0);
 		}
+		
 	}
-	
+
+	else
+	{
+		fprintf(stderr, "\n    Channel not found in import file");
+		return (0);
+	} 
 
 }

src/p25_lcw.c

@@ -1,160 +1,363 @@
+/*-------------------------------------------------------------------------------
+ * p25_lcw.c
+ * P25p1 Link Control Word Decoding
+ *
+ * LWVMOBILE
+ * 2023-05 DSD-FME Florida Man Edition
+ *-----------------------------------------------------------------------------*/
+
 #include "dsd.h"
 
-void
-processP25lcw (dsd_opts * opts, dsd_state * state, char *lcformat, char *mfid, char *lcinfo)
+//new p25_lcw function here -- TIA-102.AABF-D LCW Format Messages (if anybody wants to fill the rest out)
+void p25_lcw (dsd_opts * opts, dsd_state * state, uint8_t LCW_bits[], uint8_t irrecoverable_errors)
 {
+  uint8_t lc_format = (uint8_t)ConvertBitIntoBytes(&LCW_bits[0], 8);  //format
+  uint8_t lc_opcode = (uint8_t)ConvertBitIntoBytes(&LCW_bits[2], 8);  //opcode portion of format
+  uint8_t lc_mfid   = (uint8_t)ConvertBitIntoBytes(&LCW_bits[8], 8);  //mfid
+  uint8_t lc_svcopt = (uint8_t)ConvertBitIntoBytes(&LCW_bits[16], 8); //service options
+  uint8_t lc_pf = LCW_bits[0]; //protect flag
+  uint8_t lc_sf = LCW_bits[1]; //Implicit / Explicit MFID Format
 
-  char tgid[17], tmpstr[255];
-  long talkgroup, source;
-  int i, j;
+  if (lc_pf == 1) //check the protect flag -- if set, its an encrypted lcw
+  {
+    fprintf (stderr, "%s",KRED);
+    fprintf (stderr, " LCW Protected ");
+    fprintf (stderr, "%s",KNRM);
+  }
 
-  tgid[16] = 0;
+  if (lc_pf == 0) //not protected/encrypted lcw
+  {
 
-  if (opts->p25lc == 1)
-    {
-      fprintf (stderr, "lcformat: %s mfid: %s lcinfo: %s ", lcformat, mfid, lcinfo);
-      if (opts->p25tg == 0)
-        {
-          fprintf (stderr, "\n");
-        }
-    }
+    if (opts->payload == 1) fprintf (stderr, " LCW"); 
 
-  if (strcmp (lcformat, "00000100") == 0)
+    //check to see if we need to run these as MFID 0 or 1 only (standard)
+    if (lc_mfid == 0 || lc_mfid == 1) //lc_mfid == 0
     {
 
-      // first tg is the active channel
-      j = 0;
-      for (i = 40; i < 52; i++)
+      //check the service options on applicable formats
+      if (lc_format == 0x4A || lc_format == 0x46 || lc_format == 0x45 
+          || lc_format == 0x44 || lc_format == 0x03 || lc_format == 0x00)
+      {
+
+        if (lc_svcopt & 0x80) fprintf (stderr, " Emergency");
+        if (lc_svcopt & 0x40) fprintf (stderr, " Encrypted");
+
+        if (opts->payload == 1) //hide behind payload due to len
         {
-          if (state->tgcount < 24)
-            {
-              state->tg[state->tgcount][j] = lcinfo[i];
-            }
-          tmpstr[j] = lcinfo[i];
-          j++;
+          if (lc_svcopt & 0x20) fprintf (stderr, " Duplex");
+          if (lc_svcopt & 0x10) fprintf (stderr, " Packet");
+          else fprintf (stderr, " Circuit");
+          if (lc_svcopt & 0x8) fprintf (stderr, " R"); //reserved bit is on
+          fprintf (stderr, " Priority %d", lc_svcopt & 0x7); //call priority
         }
-      tmpstr[12] = 48;
-      tmpstr[13] = 48;
-      tmpstr[14] = 48;
-      tmpstr[15] = 48;
-      tmpstr[16] = 0;
-      talkgroup = strtol (tmpstr, NULL, 2);
-      state->lasttg = talkgroup;
-      if (state->tgcount < 24)
+      }
+
+      if (lc_format == 0x00)
+      {
+        fprintf (stderr, " Group Voice Channel User");
+        uint8_t res    = (uint8_t)ConvertBitIntoBytes(&LCW_bits[24], 7);
+        uint8_t explicit = LCW_bits[24]; //explicit source id required == 1, full SUID on seperate LCW
+        uint16_t group = (uint16_t)ConvertBitIntoBytes(&LCW_bits[32], 16);
+        uint32_t source = (uint32_t)ConvertBitIntoBytes(&LCW_bits[48], 24);
+        fprintf (stderr, " - Group %d Source %d", group, source);
+
+        //don't set this when zero, annoying blink occurs in ncurses
+        if (group != 0) state->lasttg = group;
+        if (source != 0) state->lastsrc = source;
+
+        sprintf (state->call_string[0], "   Group ");
+        if (lc_svcopt & 0x80) strcat (state->call_string[0], " Emergency  ");
+        else if (lc_svcopt & 0x40) strcat (state->call_string[0], " Encrypted  ");
+        else strcat (state->call_string[0], "            ");
+      }
+
+      else if (lc_format == 0x03)
+      {
+        fprintf (stderr, " Unit to Unit Voice Channel User");
+        uint32_t target = (uint32_t)ConvertBitIntoBytes(&LCW_bits[24], 24);
+        uint32_t source = (uint32_t)ConvertBitIntoBytes(&LCW_bits[48], 24);
+        fprintf (stderr, " - Target %d Source %d", target, source);
+
+        //don't set this when zero, annoying blink occurs in ncurses
+        if (target != 0) state->lasttg = target;
+        if (source != 0) state->lastsrc = source;
+
+        sprintf (state->call_string[0], " Private ");
+        if (lc_svcopt & 0x80) strcat (state->call_string[0], " Emergency  ");
+        else if (lc_svcopt & 0x40) strcat (state->call_string[0], " Encrypted  ");
+        else strcat (state->call_string[0], "            ");
+
+      }
+
+      //uses explicit bit?
+      else if (lc_format == 0x42) //is this group only, or group and private?
+      {
+        fprintf (stderr, " Group Voice Channel Update - ");
+        uint16_t channel1 = (uint16_t)ConvertBitIntoBytes(&LCW_bits[8], 16);
+        uint16_t group1   = (uint16_t)ConvertBitIntoBytes(&LCW_bits[24], 16);
+        uint16_t channel2 = (uint16_t)ConvertBitIntoBytes(&LCW_bits[40], 16);
+        uint16_t group2   = (uint16_t)ConvertBitIntoBytes(&LCW_bits[56], 16);
+
+        if (channel1 && group1)
         {
-          state->tgcount = state->tgcount + 1;
-        }
-      if (opts->p25tg == 1)
-        {
-          fprintf (stderr, "tg: %li ", talkgroup);
+          fprintf (stderr, "Ch: %04X TG: %d; ", channel1, group1);
+          sprintf (state->active_channel[0], "Active Ch: %04X TG: %d; ", channel1, group1);
+          state->last_active_time = time(NULL);
         }
 
-      if (opts->p25tg == 1)
+        if (channel2 && group2 && group1 != group2)
         {
-          fprintf (stderr, "tg: %li ", talkgroup);
-
-          // the remaining 3 appear to be other active tg's on the system
-          j = 0;
-          for (i = 28; i < 40; i++)
-            {
-              tmpstr[j] = lcinfo[i];
-              j++;
-            }
-          tmpstr[12] = 48;
-          tmpstr[13] = 48;
-          tmpstr[14] = 48;
-          tmpstr[15] = 48;
-          tmpstr[16] = 0;
-          talkgroup = strtol (tmpstr, NULL, 2);
-          fprintf (stderr, "%li ", talkgroup);
-          j = 0;
-          for (i = 16; i < 28; i++)
-            {
-              tmpstr[j] = lcinfo[i];
-              j++;
-            }
-          tmpstr[12] = 48;
-          tmpstr[13] = 48;
-          tmpstr[14] = 48;
-          tmpstr[15] = 48;
-          tmpstr[16] = 0;
-          talkgroup = strtol (tmpstr, NULL, 2);
-          fprintf (stderr, "%li ", talkgroup);
-          j = 0;
-          for (i = 4; i < 16; i++)
-            {
-              tmpstr[j] = lcinfo[i];
-              j++;
-            }
-          tmpstr[12] = 48;
-          tmpstr[13] = 48;
-          tmpstr[14] = 48;
-          tmpstr[15] = 48;
-          tmpstr[16] = 0;
-          talkgroup = strtol (tmpstr, NULL, 2);
-          fprintf (stderr, "%li\n", talkgroup);
+          fprintf (stderr, "Ch: %04X TG: %d; ", channel2, group2);
+          sprintf (state->active_channel[1], "Active Ch: %04X TG: %d; ", channel2, group2);
+          state->last_active_time = time(NULL);
         }
+
+      }
+
+      else if (lc_format == 0x44)
+      {
+        fprintf (stderr, " Group Voice Channel Update – Explicit");
+        uint16_t group1   = (uint16_t)ConvertBitIntoBytes(&LCW_bits[24], 16);
+        uint16_t channelt = (uint16_t)ConvertBitIntoBytes(&LCW_bits[40], 16);
+        uint16_t channelr = (uint16_t)ConvertBitIntoBytes(&LCW_bits[56], 16);
+        fprintf (stderr, "Ch: %04X TG: %d; ", channelt, group1);
+      }
+
+      else if (lc_format == 0x45)
+      {
+        fprintf (stderr, " Unit to Unit Answer Request");
+      }
+
+      else if (lc_format == 0x46)
+      {
+        fprintf (stderr, " Telephone Interconnect Voice Channel User");
+      }
+
+      else if (lc_format == 0x47)
+      {
+        fprintf (stderr, " Telephone Interconnect Answer Request");
+      }
+
+      else if (lc_format == 0x49)
+      {
+        fprintf (stderr, " Souce ID Extension");
+      }
+
+      else if (lc_format == 0x4A) 
+      {
+        fprintf (stderr, " Unit to Unit Voice Channel User – Extended");
+        uint32_t target = (uint32_t)ConvertBitIntoBytes(&LCW_bits[16], 24);
+        uint32_t suid   = (uint32_t)ConvertBitIntoBytes(&LCW_bits[40], 24);
+        fprintf (stderr, "TGT: %04X SUID: %d; ", target, suid);
+      }
+
+      else if (lc_format == 0x50)
+      {
+        fprintf (stderr, " Group Affiliation Query");
+      }
+
+      else if (lc_format == 0x51)
+      {
+        fprintf (stderr, " Unit Registration Command");
+      }
+
+      else if (lc_format == 0x52) //wonder if anybody uses this if its deleted/obsolete
+      {
+        fprintf (stderr, " Unit Authentication Command - OBSOLETE");
+      }
+
+      else if (lc_format == 0x53) 
+      {
+        fprintf (stderr, " Status Query");
+      }
+
+      else if (lc_format == 0x54) 
+      {
+        fprintf (stderr, " Status Update");
+      }
+
+      else if (lc_format == 0x55) 
+      {
+        fprintf (stderr, " Status Update");
+      }
+
+      else if (lc_format == 0x56) 
+      {
+        fprintf (stderr, " Call Alert");
+      }
+
+      else if (lc_format == 0x57) 
+      {
+        fprintf (stderr, " Extended Function Command");
+      }
+
+      else if (lc_format == 0x58) 
+      {
+        fprintf (stderr, " Channel Identifier Update");
+      }
+
+      else if (lc_format == 0x59) 
+      {
+        fprintf (stderr, " Channel Identifier Update VU");
+      }
+
+      else if (lc_format == 0x5A) 
+      {
+        fprintf (stderr, " Status Update – Source ID Extension Required");
+      }
+
+      else if (lc_format == 0x5C) 
+      {
+        fprintf (stderr, " Extended Function Command – Source ID Extension Required");
+      }
+
+      else if (lc_format == 0x60) 
+      {
+        fprintf (stderr, " System Service Broadcast");
+      }
+
+      else if (lc_format == 0x61) 
+      {
+        fprintf (stderr, " Secondary Control Channel Broadcast");
+      }
+
+      else if (lc_format == 0x62) 
+      {
+        fprintf (stderr, " Adjacent Site Status Broadcast");
+      }
+
+      else if (lc_format == 0x63) 
+      {
+        fprintf (stderr, " RFSS Status Broadcast");
+      }
+
+      else if (lc_format == 0x64) 
+      {
+        fprintf (stderr, " Network Status Broadcast");
+      }
+
+      else if (lc_format == 0x65) 
+      {
+        fprintf (stderr, " Protection Parameter Broadcast - OBSOLETE");
+      }
+
+
+      else if (lc_format == 0x66) 
+      {
+        fprintf (stderr, " Secondary Control Channel Broadcast – Explicit (LCSCBX)");
+      }
+
+      else if (lc_format == 0x67) //explicit
+      {
+        fprintf (stderr, " Adjacent Site Status (LCASBX)");
+        uint8_t lra = (uint8_t)ConvertBitIntoBytes(&LCW_bits[8], 8);
+        uint16_t channelt = (uint16_t)ConvertBitIntoBytes(&LCW_bits[16], 16);
+        uint8_t rfssid = (uint8_t)ConvertBitIntoBytes(&LCW_bits[32], 8);
+        uint8_t siteid = (uint8_t)ConvertBitIntoBytes(&LCW_bits[40], 8);
+        uint16_t channelr = (uint16_t)ConvertBitIntoBytes(&LCW_bits[48], 16);
+        uint8_t cfva = (uint8_t)ConvertBitIntoBytes(&LCW_bits[64], 4);
+        fprintf (stderr, " - RFSS %d Site %d CH %04X", rfssid, siteid, channelt);
+
+        //debug print only
+        // fprintf (stderr, "\n  ");
+        // fprintf (stderr, "  LRA [%02X] RFSS [%03d] SITE [%03d] CHAN-T [%04X] CHAN-R [%02X] CFVA [%X]\n  ", lra, rfssid, siteid, channelt, channelr, cfva);
+        // if (cfva & 0x8) fprintf (stderr, " Conventional");
+        // if (cfva & 0x4) fprintf (stderr, " Failure Condition");
+        // if (cfva & 0x2) fprintf (stderr, " Up to Date (Correct)");
+        // else fprintf (stderr, " Last Known");
+        if (cfva & 0x1) fprintf (stderr, "- Connection Active");
+        // process_channel_to_freq (opts, state, channelt);
+        //end debug, way too much for a simple link control line 
+
+
+      }
+
+      else if (lc_format == 0x68) 
+      {
+        fprintf (stderr, " RFSS Status Broadcast – Explicit (LCRSBX)");
+      }
+
+      else if (lc_format == 0x69) 
+      {
+        fprintf (stderr, " Network Status Broadcast – Explicit (LCNSBX)");
+      }
+
+      else if (lc_format == 0x6A) 
+      {
+        fprintf (stderr, " Conventional Fallback");
+      }
+
+      else if (lc_format == 0x6B) 
+      {
+        fprintf (stderr, " Message Update – Source ID Extension Required");
+      }
+
+      //tune back to CC here - save about 1-2 seconds
+      else if (lc_format == 0x4F) //# Call Termination/Cancellation 
+      {
+        fprintf (stderr, " Call Termination");
+        if (opts->p25_trunk == 1 && state->p25_cc_freq != 0 && opts->p25_is_tuned == 1)
+        {
+          
+          //Will we need to check for a symbolrate change here, can a P25p2 TDMA-CC system
+          //revert back to a phase 1 traffic channel or carry a phase 1 traffic channel?
+
+          //clear heuristics from current traffic channel
+          if (opts->frame_p25p1 == 1 && opts->use_heuristics == 1)
+          {
+            initialize_p25_heuristics(&state->p25_heuristics);
+            initialize_p25_heuristics(&state->inv_p25_heuristics);
+          }
+
+          //rigctl
+          if (opts->use_rigctl == 1)
+          {
+            state->lasttg = 0;
+            state->lastsrc = 0;
+            state->payload_algid = 0; 
+            state->payload_keyid = 0;
+            // state->payload_miP = 0;
+            //reset some strings
+            sprintf (state->call_string[0], "%s", "                     "); //21 spaces
+            sprintf (state->call_string[1], "%s", "                     "); //21 spaces
+            sprintf (state->active_channel[0], "%s", "");
+            sprintf (state->active_channel[1], "%s", "");
+            opts->p25_is_tuned = 0;
+            state->p25_vc_freq[0] = state->p25_vc_freq[1] = 0;
+            if (opts->setmod_bw != 0 ) SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
+            SetFreq(opts->rigctl_sockfd, state->p25_cc_freq);        
+          }
+          //rtl
+          else if (opts->audio_in_type == 3)
+          {
+            #ifdef USE_RTLSDR
+            state->lasttg = 0;
+            state->lastsrc = 0;
+            state->payload_algid = 0;
+            state->payload_keyid = 0;
+            // state->payload_miP = 0;
+            //reset some strings
+            sprintf (state->call_string[0], "%s", "                     "); //21 spaces
+            sprintf (state->call_string[1], "%s", "                     "); //21 spaces
+            sprintf (state->active_channel[0], "%s", "");
+            sprintf (state->active_channel[1], "%s", "");
+            opts->p25_is_tuned = 0;
+            state->p25_vc_freq[0] = state->p25_vc_freq[1] = 0;
+            rtl_dev_tune (opts, state->p25_cc_freq);
+            #endif
+          }
+        }
+      }
+
+      else fprintf (stderr, " Unknown Format %02X MFID %02X SVC %02X", lc_format, lc_mfid, lc_svcopt);
     }
 
-  else if (strcmp (lcformat, "00000000") == 0)
-    {
-      j = 0;
-      if (strcmp (mfid, "10010000") == 0)
-        {
-          for (i = 20; i < 32; i++)
-            {
-              if (state->tgcount < 24)
-                {
-                  state->tg[state->tgcount][j] = lcinfo[i];
-                }
-              tmpstr[j] = lcinfo[i];
-              j++;
-            }
-          tmpstr[12] = 48;
-          tmpstr[13] = 48;
-          tmpstr[14] = 48;
-          tmpstr[15] = 48;
-        }
-      else
-        {
-          for (i = 16; i < 32; i++)
-            {
-              if (state->tgcount < 24)
-                {
-                  state->tg[state->tgcount][j] = lcinfo[i];
-                }
-              tmpstr[j] = lcinfo[i];
-              j++;
-            }
-        }
-      tmpstr[16] = 0;
-      talkgroup = strtol (tmpstr, NULL, 2);
-      state->lasttg = talkgroup;
-      if (state->tgcount < 24)
-        {
-          state->tgcount = state->tgcount + 1;
-        }
-      if (opts->p25tg == 1)
-        {
-          fprintf (stderr, "tg: %li ", talkgroup);
-        }
+    //not a duplicate, this one will print if not MFID 0 or 1
+    else fprintf (stderr, " Unknown Format %02X MFID %02X ", lc_format, lc_mfid);
+  }
+
+  //ending line break
+  fprintf (stderr, "\n");
 
-      j = 0;
-      for (i = 32; i < 56; i++)
-        {
-          tmpstr[j] = lcinfo[i];
-          j++;
-        }
-      tmpstr[24] = 0;
-      source = strtol (tmpstr, NULL, 2);
-      state->lastsrc = source;
-      if (opts->p25tg == 1)
-        {
-          fprintf (stderr, "src: %li emr: %c\n", source, lcinfo[0]);
-        }
-    }
-  else if ((opts->p25tg == 1) && (opts->p25lc == 1))
-    {
-      fprintf (stderr, "\n");
-    }
 }
+

src/p25p1_block.cpp

@@ -40,7 +40,8 @@ static int find_min(uint8_t list[], int len) {
                     index = i;
                     unique = 1;
                 } else if (list[i] == min) {
-                    unique = 0;
+                    //unique = 0;
+                    ; //do nothing, still can be correct and pass CRC
                 }
             }
             /* return -1 if a minimum can't be found */

src/p25p1_hdu.c

@@ -453,93 +453,48 @@ processHDU(dsd_opts* opts, dsd_state* state)
   status = getDibit (opts, state);
   //TODO: Do something useful with the status bits...
 
-  //if (state->carrier == 1 && state->errs == 0) //only update when carrier is present, and no errors??
-  if (state->carrier == 1)
-  {
-    algidhex = strtol (algid, NULL, 2);
-    kidhex = strtol (kid, NULL, 2);
+  algidhex = strtol (algid, NULL, 2);
+  kidhex = strtol (kid, NULL, 2);
+  mihex1 = (unsigned long long int)ConvertBitIntoBytes(&mi[0], 32);
+  mihex2 = (unsigned long long int)ConvertBitIntoBytes(&mi[32], 32);
+  mihex3 = (unsigned long long int)ConvertBitIntoBytes(&mi[64], 8);
 
-    state->payload_algid = algidhex;
-    state->payload_keyid = kidhex;
-    //state->payload_mfid = ConvertBitIntoBytes(&mfid[0], 7);
-    //state->payload_mfid = strtol (mfid, NULL, 2);
-
-    mihex1 = (unsigned long long int)ConvertBitIntoBytes(&mi[0], 32);
-    mihex2 = (unsigned long long int)ConvertBitIntoBytes(&mi[32], 32);
-    mihex3 = (unsigned long long int)ConvertBitIntoBytes(&mi[64], 8);
-    //only use 64 MSB, trailing 8 bits aren't used, so no mihex3
-    state->payload_miP = (mihex1 << 32) | (mihex2);
-  }
+  //reset dropbytes - skip first 11 for LCW
+  state->dropL = 267; 
 
   //set vc counter to 0
   state->p25vc = 0;
 
-  if (state->payload_algid != 0x80 && state->payload_algid != 0x0) //print on payload == 1
+  if (irrecoverable_errors == 0)
   {
+
     fprintf (stderr, "%s", KYEL);
-    fprintf (stderr, " HDU  ALG ID: 0x%02X KEY ID: 0x%02X MI: 0x%08llX%08llX%02llX MFID: 0x%02X", algidhex, kidhex, mihex1, mihex2, mihex3, state->payload_mfid);
+    fprintf (stderr, " HDU  ALG ID: 0x%02X KEY ID: 0x%04X MI: 0x%08llX%08llX%02llX", algidhex, kidhex, mihex1, mihex2, mihex3);
+    state->payload_algid = algidhex;
+    state->payload_keyid = kidhex;
+    if (state->R != 0 && state->payload_algid == 0xAA)
+    {
+      fprintf (stderr, " Key: %010llX", state->R);
+      opts->unmute_encrypted_p25 = 1;
+    }
     fprintf (stderr, "%s", KNRM);
+    //only use 64 MSB, trailing 8 bits aren't used, so no mihex3
+    state->payload_miP = (mihex1 << 32) | (mihex2);
+
+    if (state->payload_algid != 0x80 && state->payload_algid != 0x0)
+    {
+      fprintf (stderr, "%s", KRED);
+      fprintf (stderr, " ENC");
+      fprintf (stderr, "%s", KNRM);
+    }
+
+    fprintf (stderr, "\n");
   }
-
-  if (state->payload_algid != 0x80 && state->payload_algid != 0x0) //print on payload == 1
-  {
-    fprintf (stderr, "%s", KRED);
-    fprintf (stderr, " ENC \n");
-    fprintf (stderr, "%s", KNRM);
-  }
-
-  if (opts->p25enc == 1 && opts->payload == 0)
-    {
-      algidhex = strtol (algid, NULL, 2);
-      kidhex = strtol (kid, NULL, 2);
-    }
-  if (opts->p25lc == 1)
-    {
-      fprintf (stderr, "mfid: %s tgid: %s ", mfid, tgid);
-      if (opts->p25tg == 0)
-        {
-          fprintf (stderr, "\n");
-        }
-    }
-
-  j = 0;
-  if (strcmp (mfid, "10010000") == 0)
-    {
-      for (i = 4; i < 16; i++)
-        {
-          if (state->tgcount < 24)
-            {
-              state->tg[state->tgcount][j] = tgid[i];
-            }
-          tmpstr[j] = tgid[i];
-          j++;
-        }
-      tmpstr[12] = '0';
-      tmpstr[13] = '0';
-      tmpstr[14] = '0';
-      tmpstr[15] = '0';
-    }
   else
-    {
-      for (i = 0; i < 16; i++)
-        {
-          if (state->tgcount < 24)
-            {
-              state->tg[state->tgcount][j] = tgid[i];
-            }
-          tmpstr[j] = tgid[i];
-          j++;
-        }
-    }
-  tmpstr[16] = 0;
-  talkgroup = strtol (tmpstr, NULL, 2);
-  state->lasttg = talkgroup;
-  if (state->tgcount < 24)
-    {
-      state->tgcount = state->tgcount + 1;
-    }
-  if (opts->p25tg == 1)
-    {
-      fprintf (stderr, "tg: %li\n", talkgroup);
-    }
+  {
+      fprintf (stderr, "%s", KRED);
+      fprintf (stderr, " HDU FEC ERR \n");
+      fprintf (stderr, "%s", KNRM);
+  }
+  
 }

src/p25p1_ldu1.c

@@ -171,6 +171,8 @@ processLDU1 (dsd_opts* opts, dsd_state* state)
 
     // TODO: error correction of the LSD bytes...
     // TODO: do something useful with the LSD bytes...
+
+    state->dropL += 2; //need to skip 2 here for the LSD bytes
   }
 
   // IMBE 9
@@ -324,15 +326,53 @@ processLDU1 (dsd_opts* opts, dsd_state* state)
   lcinfo[54]  = hex_data[ 0][4] + '0';
   lcinfo[55]  = hex_data[ 0][5] + '0';
 
-  unsigned long long int lcinfohex = 0;
-  if (state->carrier == 1 && state->errs == 0) //only update when carrier is present, otherwise, garbage values may be collected
-  {
-    state->payload_mfid = strtol (mfid, NULL, 2);
+  int j;
+  uint8_t LCW_bytes[9];
+  uint8_t LCW_bits[72];
+  memset (LCW_bytes, 0, sizeof(LCW_bytes));
+  memset (LCW_bits, 0, sizeof(LCW_bits));
 
-    //state->payload_mfid = ConvertBitIntoBytes(&mfid[0], 7);
-    lcinfohex = ConvertBitIntoBytes(&lcinfo[0], 55);
-    //fprintf (stderr, " LDU1 LCINFO %16llX \n", lcinfohex);
+  //load array above into byte form first
+  LCW_bytes[0] = (uint8_t) ConvertBitIntoBytes(&lcformat[0], 8);
+  LCW_bytes[1] = (uint8_t) ConvertBitIntoBytes(&mfid[0], 8);
+  for (i = 0; i < 7; i++) LCW_bytes[i+2] = (uint8_t) ConvertBitIntoBytes(&lcinfo[i*8], 8);
+
+  //load as bit array next (easier to process data in bit form)
+  for(i = 0, j = 0; i < 9; i++, j+=8)
+  {
+    LCW_bits[j + 0] = (LCW_bytes[i] >> 7) & 0x01;
+    LCW_bits[j + 1] = (LCW_bytes[i] >> 6) & 0x01;
+    LCW_bits[j + 2] = (LCW_bytes[i] >> 5) & 0x01;
+    LCW_bits[j + 3] = (LCW_bytes[i] >> 4) & 0x01;
+    LCW_bits[j + 4] = (LCW_bytes[i] >> 3) & 0x01;
+    LCW_bits[j + 5] = (LCW_bytes[i] >> 2) & 0x01;
+    LCW_bits[j + 6] = (LCW_bytes[i] >> 1) & 0x01;
+    LCW_bits[j + 7] = (LCW_bytes[i] >> 0) & 0x01;
+  }
+ 
+  //send to new P25 LCW function
+  if (irrecoverable_errors == 0)
+  {
+    fprintf (stderr, "%s", KYEL);
+    p25_lcw (opts, state, LCW_bits, 0);
+    fprintf (stderr, "%s", KNRM);
+  }
+  else
+  {
+    fprintf (stderr, "%s",KRED);
+    fprintf (stderr, " LCW FEC ERR ");
+    fprintf (stderr, "%s\n", KNRM);
   }
 
-  processP25lcw (opts, state, lcformat, mfid, lcinfo);
+  if (opts->payload == 1)
+  {
+    fprintf (stderr, "%s",KCYN);
+    fprintf (stderr, " P25 LCW Payload ");
+    for (i = 0; i < 9; i++)
+    {
+      fprintf (stderr, "[%02X]", LCW_bytes[i]);
+    }
+    
+    fprintf (stderr, "%s\n", KNRM);
+  }
 }

src/p25p1_ldu2.c

@@ -172,6 +172,8 @@ processLDU2 (dsd_opts * opts, dsd_state * state)
 
     // TODO: error correction of the LSD bytes...
     // TODO: do something useful with the LSD bytes...
+
+    state->dropL += 2; //need to skip 2 here for the LSD bytes
   }
 
   // IMBE 9
@@ -183,6 +185,9 @@ processLDU2 (dsd_opts * opts, dsd_state * state)
   //set vc counter to 0
   state->p25vc = 0;
 
+  //reset dropbytes -- skip first 11 for next LCW
+  state->dropL = 267;
+
   if (opts->errorbars == 1)
     {
       fprintf (stderr, "\n");
@@ -357,37 +362,82 @@ processLDU2 (dsd_opts * opts, dsd_state * state)
   kid[14]  = hex_data[ 0][4] + '0';
   kid[15]  = hex_data[ 0][5] + '0';
 
+  algidhex = strtol (algid, NULL, 2);
+  kidhex = strtol (kid, NULL, 2);
+  mihex1 = (unsigned long long int)ConvertBitIntoBytes(&mi[0], 32);
+  mihex2 = (unsigned long long int)ConvertBitIntoBytes(&mi[32], 32);
+  mihex3 = (unsigned long long int)ConvertBitIntoBytes(&mi[64], 8);
 
-  //if (state->carrier == 1 && state->errs == 0) //only update when carrier is present, and no errors??
-  if (state->carrier == 1)
+  if (irrecoverable_errors == 0)
   {
-
-    algidhex = strtol (algid, NULL, 2);
-    kidhex = strtol (kid, NULL, 2);
-
+    fprintf (stderr, "%s", KYEL);
+    fprintf (stderr, " LDU2 ALG ID: 0x%02X KEY ID: 0x%04X MI: 0x%08llX%08llX%02llX", algidhex, kidhex, mihex1, mihex2, mihex3);
     state->payload_algid = algidhex;
     state->payload_keyid = kidhex;
-
-    mihex1 = (unsigned long long int)ConvertBitIntoBytes(&mi[0], 32);
-    mihex2 = (unsigned long long int)ConvertBitIntoBytes(&mi[32], 32);
-    mihex3 = (unsigned long long int)ConvertBitIntoBytes(&mi[64], 8);
+    if (state->R != 0 && state->payload_algid == 0xAA)
+    {
+      fprintf (stderr, " Key: %010llX", state->R);
+      opts->unmute_encrypted_p25 = 1;
+    }
+    fprintf (stderr, "%s", KNRM);
     //only use 64 MSB, trailing 8 bits aren't used, so no mihex3
     state->payload_miP = (mihex1 << 32) | (mihex2);
 
+    if (state->payload_algid != 0x80 && state->payload_algid != 0x0)
+    {
+      fprintf (stderr, "%s", KRED);
+      fprintf (stderr, " ENC");
+      fprintf (stderr, "%s", KNRM);
+    }
+
+    fprintf (stderr, "\n");
+  }
+  else
+  {
+      fprintf (stderr, "%s", KRED);
+      fprintf (stderr, " LDU2 FEC ERR \n");
+      fprintf (stderr, "%s", KNRM);
   }
 
-  if (state->payload_algid != 0x80 && state->payload_algid != 0x0) //print on payload == 1
+  //run LFSR on the MI if we have irrecoverable errors here
+  if (irrecoverable_errors && state->payload_algid != 0x80 && state->payload_keyid != 0 && state->payload_miP != 0) 
   {
-    fprintf (stderr, "%s", KYEL);
-    fprintf (stderr, " LDU2 ALG ID: 0x%02X KEY ID: 0x%02X MI: 0x%08llX%08llX%02llX", algidhex, kidhex, mihex1, mihex2, mihex3);
-    fprintf (stderr, "%s", KNRM);
-  }
-
-  if (state->payload_algid != 0x80 && state->payload_algid != 0x0) //print on payload == 1
-  {
-    fprintf (stderr, "%s", KRED);
-    fprintf (stderr, " ENC \n");
-    fprintf (stderr, "%s", KNRM);
+    LFSRP(state);
+    fprintf (stderr, "\n");
   }
 
 }
+
+//LFSR code courtesy of https://github.com/mattames/LFSR/
+void LFSRP(dsd_state * state)
+{
+  //rework for P2 TDMA support
+  unsigned long long int lfsr = 0;
+  if (state->currentslot == 0)
+    lfsr = state->payload_miP;
+
+  if (state->currentslot == 1)
+    lfsr = state->payload_miN;
+
+  int cnt = 0;
+  for(cnt=0;cnt<64;cnt++)
+  {
+	  // Polynomial is C(x) = x^64 + x^62 + x^46 + x^38 + x^27 + x^15 + 1
+    unsigned long long int bit  = ((lfsr >> 63) ^ (lfsr >> 61) ^ (lfsr >> 45) ^ (lfsr >> 37) ^ (lfsr >> 26) ^ (lfsr >> 14)) & 0x1;
+    lfsr =  (lfsr << 1) | (bit);
+  }
+
+  if (state->currentslot == 0)
+    state->payload_miP = lfsr;
+
+  if (state->currentslot == 1)
+    state->payload_miN = lfsr;
+
+  //print current ENC identifiers already known and new calculated MI
+  fprintf (stderr, "%s", KYEL);
+  if (state->currentslot == 0)
+    fprintf (stderr, " LDU2/ESS_B FEC ERR - ALG: 0x%02X KEY ID: 0x%04X LFSR MI: 0x%016llX", state->payload_algid, state->payload_keyid, state->payload_miP);
+  if (state->currentslot == 1)
+    fprintf (stderr, " LDU2/ESS_B FEC ERR - ALG: 0x%02X KEY ID: 0x%04X LFSR MI: 0x%016llX", state->payload_algidR, state->payload_keyidR, state->payload_miN);
+  fprintf (stderr, "%s", KNRM);
+}

src/p25p1_mdpu.c

@@ -0,0 +1,531 @@
+/*-------------------------------------------------------------------------------
+ * p25p1_mpdu.c
+ * P25p1 Multi Block PDU and Multi Block Trunking
+ *
+ * LWVMOBILE
+ * 2023-03 DSD-FME Florida Man Edition
+ *-----------------------------------------------------------------------------*/
+
+#include "dsd.h"
+
+static uint32_t crc32mbf(uint8_t buf[], int len)
+{	
+  uint32_t g = 0x04c11db7;
+  uint64_t crc = 0;
+  for (int i = 0; i < len; i++)
+  {
+    crc <<= 1;
+    int b = ( buf [i / 8] >> (7 - (i % 8)) ) & 1;
+    if (((crc >> 32) ^ b) & 1) crc ^= g;
+  }
+  crc = (crc & 0xffffffff) ^ 0xffffffff;
+  return crc;
+}
+
+void processMPDU(dsd_opts * opts, dsd_state * state)
+{
+
+  //reset some strings when returning from a call in case they didn't get zipped already
+  sprintf (state->call_string[0], "%s", "                     "); //21 spaces
+  sprintf (state->call_string[1], "%s", "                     "); //21 spaces
+
+  //clear stale Active Channel messages here
+  if ( (time(NULL) - state->last_active_time) > 3 )
+  {
+    memset (state->active_channel, 0, sizeof(state->active_channel));
+  }
+  
+  int tsbkbit[196]; //tsbk bit array, 196 trellis encoded bits
+  int tsbk_dibit[98];
+
+  memset (tsbkbit, 0, sizeof(tsbkbit));
+  memset (tsbk_dibit, 0, sizeof(tsbk_dibit));
+
+  int dibit = 0;
+
+  uint8_t tsbk_byte[12]; //12 byte return from bd_bridge (block_deinterleave)
+  memset (tsbk_byte, 0, sizeof(tsbk_byte));
+
+  unsigned long long int PDU[24];
+  memset (PDU, 0, sizeof(PDU));
+
+  int tsbk_decoded_bits[190]; //decoded bits from tsbk_bytes for sending to crc16_lb_bridge
+  memset (tsbk_decoded_bits, 0, sizeof(tsbk_decoded_bits));
+
+  uint8_t mpdu_decoded_bits[288];
+  memset (mpdu_decoded_bits, 0, sizeof(mpdu_decoded_bits));
+
+  uint8_t mpdu_crc_bits[196]; 
+  memset (mpdu_crc_bits, 0, sizeof(mpdu_crc_bits));
+
+  uint8_t mpdu_crc_bytes[24];
+  memset (mpdu_crc_bytes, 0, sizeof(mpdu_crc_bytes));
+
+  int flushing_bits[196]; //for flushing the trellis state machine
+  memset (flushing_bits, 0, sizeof(flushing_bits));
+
+  int i, j, k, b, x, y;
+  int ec[3]; //error value returned from (block_deinterleave)
+  int err[2]; //error value returned from ccrc16 or crc32
+  memset (ec, -2, sizeof(ec));
+  memset (err, -2, sizeof(err));
+
+  int skipdibit = 14; //initial status dibit will occur at 14, then add 36 each time it occurs
+  int protectbit = 0;
+  int MFID = 0xFF; //Manufacturer ID
+
+  uint8_t mpdu_byte[36];
+  memset (mpdu_byte, 0, sizeof(mpdu_byte));
+
+  uint8_t io = 0; 
+  uint8_t fmt = 0;  
+  uint8_t sap = 0; 
+  uint8_t blks = 0; 
+  uint8_t opcode = 0;
+
+  //CRC32
+  uint32_t CRCComputed = 0;
+  uint32_t CRCExtracted = 0;
+
+  //collect three reps of 101 dibits (98 valid dibits with status dibits interlaced)
+  for (j = 0; j < 3; j++)
+  {
+    k = 0;
+    for (i = 0; i < 101; i++)
+    {
+
+      dibit = getDibit(opts, state);
+
+      if (i+(j*101) != skipdibit) //
+      {
+        tsbk_dibit[k] =   dibit;
+        tsbkbit[k*2]   = (dibit >> 1) & 1;
+        tsbkbit[k*2+1] = (dibit & 1);
+        k++;
+      }
+
+      if (i+(j*101) == skipdibit) 
+      {
+        skipdibit += 36; //was set to 35, this was the bug
+      }
+
+    }
+
+    //flushing the trellis state machine
+    if (j == 0)
+    {
+      bd_bridge(flushing_bits, tsbk_byte);
+      //reset tsbk_byte afterwards
+      memset (tsbk_byte, 0, sizeof(tsbk_byte));
+    } 
+
+    //send tsbkbit to block_deinterleave and return tsbk_byte
+    ec[j] = bd_bridge(tsbkbit, tsbk_byte);
+
+    //too many bit manipulations!
+    k = 0;
+    for (i = 0; i < 12; i++)
+    {
+      for (x = 0; x < 8; x++)
+      {
+        tsbk_decoded_bits[k] = ((tsbk_byte[i] << x) & 0x80) >> 7;
+        k++;
+      }
+    }
+
+    //CRC16 on the header
+    if (j == 0) err[0] = crc16_lb_bridge(tsbk_decoded_bits, 80);
+
+    //load into bit array for storage (easier decoding for future PDUs)
+    for (i = 0; i < 96; i++) mpdu_decoded_bits[i+(j*96)] = (uint8_t)tsbk_decoded_bits[i];
+
+    //shuffle corrected bits back into tsbk_byte
+    k = 0;
+    for (i = 0; i < 12; i++)
+    {
+      int byte = 0;
+      for (x = 0; x < 8; x++)
+      {
+        byte = byte << 1;
+        byte = byte | tsbk_decoded_bits[k];
+        k++;
+      }
+      tsbk_byte[i] = byte;
+      mpdu_byte[i+(j*12)] = byte; //add to completed MBF format bytes
+    }
+    
+  }
+
+  io   = (mpdu_byte[0] >> 5) & 0x1;
+  fmt  = mpdu_byte[0] & 0x1F;
+  sap  = mpdu_byte[1] & 0x3F;
+  blks = mpdu_byte[6] & 0x7F;
+  MFID = mpdu_byte[2];
+
+  //group list mode so we can look and see if we need to block tuning any groups, etc
+	char mode[8]; //allow, block, digital, enc, etc
+
+	//if we are using allow/whitelist mode, then write 'B' to mode for block
+	//comparison below will look for an 'A' to write to mode if it is allowed
+	if (opts->trunk_use_allow_list == 1) sprintf (mode, "%s", "B");
+
+  fprintf (stderr, "%s",KGRN);
+  fprintf (stderr, " P25 MBF FMT: %02X SAP: %02X", fmt, sap);
+  fprintf (stderr, " Blocks: %02X MFID: %02X", blks, MFID);
+
+  //trunking blocks
+  if ((sap == 0x3D) && ((fmt == 0x17) || (fmt == 0x15)))
+  {
+    if (fmt == 0x15) fprintf (stderr, " UNC");
+    else fprintf (stderr, " ALT");
+    fprintf (stderr, " MBT"); //find way to convert to vPDU or TSBK format?
+    if (fmt == 0x17) opcode = mpdu_byte[7] & 0x3F; //alt MBT
+    else opcode = mpdu_byte[12] & 0x3F; //unconf MBT
+    fprintf (stderr, " - OP: %02X", opcode);
+  }
+
+  //CRC32 is now working! 
+  for (i = 0; i < 196; i++) mpdu_crc_bits[i] = mpdu_decoded_bits[i+96];
+  for (i = 0; i < 24; i++) mpdu_crc_bytes[i] = mpdu_byte[i+12];
+  if (blks == 1) //blocks to follow is 1
+  {
+    CRCExtracted = (uint32_t)ConvertBitIntoBytes(&mpdu_crc_bits[96-32], 32);
+    CRCComputed  = crc32mbf(mpdu_crc_bytes, 96-32);
+    if (CRCComputed == CRCExtracted) err[1] = 0;
+  }
+  if (blks == 2) //blocks to follow is 2
+  {
+    CRCExtracted = (uint32_t)ConvertBitIntoBytes(&mpdu_crc_bits[192-32], 32);
+    CRCComputed  = crc32mbf(mpdu_crc_bytes, 192-32);
+    if (CRCComputed == CRCExtracted) err[1] = 0;
+  }
+
+  //just going to do a couple for now -- the extended format will not be vPDU compatible :(
+  if (err[0] == 0 && err[1] == 0 && io == 1 && fmt == 0x17) //ALT Format
+  {    
+    //NET_STS_BCST -- TIA-102.AABC-D 6.2.11.2
+    if (opcode == 0x3B)
+    {
+      int lra = mpdu_byte[3];
+      int sysid = ((mpdu_byte[4] & 0xF) << 8) | mpdu_byte[5];
+      int res_a = mpdu_byte[8];
+      int res_b = mpdu_byte[9];
+      long int wacn = (mpdu_byte[12] << 12) | (mpdu_byte[13] << 4) | (mpdu_byte[14] >> 4);
+      int channelt = (mpdu_byte[15] << 8) | mpdu_byte[16];
+      int channelr = (mpdu_byte[17] << 8) | mpdu_byte[18];
+      int ssc =  mpdu_byte[19];
+      fprintf (stderr, "%s",KYEL);
+      fprintf (stderr, "\n Network Status Broadcast MBT - Extended \n");
+      fprintf (stderr, "  LRA [%02X] WACN [%05lX] SYSID [%03X] NAC [%03llX]\n", lra, wacn, sysid, state->p2_cc);
+      fprintf (stderr, "  CHAN-T [%04X] CHAN-R [%04X]", channelt, channelr);
+      long int ct_freq = process_channel_to_freq(opts, state, channelt);
+      long int cr_freq = process_channel_to_freq(opts, state, channelr);
+      
+      state->p25_cc_freq = ct_freq;
+      state->p25_cc_is_tdma = 0; //flag off for CC tuning purposes when system is qpsk
+
+      //place the cc freq into the list at index 0 if 0 is empty, or not the same, 
+      //so we can hunt for rotating CCs without user LCN list
+      if (state->trunk_lcn_freq[0] == 0 || state->trunk_lcn_freq[0] != state->p25_cc_freq)
+      {
+        state->trunk_lcn_freq[0] = state->p25_cc_freq; 
+      } 
+
+      //only set IF these values aren't already hard set by the user
+      if (state->p2_hardset == 0)
+      {
+        state->p2_wacn = wacn;
+        state->p2_sysid = sysid;
+      } 
+    }
+    //RFSS Status Broadcast - Extended 6.2.15.2
+		else if (opcode == 0x3A) 
+		{
+			int lra = mpdu_byte[3];
+			int lsysid = ((mpdu_byte[4] & 0xF) << 8) | mpdu_byte[5];
+			int rfssid = mpdu_byte[12];
+			int siteid = mpdu_byte[13];
+			int channelt = (mpdu_byte[14] << 8) | mpdu_byte[15];
+      int channelr = (mpdu_byte[16] << 8) | mpdu_byte[17];
+			int sysclass = mpdu_byte[18];
+      fprintf (stderr, "%s",KYEL);
+			fprintf (stderr, "\n RFSS Status Broadcast MBF - Extended \n");
+			fprintf (stderr, "  LRA [%02X] SYSID [%03X] RFSS ID [%02X] SITE ID [%02X]\n  CHAN-T [%04X] CHAN-R [%02X] SSC [%02X] ", lra, lsysid, rfssid, siteid, channelt, channelr, sysclass);
+			process_channel_to_freq (opts, state, channelt);
+			process_channel_to_freq (opts, state, channelr);
+
+			state->p2_siteid = siteid;
+			state->p2_rfssid = rfssid;
+		}
+
+    //Adjacent Status Broadcast (ADJ_STS_BCST) Extended 6.2.2.2
+    else if (opcode == 0x3C) 
+    {
+      int lra = mpdu_byte[3];
+      int cfva = mpdu_byte[4] >> 4;
+			int lsysid = ((mpdu_byte[4] & 0xF) << 8) | mpdu_byte[5];
+			int rfssid = mpdu_byte[8];
+			int siteid = mpdu_byte[9];
+			int channelt = (mpdu_byte[12] << 8) | mpdu_byte[13];
+			int channelr = (mpdu_byte[14] << 8) | mpdu_byte[15];
+			int sysclass = mpdu_byte[16];  
+      long int wacn = (mpdu_byte[17] << 12) | (mpdu_byte[18] << 4) | (mpdu_byte[19] >> 4);
+      fprintf (stderr, "%s",KYEL);
+      fprintf (stderr, "\n Adjacent Status Broadcast - Extended\n");
+      fprintf (stderr, "  LRA [%02X] CFVA [%X] RFSS[%03d] SYSID [%03X] SITE [%03X]\n  CHAN-T [%04X] CHAN-R [%04X] SSC [%02X] WACN [%05lX]\n  ", lra, cfva, rfssid, lsysid, siteid, channelt, channelr, sysclass, wacn);
+      if (cfva & 0x8) fprintf (stderr, " Conventional");
+      if (cfva & 0x4) fprintf (stderr, " Failure Condition");
+      if (cfva & 0x2) fprintf (stderr, " Up to Date (Correct)");
+      else fprintf (stderr, " Last Known");
+      if (cfva & 0x1) fprintf (stderr, " Valid RFSS Connection Active");
+      process_channel_to_freq (opts, state, channelt);
+      process_channel_to_freq (opts, state, channelr);
+
+    }
+
+    //Group Voice Channel Grant - Extended 
+    else if (opcode == 0x0) 
+    {
+      int svc = mpdu_byte[8];
+			int channelt  = (mpdu_byte[14] << 8) | mpdu_byte[15];
+			int channelr  = (mpdu_byte[16] << 8) | mpdu_byte[17];
+      long int source = (mpdu_byte[3] << 16) |(mpdu_byte[4] << 8) | mpdu_byte[5];
+			int group = (mpdu_byte[18] << 8) | mpdu_byte[19];
+			long int freq1 = 0;
+			long int freq2 = 0;
+      fprintf (stderr, "%s\n ",KYEL);
+      if (svc & 0x80) fprintf (stderr, " Emergency");
+      if (svc & 0x40) fprintf (stderr, " Encrypted");
+
+      if (opts->payload == 1) //hide behind payload due to len
+      {
+        if (svc & 0x20) fprintf (stderr, " Duplex");
+        if (svc & 0x10) fprintf (stderr, " Packet");
+        else fprintf (stderr, " Circuit");
+        if (svc & 0x8) fprintf (stderr, " R"); //reserved bit is on
+        fprintf (stderr, " Priority %d", svc & 0x7); //call priority
+      }
+			fprintf (stderr, " Group Voice Channel Grant Update - Extended");
+			fprintf (stderr, "\n  SVC [%02X] CHAN-T [%04X] CHAN-R [%04X] Group [%d][%04X]", svc, channelt, channelr, group, group);
+			freq1 = process_channel_to_freq (opts, state, channelt);
+			freq2 = process_channel_to_freq (opts, state, channelr);
+
+      //add active channel to string for ncurses display
+			sprintf (state->active_channel[0], "Active Ch: %04X TG: %d ", channelt, group);
+      state->last_active_time = time(NULL);
+
+      for (int i = 0; i < state->group_tally; i++)
+      {
+        if (state->group_array[i].groupNumber == group)
+        {
+          fprintf (stderr, " [%s]", state->group_array[i].groupName);
+          strcpy (mode, state->group_array[i].groupMode);
+        }
+      }
+
+      
+			//Skip tuning group calls if group calls are disabled
+			if (opts->trunk_tune_group_calls == 0) goto SKIPCALL;
+
+      //Skip tuning encrypted calls if enc calls are disabled
+      if ( (svc & 0x40) && opts->trunk_tune_enc_calls == 0) goto SKIPCALL;
+
+			//tune if tuning available
+			if (opts->p25_trunk == 1 && (strcmp(mode, "DE") != 0) && (strcmp(mode, "B") != 0))
+  		{
+				//reworked to set freq once on any call to process_channel_to_freq, and tune on that, independent of slot
+    		if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && freq1 != 0) //if we aren't already on a VC and have a valid frequency
+    		{
+					//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
+					// if (opts->mod_qpsk == 1)
+					// {
+					// 	int spacing = state->p25_chan_spac[channelt >> 12];
+					// 	if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+					// 	{
+					// 		state->samplesPerSymbol = 8;
+					// 		state->symbolCenter = 3;
+					// 	}	
+					// }
+
+          //changed to allow symbol rate change on C4FM Phase 2 systems as well as QPSK
+					if (1 == 1)
+					{
+						if (state->p25_chan_tdma[channelt >> 12] == 1)
+						{
+							state->samplesPerSymbol = 8;
+							state->symbolCenter = 3;
+						}
+					}
+					//rigctl
+          if (opts->use_rigctl == 1)
+					{
+						if (opts->setmod_bw != 0 ) SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
+      			SetFreq(opts->rigctl_sockfd, freq1);
+						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq1;
+						opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop 
+            state->last_vc_sync_time = time(NULL);
+					}
+					//rtl
+					else if (opts->audio_in_type == 3)
+					{
+            #ifdef USE_RTLSDR
+						rtl_dev_tune (opts, freq1);
+						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq1;
+						opts->p25_is_tuned = 1;
+            state->last_vc_sync_time = time(NULL);
+            #endif
+					}
+    		}    
+  		}
+    }
+
+    //Unit to Unit Voice Channel Grant - Extended
+    else if (opcode == 0x6) 
+    {
+      //I'm not doing EVERY element of this, just enough for tuning!
+      int svc = mpdu_byte[8];
+			int channelt  = (mpdu_byte[22] << 8) | mpdu_byte[23];
+			int channelr  = (mpdu_byte[24] << 8) | mpdu_byte[25]; //optional!
+      //using source and target address, not source and target id (is this correct?)
+      long int source = (mpdu_byte[3] << 16) |(mpdu_byte[4] << 8) | mpdu_byte[5];
+			long int target = (mpdu_byte[19] << 16) |(mpdu_byte[20] << 8) | mpdu_byte[21];
+			long int freq1 = 0;
+			long int freq2 = 0;
+      fprintf (stderr, "%s\n ",KYEL);
+      if (svc & 0x80) fprintf (stderr, " Emergency");
+      if (svc & 0x40) fprintf (stderr, " Encrypted");
+
+      if (opts->payload == 1) //hide behind payload due to len
+      {
+        if (svc & 0x20) fprintf (stderr, " Duplex");
+        if (svc & 0x10) fprintf (stderr, " Packet");
+        else fprintf (stderr, " Circuit");
+        if (svc & 0x8) fprintf (stderr, " R"); //reserved bit is on
+        fprintf (stderr, " Priority %d", svc & 0x7); //call priority
+      }
+			fprintf (stderr, " Unit to Unit Voice Channel Grant Update - Extended");
+			fprintf (stderr, "\n  SVC [%02X] CHAN-T [%04X] CHAN-R [%04X] Source [%ld][%04lX] Target [%ld][%04lX]", svc, channelt, channelr, source, source, target, target);
+			freq1 = process_channel_to_freq (opts, state, channelt);
+			freq2 = process_channel_to_freq (opts, state, channelr); //optional!
+
+      //add active channel to string for ncurses display
+			sprintf (state->active_channel[0], "Active Ch: %04X TGT: %ld; ", channelt, target);
+
+      for (int i = 0; i < state->group_tally; i++)
+      {
+        if (state->group_array[i].groupNumber == target)
+        {
+          fprintf (stderr, " [%s]", state->group_array[i].groupName);
+          strcpy (mode, state->group_array[i].groupMode);
+        }
+      }
+
+      
+			//Skip tuning private calls if group calls are disabled
+			if (opts->trunk_tune_private_calls == 0) goto SKIPCALL;
+
+      //Skip tuning encrypted calls if enc calls are disabled
+      if ( (svc & 0x40) && opts->trunk_tune_enc_calls == 0) goto SKIPCALL;
+
+			//tune if tuning available
+			if (opts->p25_trunk == 1 && (strcmp(mode, "DE") != 0) && (strcmp(mode, "B") != 0))
+  		{
+				//reworked to set freq once on any call to process_channel_to_freq, and tune on that, independent of slot
+    		if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && freq1 != 0) //if we aren't already on a VC and have a valid frequency
+    		{
+
+					//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
+					// if (opts->mod_qpsk == 1)
+					// {
+					// 	int spacing = state->p25_chan_spac[channelt >> 12];
+					// 	if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+					// 	{
+					// 		state->samplesPerSymbol = 8;
+					// 		state->symbolCenter = 3;
+					// 	}	
+					// }
+
+          //changed to allow symbol rate change on C4FM Phase 2 systems as well as QPSK
+					if (1 == 1)
+					{
+						if (state->p25_chan_tdma[channelt >> 12] == 1)
+						{
+							state->samplesPerSymbol = 8;
+							state->symbolCenter = 3;
+						}
+					}
+					//rigctl
+          if (opts->use_rigctl == 1)
+					{
+						if (opts->setmod_bw != 0 ) SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
+      			SetFreq(opts->rigctl_sockfd, freq1);
+						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq1;
+						opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop
+            state->last_vc_sync_time = time(NULL);
+					}
+					//rtl
+					else if (opts->audio_in_type == 3)
+					{
+            #ifdef USE_RTLSDR
+						rtl_dev_tune (opts, freq1);
+						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq1;
+						opts->p25_is_tuned = 1;
+            state->last_vc_sync_time = time(NULL);
+            #endif
+					}
+    		}    
+  		}
+    }
+
+    else
+    {
+      //convert mpdu_byte to vPDU format and get indication of what the message was
+      PDU[0] = 0x0C; //P25p1 MB Duid 0x0C
+      PDU[1] = opcode;
+      PDU[2] = MFID;
+      PDU[1] = PDU[1] ^ 0xC0; //flip bits to make it compatible with MAC_PDUs explicit format
+
+      //without any extra bytes filled in, we can atleast see what the MBT is supposed to be
+      //Hopefully, no 0 value things will cause issues -- call grants, iden_up, etc!
+      // fprintf (stderr, "%s",KYEL);
+      // process_MAC_VPDU(opts, state, 0, PDU);
+      // fprintf (stderr, "%s",KNRM);
+    }
+  }
+
+  SKIPCALL: ; //do nothing
+
+  if (opts->payload == 1)
+  {
+    fprintf (stderr, "%s",KCYN);
+    fprintf (stderr, "\n P25 MBF Payload \n  ");
+    for (i = 0; i < 36; i++)
+    {
+      fprintf (stderr, "[%02X]", mpdu_byte[i]);
+      if (i == 11 || i == 23) fprintf (stderr, "\n  ");
+
+    }
+    fprintf (stderr, " CRC EXT %08X CMP %08X", CRCExtracted, CRCComputed);
+    fprintf (stderr, "%s ", KNRM);
+    fprintf (stderr, "\n "); 
+
+    //Header 
+    if (err[0] != 0) 
+    {
+      fprintf (stderr, "%s",KRED);
+      fprintf (stderr, " (HDR CRC16 ERR)");
+      fprintf (stderr, "%s",KCYN);
+    }
+    //Completed MBF 
+    if (err[1] != 0) 
+    {
+      fprintf (stderr, "%s",KRED);
+      fprintf (stderr, " (MBF CRC32 ERR)");
+      fprintf (stderr, "%s",KCYN);
+    }
+
+  }
+
+  fprintf (stderr, "%s ", KNRM);
+  fprintf (stderr, "\n"); 
+}

src/p25p1_tdu.c

@@ -33,4 +33,8 @@ processTDU (dsd_opts* opts, dsd_state* state)
         status = getDibit (opts, state) + '0';
         // TODO: do something useful with the status bits...
     }
+    
+    //reset some strings -- since its a tdu, blank out any call strings, only want during actual call
+    sprintf (state->call_string[0], "%s", "                     "); //21 spaces
+    sprintf (state->call_string[1], "%s", "                     "); //21 spaces
 }

src/p25p1_tdulc.c

@@ -390,11 +390,60 @@ processTDULC (dsd_opts* opts, dsd_state* state)
   lcinfo[53]  = dodeca_data[0][ 9] + '0';
   lcinfo[54]  = dodeca_data[0][10] + '0';
   lcinfo[55]  = dodeca_data[0][11] + '0';
-  /*
-  if (state->carrier == 1) //only update when carrier is present, otherwise, garbage values may be collected
+
+  int j;
+  uint8_t LCW_bytes[9];
+  uint8_t LCW_bits[72];
+  memset (LCW_bytes, 0, sizeof(LCW_bytes));
+  memset (LCW_bits, 0, sizeof(LCW_bits));
+
+  //load array above into byte form first
+  LCW_bytes[0] = (uint8_t) ConvertBitIntoBytes(&lcformat[0], 8);
+  LCW_bytes[1] = (uint8_t) ConvertBitIntoBytes(&mfid[0], 8);
+  for (i = 0; i < 7; i++) LCW_bytes[i+2] = (uint8_t) ConvertBitIntoBytes(&lcinfo[i*8], 8);
+
+  //load as bit array next (easier to process data in bit form)
+  for(i = 0, j = 0; i < 9; i++, j+=8)
   {
-    state->payload_mfid = strtol (mfid, NULL, 2); //wonder if this is accurate info or not
+    LCW_bits[j + 0] = (LCW_bytes[i] >> 7) & 0x01;
+    LCW_bits[j + 1] = (LCW_bytes[i] >> 6) & 0x01;
+    LCW_bits[j + 2] = (LCW_bytes[i] >> 5) & 0x01;
+    LCW_bits[j + 3] = (LCW_bytes[i] >> 4) & 0x01;
+    LCW_bits[j + 4] = (LCW_bytes[i] >> 3) & 0x01;
+    LCW_bits[j + 5] = (LCW_bytes[i] >> 2) & 0x01;
+    LCW_bits[j + 6] = (LCW_bytes[i] >> 1) & 0x01;
+    LCW_bits[j + 7] = (LCW_bytes[i] >> 0) & 0x01;
   }
-  */
-  processP25lcw (opts, state, lcformat, mfid, lcinfo);
+ 
+  //send to new P25 LCW function
+  if (irrecoverable_errors == 0)
+  {
+    fprintf (stderr, "%s", KYEL);
+    p25_lcw (opts, state, LCW_bits, 0);
+    fprintf (stderr, "%s", KNRM);
+  }
+  else
+  {
+    fprintf (stderr, "%s",KRED);
+    fprintf (stderr, " LCW FEC ERR ");
+    fprintf (stderr, "%s\n", KNRM);
+  }
+
+  if (opts->payload == 1)
+  {
+    fprintf (stderr, "%s",KCYN);
+    fprintf (stderr, " P25 LCW Payload ");
+    for (i = 0; i < 9; i++)
+    {
+      fprintf (stderr, "[%02X]", LCW_bytes[i]);
+    }
+    
+    
+    fprintf (stderr, "%s\n", KNRM);
+  }
+
+  //reset some strings -- since its a tdu, blank out any call strings, only want during actual call
+  sprintf (state->call_string[0], "%s", "                     "); //21 spaces
+  sprintf (state->call_string[1], "%s", "                     "); //21 spaces
+
 }

src/p25p1_tsbk.c

@@ -7,16 +7,40 @@
  *-----------------------------------------------------------------------------*/
 
 #include "dsd.h"
+
 void processTSBK(dsd_opts * opts, dsd_state * state)
 {
+
+  //reset some strings when returning from a call in case they didn't get zipped already
+  sprintf (state->call_string[0], "%s", "                     "); //21 spaces
+  sprintf (state->call_string[1], "%s", "                     "); //21 spaces
+
+  //clear stale Active Channel messages here
+  if ( (time(NULL) - state->last_active_time) > 3 )
+  {
+    memset (state->active_channel, 0, sizeof(state->active_channel));
+  }
   
-  int tsbkbit[196] = {0}; //tsbk bit array, 196 trellis encoded bits
-  int tsbk_dibit[98] = {0};
+  int tsbkbit[196]; //tsbk bit array, 196 trellis encoded bits
+  int tsbk_dibit[98];
+
+  memset (tsbkbit, 0, sizeof(tsbkbit));
+  memset (tsbk_dibit, 0, sizeof(tsbk_dibit));
 
   int dibit = 0;
-  uint8_t tsbk_byte[12] = {0}; //12 byte return from bd_bridge (block_deinterleave)
-  unsigned long long int PDU[24] = {0}; //24 byte PDU to send to the tsbk_byte vPDU handler, should be same formats (mostly)
-  int tsbk_decoded_bits[190] = {0}; //decoded bits from tsbk_bytes for sending to crc16_lb_bridge
+
+  uint8_t tsbk_byte[12]; //12 byte return from bd_bridge (block_deinterleave)
+  memset (tsbk_byte, 0, sizeof(tsbk_byte));
+
+  unsigned long long int PDU[24]; //24 byte PDU to send to the tsbk_byte vPDU handler, should be same formats (mostly)
+  memset (PDU, 0, sizeof(PDU));
+
+  int tsbk_decoded_bits[190]; //decoded bits from tsbk_bytes for sending to crc16_lb_bridge
+  memset (tsbk_decoded_bits, 0, sizeof(tsbk_decoded_bits));
+
+  int flushing_bits[196]; //for flushing the trellis state machine
+  memset (flushing_bits, 0, sizeof(flushing_bits));
+  
   int i, j, k, b, x, y;
   int ec = -2; //error value returned from (block_deinterleave)
   int err = -2; //error value returned from crc16_lb_bridge
@@ -24,11 +48,7 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
   int protectbit = 0;
   int MFID = 0xFF; //Manufacturer ID - Might be beneficial to NOT send anything but standard 0x00 or 0x01 messages
 
-  //Update: Identified Bug in skipdibit incrememnt causing many block deinterleave/crc failures
-  //with correct values set, now we are decoding many more TSBKs
   //TODO: Don't Print TSBKs/vPDUs unless verbosity levels set higher
-  //TSBKs are always single block, but up to three can be transmitted in a row,
-  //Multi-Block PDUs are sent on a different DUID - 0xC (not handled currently)
 
   //collect three reps of 101 dibits (98 valid dibits with status dibits interlaced)
   for (j = 0; j < 3; j++)
@@ -49,11 +69,19 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
 
       if (i+(j*101) == skipdibit) 
       {
-        skipdibit += 36; //was set to 35, this was the bug
+        skipdibit += 36;
       }
 
     }
 
+    //flushing the trellis state machine
+    if (j == 0)
+    {
+      bd_bridge(flushing_bits, tsbk_byte);
+      //reset tsbk_byte afterwards
+      memset (tsbk_byte, 0, sizeof(tsbk_byte));
+    }
+
     //send tsbkbit to block_deinterleave and return tsbk_byte
     ec = bd_bridge(tsbkbit, tsbk_byte);
 
@@ -84,7 +112,7 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
       tsbk_byte[i] = byte;
     }
 
-    //convert tsbk_byte to PDU and send to vPDU handler
+    //convert tsbk_byte to vPDU and send to vPDU handler
     //...may or may not be entirely compatible,
     MFID   = tsbk_byte[1];
     PDU[0] = 0x07; //P25p1 TSBK Duid 0x07
@@ -106,7 +134,10 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
     protectbit = (tsbk_byte[0] >> 6) & 0x1;
 
     //Don't run NET_STS out of this, or will set wrong NAC/CC //&& PDU[1] != 0x49 && PDU[1] != 0x45
-    //0x49 is telephone grant, 0x46 Unit to Unit Channel Answer Request (seems bogus)
+    //0x49 is telephone grant, 0x46 Unit to Unit Channel Answer Request (seems bogus) (mfid 90)
+    // if (MFID < 0x2 && protectbit == 0 && err == 0 && ec == 0 && PDU[1] != 0x7B )
+    //running with A4 and 90 causing some false positives when sending to vPDU, issuing bad call grants to nowhere!
+    // if ( (MFID < 0x2 || MFID == 0xA4 || MFID == 0x90) && protectbit == 0 && err == 0 && ec == 0 && PDU[1] != 0x7B )  
     if (MFID < 0x2 && protectbit == 0 && err == 0 && ec == 0 && PDU[1] != 0x7B ) 
     {
       fprintf (stderr, "%s",KYEL);
@@ -115,9 +146,9 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
     }
 
     //set our WACN and SYSID here now that we have valid ec and crc/checksum
-    if (protectbit == 0 && err == 0 && ec == 0 && (tsbk_byte[0] & 0x3F) == 0x3B)
+    else if (protectbit == 0 && err == 0 && ec == 0 && (tsbk_byte[0] & 0x3F) == 0x3B) 
     {
-      long int wacn = (tsbk_byte[3] << 12) | (tsbk_byte[4] << 4) | (tsbk_byte[5] >> 4);;
+      long int wacn = (tsbk_byte[3] << 12) | (tsbk_byte[4] << 4) | (tsbk_byte[5] >> 4);
       int sysid = ((tsbk_byte[5] & 0xF) << 8) | tsbk_byte[6];
       int channel = (tsbk_byte[7] << 8) | tsbk_byte[8];
       fprintf (stderr, "%s",KYEL);
@@ -143,16 +174,43 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
       if (opts->payload == 1)
       {
         fprintf (stderr, "%s",KCYN);
-        fprintf (stderr, "\n P25 PDU Payload ");
+        fprintf (stderr, "\n P25 PDU Payload #%d ", j);
         for (i = 0; i < 12; i++)
         {
           fprintf (stderr, "[%02X]", tsbk_byte[i]);
         }
       }
+
       fprintf (stderr, "%s ", KNRM);
 
     }
 
+    else
+    {
+      if (opts->payload == 1)
+      {
+        fprintf (stderr, "%s",KCYN);
+        fprintf (stderr, "\n P25 PDU Payload #%d ", j+1);
+        for (i = 0; i < 12; i++)
+        {
+          fprintf (stderr, "[%02X]", tsbk_byte[i]);
+        }
+        fprintf (stderr, "\n MFID %02X Protected: %d Last Block: %d", MFID, protectbit, (tsbk_byte[0] >> 7) );
+        
+        if (ec != 0) 
+        {
+          fprintf (stderr, "%s",KRED);
+          fprintf (stderr, " (FEC ERR)");
+        }
+        else if (err != 0) 
+        {
+          fprintf (stderr, "%s",KRED);
+          fprintf (stderr, " (CRC ERR)");
+        }
+        fprintf (stderr, "%s ", KNRM);
+      }
+    } 
+
     //reset for next rep
     ec = -2;
     err = -2;
@@ -165,5 +223,7 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
       j = 4; //set j to break the loop early
     }
   }
+
+  fprintf (stderr, "%s ", KNRM);
   fprintf (stderr, "\n"); 
 }

src/p25p2_frame.c

@@ -475,10 +475,16 @@ void process_4V (dsd_opts * opts, dsd_state * state)
 		fprintf (stderr, "\n");
 	}
 
-	//set to 16 for MBE OSS shim to preempt audio
-	if (state->currentslot == 0) state->dmrburstL = 16;
-	else state->dmrburstR = 16;
-
+	#ifdef AERO_BUILD //FUN FACT: OSS stutters only on Cygwin, using padsp in linux, it actually opens two virtual /dev/dsp audio streams for output
+	//Cygwin OSS Slot Preference Pre-emption shim
+	if (opts->audio_out_type == 5)
+	{
+		//set to 21 for MBE OSS shim to preempt audio 
+		if (state->currentslot == 0) state->dmrburstL = 21;
+		else state->dmrburstR = 21;
+	}
+	#endif
+	
 	processMbeFrame (opts, state, NULL, ambe_fr1, NULL);
 	processMbeFrame (opts, state, NULL, ambe_fr2, NULL);
 	processMbeFrame (opts, state, NULL, ambe_fr3, NULL);
@@ -546,6 +552,7 @@ void process_ESS (dsd_opts * opts, dsd_state * state)
 				fprintf (stderr, " ALG ID 0x%02X", state->payload_algid);
 				fprintf (stderr, " KEY ID 0x%04X", state->payload_keyid);
 				fprintf (stderr, " MI 0x%016llX", state->payload_miP);
+				if (state->R != 0 && state->payload_algid == 0xAA) fprintf (stderr, " Key 0x%010llX", state->R);
 				fprintf (stderr, " ESSB");
 			}
 
@@ -561,6 +568,7 @@ void process_ESS (dsd_opts * opts, dsd_state * state)
 				fprintf (stderr, " ALG ID 0x%02X", state->payload_algidR);
 				fprintf (stderr, " KEY ID 0x%04X", state->payload_keyidR);
 				fprintf (stderr, " MI 0x%016llX", state->payload_miN);
+				if (state->RR != 0 && state->payload_algidR == 0xAA) fprintf (stderr, " Key 0x%010llX", state->RR);
 				fprintf (stderr, " ESSB");
 			}
 
@@ -568,7 +576,11 @@ void process_ESS (dsd_opts * opts, dsd_state * state)
 	}
 	if (ec == -1 || ec >= 15)
 	{
-		//ESS R-S Failure
+		//ESS R-S Failure -- run LFSR on current MI if applicable
+		if (state->currentslot == 0 && state->payload_algid != 0x80 && state->payload_keyid != 0 && state->payload_miP != 0)
+			LFSRP(state);
+		if (state->currentslot == 1 && state->payload_algidR != 0x80 && state->payload_keyidR != 0 && state->payload_miN != 0)
+			LFSRP(state);
 	}
 	fprintf (stderr, "%s", KNRM);
 
@@ -630,15 +642,28 @@ void process_2V (dsd_opts * opts, dsd_state * state)
 		fprintf (stderr, "\n");
 	}
 
-	//set to 16 for MBE OSS shim to preempt audio
-	if (state->currentslot == 0) state->dmrburstL = 16;
-	else state->dmrburstR = 16;
+	#ifdef AERO_BUILD //FUN FACT: OSS stutters only on Cygwin, using padsp in linux, it actually opens two virtual /dev/dsp audio streams for output
+	//Cygwin OSS Slot Preference Pre-emption shim
+	if (opts->audio_out_type == 5)
+	{
+		//set to 21 for MBE OSS shim to preempt audio 
+		if (state->currentslot == 0) state->dmrburstL = 21;
+		else state->dmrburstR = 21;
+	}
+	#endif
 
 	processMbeFrame (opts, state, NULL, ambe_fr1, NULL);
 	processMbeFrame (opts, state, NULL, ambe_fr2, NULL);
 
 	process_ESS(opts, state);
 
+	//reset drop bytes after a 2V
+	if (state->currentslot == 0 && state->payload_algid == 0xAA)
+		state->dropL = 256;
+
+	if (state->currentslot == 1 && state->payload_algidR == 0xAA)
+		state->dropR = 256;
+
 }
 
 //P2 Data Unit ID
@@ -711,12 +736,24 @@ void process_P2_DUID (dsd_opts * opts, dsd_state * state)
 		}
 		else fprintf (stderr, "VCH S ");
 
+		//check to see when last voice activity occurred in order to allow tuning on phase 2
+		//mac_signal or mac_idle when no more voice activity on current channel
+		//this is primarily a fix for TDMA control channels that carry voice (Duke P25)
+		//but may also allow for chain tuning without returning to the control channel <--may be problematic since we can assign a p25_cc_freq from the pdu
+		if (duid_decoded == 13 && opts->p25_is_tuned == 1 && ((time(NULL) - state->last_vc_sync_time) > opts->trunk_hangtime) )  //version for MAC_SIGNAL only, no idle
+		{
+			opts->p25_is_tuned = 0;
+			state->p25_vc_freq[0] = state->p25_vc_freq[1] = 0;
+			memset (state->active_channel, 0, sizeof (state->active_channel)); //zero out here? I think this will be fine
+		}
+
 		if (duid_decoded == 0)
 		{
 			fprintf (stderr, " 4V %d", state->fourv_counter[state->currentslot]+1);
 			if (state->p2_wacn != 0 && state->p2_cc != 0 && state->p2_sysid != 0 &&
 					state->p2_wacn != 0xFFFFF && state->p2_cc != 0xFFF && state->p2_sysid != 0xFFF)
 			{
+				state->last_vc_sync_time = time(NULL);
 				process_4V (opts, state);
 			}
 		}
@@ -726,6 +763,7 @@ void process_P2_DUID (dsd_opts * opts, dsd_state * state)
 			if (state->p2_wacn != 0 && state->p2_cc != 0 && state->p2_sysid != 0 &&
 					state->p2_wacn != 0xFFFFF && state->p2_cc != 0xFFF && state->p2_sysid != 0xFFF)
 			{
+				state->last_vc_sync_time = time(NULL);
 				process_2V (opts, state);
 			}
 		}
@@ -823,22 +861,21 @@ void process_P2_DUID (dsd_opts * opts, dsd_state * state)
 void processP2 (dsd_opts * opts, dsd_state * state)
 {
 	state->dmr_stereo = 1; 
-	//state->currentslot = 1; 
-
 	p2_dibit_buffer (opts, state);
 
 	//look at our ISCH values and determine location in superframe before running frame scramble
-	for (framing_counter = 0; framing_counter < 4; framing_counter++) //12
+	for (framing_counter = 0; framing_counter < 4; framing_counter++)
 	{
-		process_ISCH (opts, state); //run ISCH in here so we know when to start descramble offset
+		//run ISCH in here so we know when to start descramble offset
+		process_ISCH (opts, state); 
 	}
 
 	//set initial current slot depending on offset value
 	if (state->p2_scramble_offset % 2)
 	{
-		state->currentslot = 0; 
+		state->currentslot = 1; 
 	}
-	else state->currentslot = 1; 
+	else state->currentslot = 0; 
 
 	//frame_scramble runs lfsr and creates an array of unscrambled bits to pull from
   process_Frame_Scramble (opts, state);
@@ -848,14 +885,5 @@ void processP2 (dsd_opts * opts, dsd_state * state)
 	state->dmr_stereo = 0; 
 	state->p2_is_lcch = 0;
 
-	//bugfix for OSS dmrbust 16 shim, reset both to 0 upon exit
-	//in case or marginal signal and both get stuck on 16, indefinitely muting the non-preferred slot
-	//but...this can also cause at least one 4v/2v to get through on the other slot if the sync lines up that way
-	if (opts->audio_out_type == 5)
-	{
-		//set both to blank value
-		state->dmrburstL = 17;
-		state->dmrburstR = 17;
-	}
   fprintf (stderr, "\n"); 
 }

src/p25p2_vpdu.c

@@ -84,7 +84,7 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 	for (int i = 0; i < 2; i++) 
 	{
 
-		//MFID90 Voice Grants, A3, A4, and A5
+		//MFID90 Voice Grants, A3, A4, and A5 <--I bet A4 here was triggering a phantom call when TSBK sent PDUs here
 		//MFID90 Group Regroup Channel Grant - Implicit
 		if (MAC[1+len_a] == 0xA3 && MAC[2+len_a] == 0x90)
 		{
@@ -96,6 +96,10 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			fprintf (stderr, "\n  CHAN [%04X] Group [%d][%04X]", channel, sgroup, sgroup);
 			freq = process_channel_to_freq (opts, state, channel);
 
+			//add active channel to string for ncurses display
+			sprintf (state->active_channel[0], "MFID90 Active Ch: %04X SG: %d; ", channel, sgroup);
+			state->last_active_time = time(NULL);
+
 			for (int i = 0; i < state->group_tally; i++)
       {
         if (state->group_array[i].groupNumber == sgroup)
@@ -114,30 +118,34 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 				//reworked to set freq once on any call to process_channel_to_freq, and tune on that, independent of slot
     		if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && freq != 0) //if we aren't already on a VC and have a valid frequency
     		{
-					//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
-					if (opts->mod_qpsk == 1)
+					//changed to allow symbol rate change on C4FM Phase 2 systems as well as QPSK
+					if (1 == 1)
 					{
-						int spacing = state->p25_chan_spac[channel >> 12];
-						if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+						if (state->p25_chan_tdma[channel >> 12] == 1)
 						{
 							state->samplesPerSymbol = 8;
 							state->symbolCenter = 3;
-						}	
+						}
 					}
+					
 					//rigctl
           if (opts->use_rigctl == 1)
 					{
 						if (opts->setmod_bw != 0 ) SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
       			SetFreq(opts->rigctl_sockfd, freq);
 						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq;
-						opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop 
+						opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop
+						state->last_vc_sync_time = time(NULL);
 					}
-					//rtl_udp
+					//rtl
 					else if (opts->audio_in_type == 3)
 					{
-						rtl_udp_tune (opts, state, freq);
+						#ifdef USE_RTLSDR
+						rtl_dev_tune (opts, freq);
 						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq;
 						opts->p25_is_tuned = 1;
+						state->last_vc_sync_time = time(NULL);
+						#endif
 					}
     		}    
   		}
@@ -164,6 +172,10 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			fprintf (stderr, "\n  CHAN [%04X] Group [%d][%04X]", channel, sgroup, sgroup);
 			freq = process_channel_to_freq (opts, state, channel);
 
+			//add active channel to string for ncurses display
+			sprintf (state->active_channel[0], "MFID90 Active Ch: %04X SG: %d ", channel, sgroup);
+			state->last_active_time = time(NULL);
+
 			for (int i = 0; i < state->group_tally; i++)
       {
         if (state->group_array[i].groupNumber == sgroup)
@@ -182,15 +194,14 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 				//reworked to set freq once on any call to process_channel_to_freq, and tune on that, independent of slot
     		if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && freq != 0) //if we aren't already on a VC and have a valid frequency
     		{
-					//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
-					if (opts->mod_qpsk == 1)
+					//changed to allow symbol rate change on C4FM Phase 2 systems as well as QPSK
+					if (1 == 1)
 					{
-						int spacing = state->p25_chan_spac[channel >> 12];
-						if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+						if (state->p25_chan_tdma[channel >> 12] == 1)
 						{
 							state->samplesPerSymbol = 8;
 							state->symbolCenter = 3;
-						}	
+						}
 					}
 					
           if (opts->use_rigctl == 1)
@@ -198,14 +209,18 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 						if (opts->setmod_bw != 0 ) SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
       			SetFreq(opts->rigctl_sockfd, freq);
 						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq;
-						opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop 
+						opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop
+						state->last_vc_sync_time = time(NULL);
 					}
-					//rtl_udp
+					//rtl
 					else if (opts->audio_in_type == 3)
 					{
-						rtl_udp_tune (opts, state, freq);
+						#ifdef USE_RTLSDR
+						rtl_dev_tune (opts, freq);
 						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq;
 						opts->p25_is_tuned = 1;
+						state->last_vc_sync_time = time(NULL);
+						#endif
 					}
     		}    
   		}
@@ -239,6 +254,10 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			fprintf (stderr, "\n  Channel 2 [%04X] Group 2 [%d][%04X]", channel2, group2, group2);
 			freq2 = process_channel_to_freq (opts, state, channel2);
 
+			//add active channel to string for ncurses display
+			sprintf (state->active_channel[0], "MFID90 Active Ch: %04X SG: %d; Ch: %04X SG: %d; ", channel1, group1, channel2, group2);
+			state->last_active_time = time(NULL);
+
 			//Skip tuning group calls if group calls are disabled
 			if (opts->trunk_tune_group_calls == 0) goto SKIPCALL;
 
@@ -283,16 +302,16 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 					//reworked to set freq once on any call to process_channel_to_freq, and tune on that, independent of slot
 					if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && tunable_freq != 0) //if we aren't already on a VC and have a valid frequency already
 					{
-						//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
-						if (opts->mod_qpsk == 1) 
+						//changed to allow symbol rate change on C4FM Phase 2 systems as well as QPSK
+						if (1 == 1)
 						{
-							int spacing = state->p25_chan_spac[tunable_chan >> 12];
-							if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+							if (state->p25_chan_tdma[tunable_chan >> 12] == 1)
 							{
 								state->samplesPerSymbol = 8;
 								state->symbolCenter = 3;
-							}	
+							}
 						}
+
 						//rigctl
 						if (opts->use_rigctl == 1)
 						{
@@ -300,17 +319,21 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 							SetFreq(opts->rigctl_sockfd, tunable_freq);
 							//probably best to only set these when really tuning
 							state->p25_vc_freq[0] = state->p25_vc_freq[1] = tunable_freq;
-							opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop 
+							opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop
+							state->last_vc_sync_time = time(NULL);
 							j = 8; //break loop
 							
 						}
-						//rtl_udp
+						//rtl
 						else if (opts->audio_in_type == 3)
 						{
-							rtl_udp_tune (opts, state, tunable_freq);
+							#ifdef USE_RTLSDR
+							rtl_dev_tune (opts, tunable_freq);
 							state->p25_vc_freq[0] = state->p25_vc_freq[1] = tunable_freq;
 							opts->p25_is_tuned = 1;
+							state->last_vc_sync_time = time(NULL);
 							j = 8; //break loop
+							#endif
 						}
 					}    
 				}
@@ -339,10 +362,27 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			int source  = (MAC[7+len_a] << 16) | (MAC[8+len_a] << 8) | MAC[9+len_a];
 			long int freq = 0;
 
-			fprintf (stderr, "\n Group Voice Channel Grant Update");
+			fprintf (stderr, "\n");
+			if (svc & 0x80) fprintf (stderr, " Emergency");
+      if (svc & 0x40) fprintf (stderr, " Encrypted");
+
+      if (opts->payload == 1) //hide behind payload due to len
+      {
+        if (svc & 0x20) fprintf (stderr, " Duplex");
+        if (svc & 0x10) fprintf (stderr, " Packet");
+        else fprintf (stderr, " Circuit");
+        if (svc & 0x8) fprintf (stderr, " R"); //reserved bit is on
+        fprintf (stderr, " Priority %d", svc & 0x7); //call priority
+      }
+
+			fprintf (stderr, " Group Voice Channel Grant Update");
 			fprintf (stderr, "\n  SVC [%02X] CHAN [%04X] Group [%d] Source [%d]", svc, channel, group, source);
 			freq = process_channel_to_freq (opts, state, channel);
 
+			//add active channel to string for ncurses display
+			sprintf (state->active_channel[0], "Active Ch: %04X TG: %d; ", channel, group);
+			state->last_active_time = time(NULL);
+
 			for (int i = 0; i < state->group_tally; i++)
       {
         if (state->group_array[i].groupNumber == group)
@@ -355,22 +395,25 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			//Skip tuning group calls if group calls are disabled
 			if (opts->trunk_tune_group_calls == 0) goto SKIPCALL;
 
+			//Skip tuning encrypted calls if enc calls are disabled
+      if ( (svc & 0x40) && opts->trunk_tune_enc_calls == 0) goto SKIPCALL;
+
 			//tune if tuning available
 			if (opts->p25_trunk == 1 && (strcmp(mode, "DE") != 0) && (strcmp(mode, "B") != 0))
   		{
 				//reworked to set freq once on any call to process_channel_to_freq, and tune on that, independent of slot
     		if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && freq != 0) //if we aren't already on a VC and have a valid frequency
     		{
-					//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
-					if (opts->mod_qpsk == 1)
+					//changed to allow symbol rate change on C4FM Phase 2 systems as well as QPSK
+					if (1 == 1)
 					{
-						int spacing = state->p25_chan_spac[channel >> 12];
-						if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+						if (state->p25_chan_tdma[channel >> 12] == 1)
 						{
 							state->samplesPerSymbol = 8;
 							state->symbolCenter = 3;
-						}	
+						}
 					}
+
 					//rigctl
           if (opts->use_rigctl == 1)
 					{
@@ -378,13 +421,17 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
       			SetFreq(opts->rigctl_sockfd, freq);
 						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq;
 						opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop 
+						state->last_vc_sync_time = time(NULL);
 					}
-					//rtl_udp
+					//rtl
 					else if (opts->audio_in_type == 3)
 					{
-						rtl_udp_tune (opts, state, freq);
+						#ifdef USE_RTLSDR
+						rtl_dev_tune (opts, freq);
 						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq;
 						opts->p25_is_tuned = 1;
+						state->last_vc_sync_time = time(NULL);
+						#endif
 					}
     		}    
   		}
@@ -403,7 +450,7 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 		}
 
 		//Unit-to-Unit Voice Service Channel Grant (UU_V_CH_GRANT), or Grant Update (same format)
-		if (MAC[1+len_a] == 0x44 || MAC[1+len_a] == 0x46)
+		if (MAC[1+len_a] == 0x44 || MAC[1+len_a] == 0x46) //double check these opcodes
 		{
 			int channel = (MAC[2+len_a] << 8) | MAC[3+len_a];
 			int target  = (MAC[4+len_a] << 16) | (MAC[5+len_a] << 8) | MAC[6+len_a];
@@ -415,9 +462,16 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			fprintf (stderr, "\n  CHAN [%04X] Source [%d] Target [%d]", channel, source, target);
 			freq = process_channel_to_freq (opts, state, channel);
 
+			//add active channel to string for ncurses display
+			sprintf (state->active_channel[0], "Active Ch: %04X TGT: %d; ", channel, target);
+			state->last_active_time = time(NULL);
+
 			//Skip tuning private calls if private calls is disabled
       if (opts->trunk_tune_private_calls == 0) goto SKIPCALL; 
 
+			//Skip tuning encrypted calls if enc calls are disabled -- abb formats do not carry svc bits :(
+      if (opts->trunk_tune_enc_calls == 0) goto SKIPCALL; //enable, or disable?
+
 			//unit to unit needs work, may fail under certain conditions (first blocked, second allowed, etc) (labels should still work though)
 			for (int i = 0; i < state->group_tally; i++)
       {
@@ -434,30 +488,34 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 				//reworked to set freq once on any call to process_channel_to_freq, and tune on that, independent of slot
     		if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && freq != 0) //if we aren't already on a VC and have a valid frequency
     		{
-					//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
-					if (opts->mod_qpsk == 1)
+					//changed to allow symbol rate change on C4FM Phase 2 systems as well as QPSK
+					if (1 == 1)
 					{
-						int spacing = state->p25_chan_spac[channel >> 12];
-						if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+						if (state->p25_chan_tdma[channel >> 12] == 1)
 						{
 							state->samplesPerSymbol = 8;
 							state->symbolCenter = 3;
-						}	
+						}
 					}
+
 					//rigctl
           if (opts->use_rigctl == 1)
 					{
 						if (opts->setmod_bw != 0 ) SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
       			SetFreq(opts->rigctl_sockfd, freq);
 						if (state->synctype == 0 || state->synctype == 1) state->p25_vc_freq[0] = freq;
-						opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop 
+						opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop
+						state->last_vc_sync_time = time(NULL); 
 					}
-					//rtl_udp
+					//rtl
 					else if (opts->audio_in_type == 3)
 					{
-						rtl_udp_tune (opts, state, freq);
+						#ifdef USE_RTLSDR
+						rtl_dev_tune (opts, freq);
 						if (state->synctype == 0 || state->synctype == 1) state->p25_vc_freq[0] = freq;
 						opts->p25_is_tuned = 1;
+						state->last_vc_sync_time = time(NULL);
+						#endif
 					}
     		}    
   		}
@@ -489,17 +547,46 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			long int freq1r = 0;
 			long int freq2t = 0;
 			long int freq2r = 0;
+
 			fprintf (stderr, "\n Group Voice Channel Grant Update Multiple - Explicit");
 			fprintf (stderr, "\n  SVC [%02X] CHAN-T [%04X] CHAN-R [%04X] Group [%d][%04X]", svc1, channelt1, channelr1, group1, group1);
+			if (svc1 & 0x80) fprintf (stderr, " Emergency");
+      if (svc1 & 0x40) fprintf (stderr, " Encrypted");
+      if (opts->payload == 1) //hide behind payload due to len
+      {
+        if (svc1 & 0x20) fprintf (stderr, " Duplex");
+        if (svc1 & 0x10) fprintf (stderr, " Packet");
+        else fprintf (stderr, " Circuit");
+        if (svc1 & 0x8) fprintf (stderr, " R"); //reserved bit is on
+        fprintf (stderr, " Priority %d", svc1 & 0x7); //call priority
+      }
 			freq1t = process_channel_to_freq (opts, state, channelt1);
-			freq1r = process_channel_to_freq (opts, state, channelr1);
+			if (channelr1 != 0 && channelr1 != 0xFFFF) freq1r = process_channel_to_freq (opts, state, channelr1);
+
 			fprintf (stderr, "\n  SVC [%02X] CHAN-T [%04X] CHAN-R [%04X] Group [%d][%04X]", svc2, channelt2, channelr2, group2, group2);
+			if (svc2 & 0x80) fprintf (stderr, " Emergency");
+      if (svc2 & 0x40) fprintf (stderr, " Encrypted");
+      if (opts->payload == 1) //hide behind payload due to len
+      {
+        if (svc2 & 0x20) fprintf (stderr, " Duplex");
+        if (svc2 & 0x10) fprintf (stderr, " Packet");
+        else fprintf (stderr, " Circuit");
+        if (svc2 & 0x8) fprintf (stderr, " R"); //reserved bit is on
+        fprintf (stderr, " Priority %d", svc2 & 0x7); //call priority
+      }
 			freq1t = process_channel_to_freq (opts, state, channelt2);
-			freq1r = process_channel_to_freq (opts, state, channelr2);
+			if (channelr2 != 0 && channelr2 != 0xFFFF) freq1r = process_channel_to_freq (opts, state, channelr2);
+
+			//add active channel to string for ncurses display
+			sprintf (state->active_channel[0], "Active Ch: %04X TG: %d; Ch: %04X TG: %d; ", channelt1, group1, channelt2, group2);
+			state->last_active_time = time(NULL);
 
 			//Skip tuning group calls if group calls are disabled
 			if (opts->trunk_tune_group_calls == 0) goto SKIPCALL;
 
+			//Skip tuning encrypted calls if enc calls are disabled
+      if ( (svc1 & 0x40) && (svc2 & 0x40) && opts->trunk_tune_enc_calls == 0) goto SKIPCALL;
+
 			int loop = 1;
 			if (channelt2 == channelt2) loop = 1;
 			else loop = 2;
@@ -510,6 +597,16 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 
 			for (int j = 0; j < loop; j++)
 			{
+				//test svc opts for enc to tune or skip
+				if (j == 0)
+				{
+					if ( (svc1 & 0x40) && opts->trunk_tune_enc_calls == 0) j++; //skip to next
+				}
+				if (j == 1)
+				{
+					if (( svc2 & 0x40) && opts->trunk_tune_enc_calls == 0) goto SKIPCALL; //skip to end
+				}
+
 				//assign our internal variables for check down on if to tune one freq/group or not
 				if (j == 0)
 				{
@@ -538,15 +635,14 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 					//reworked to set freq once on any call to process_channel_to_freq, and tune on that, independent of slot
 					if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && tunable_freq != 0) //if we aren't already on a VC and have a valid frequency
 					{
-						//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
-						if (opts->mod_qpsk == 1)
+						//changed to allow symbol rate change on C4FM Phase 2 systems as well as QPSK
+						if (1 == 1)
 						{
-							int spacing = state->p25_chan_spac[tunable_chan >> 12];
-							if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+							if (state->p25_chan_tdma[tunable_chan >> 12] == 1)
 							{
 								state->samplesPerSymbol = 8;
 								state->symbolCenter = 3;
-							}	
+							}
 						}
 						
 						if (opts->use_rigctl == 1)
@@ -554,16 +650,20 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 							if (opts->setmod_bw != 0 ) SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
 							SetFreq(opts->rigctl_sockfd, tunable_freq);
 							state->p25_vc_freq[0] = state->p25_vc_freq[1] = tunable_freq;
-							opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop 
+							opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop
+							state->last_vc_sync_time = time(NULL);
 							j = 8; //break loop
 						}
-						//rtl_udp
+						//rtl
 						else if (opts->audio_in_type == 3)
 						{
-							rtl_udp_tune (opts, state, tunable_freq);
+							#ifdef USE_RTLSDR
+							rtl_dev_tune (opts, tunable_freq);
 							state->p25_vc_freq[0] = state->p25_vc_freq[1] = tunable_freq;
 							opts->p25_is_tuned = 1;
+							state->last_vc_sync_time = time(NULL);
 							j = 8; //break loop
+							#endif
 						}
 					}    
 				}
@@ -581,7 +681,7 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 		}
 
 		//Group Voice Channel Grant Update Multiple - Implicit
-		if (MAC[1+len_a] == 0x05) //wonder if this is MAC_SIGNAL only? Too long for a TSBK
+		if (MAC[1+len_a] == 0x05)
 		{
 			int so1 = MAC[2+len_a];
 			int channel1  = (MAC[3+len_a] << 8) | MAC[4+len_a];
@@ -598,15 +698,54 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 
 			fprintf (stderr, "\n Group Voice Channel Grant Update Multiple - Implicit");
 			fprintf (stderr, "\n  Channel 1 [%04X] Group 1 [%d][%04X]", channel1, group1, group1);
+			if (so1 & 0x80) fprintf (stderr, " Emergency");
+      if (so1 & 0x40) fprintf (stderr, " Encrypted");
+      if (opts->payload == 1) //hide behind payload due to len
+      {
+        if (so1 & 0x20) fprintf (stderr, " Duplex");
+        if (so1 & 0x10) fprintf (stderr, " Packet");
+        else fprintf (stderr, " Circuit");
+        if (so1 & 0x8) fprintf (stderr, " R"); //reserved bit is on
+        fprintf (stderr, " Priority %d", so1 & 0x7); //call priority
+      }
 			freq1 = process_channel_to_freq (opts, state, channel1);
+
 			fprintf (stderr, "\n  Channel 2 [%04X] Group 2 [%d][%04X]", channel2, group2, group2);
+			if (so2 & 0x80) fprintf (stderr, " Emergency");
+      if (so2 & 0x40) fprintf (stderr, " Encrypted");
+      if (opts->payload == 1) //hide behind payload due to len
+      {
+        if (so2 & 0x20) fprintf (stderr, " Duplex");
+        if (so2 & 0x10) fprintf (stderr, " Packet");
+        else fprintf (stderr, " Circuit");
+        if (so2 & 0x8) fprintf (stderr, " R"); //reserved bit is on
+        fprintf (stderr, " Priority %d", so2 & 0x7); //call priority
+      }
 			freq2 = process_channel_to_freq (opts, state, channel2);
+
 			fprintf (stderr, "\n  Channel 3 [%04X] Group 3 [%d][%04X]", channel3, group3, group3);
+			if (so3 & 0x80) fprintf (stderr, " Emergency");
+      if (so3 & 0x40) fprintf (stderr, " Encrypted");
+      if (opts->payload == 1) //hide behind payload due to len
+      {
+        if (so3 & 0x20) fprintf (stderr, " Duplex");
+        if (so3 & 0x10) fprintf (stderr, " Packet");
+        else fprintf (stderr, " Circuit");
+        if (so3 & 0x8) fprintf (stderr, " R"); //reserved bit is on
+        fprintf (stderr, " Priority %d", so3 & 0x7); //call priority
+      }
 			freq3 = process_channel_to_freq (opts, state, channel3);
 
+			//add active channel to string for ncurses display
+			sprintf (state->active_channel[0], "Active Ch: %04X TG: %d; Ch: %04X TG: %d; Ch: %04X TG: %d; ", channel1, group1, channel2, group2, channel3, group3);
+			state->last_active_time = time(NULL);
+
 			//Skip tuning group calls if group calls are disabled
 			if (opts->trunk_tune_group_calls == 0) goto SKIPCALL;
 
+			//Skip tuning encrypted calls if enc calls are disabled
+      if ( (so1 & 0x40) && (so2 & 0x40) && (so3 & 0x40) && opts->trunk_tune_enc_calls == 0) goto SKIPCALL;
+
 			int loop = 3;
 
 			long int tunable_freq = 0;
@@ -615,6 +754,20 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 
 			for (int j = 0; j < loop; j++)
 			{
+				//test svc opts for enc to tune or skip
+				if (j == 0)
+				{
+					if ( (so1 & 0x40) && opts->trunk_tune_enc_calls == 0) j++; //skip to next
+				}
+				if (j == 1)
+				{
+					if ( (so2 & 0x40) && opts->trunk_tune_enc_calls == 0) j++; //skip to next
+				}
+				if (j == 2)
+				{
+					if ( (so3 & 0x40) && opts->trunk_tune_enc_calls == 0) goto SKIPCALL; //skip to end
+				}
+
 				//assign our internal variables for check down on if to tune one freq/group or not
 				if (j == 0)
 				{
@@ -650,16 +803,16 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 					//reworked to set freq once on any call to process_channel_to_freq, and tune on that, independent of slot
 					if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && tunable_freq != 0) //if we aren't already on a VC and have a valid frequency already
 					{
-						//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
-						if (opts->mod_qpsk == 1) 
+						//changed to allow symbol rate change on C4FM Phase 2 systems as well as QPSK
+						if (1 == 1)
 						{
-							int spacing = state->p25_chan_spac[tunable_chan >> 12];
-							if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+							if (state->p25_chan_tdma[tunable_chan >> 12] == 1)
 							{
 								state->samplesPerSymbol = 8;
 								state->symbolCenter = 3;
-							}	
+							}
 						}
+
 						//rigctl
 						if (opts->use_rigctl == 1)
 						{
@@ -667,17 +820,21 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 							SetFreq(opts->rigctl_sockfd, tunable_freq);
 							//probably best to only set these when really tuning
 							state->p25_vc_freq[0] = state->p25_vc_freq[1] = tunable_freq;
-							opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop 
+							opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop
+							state->last_vc_sync_time = time(NULL);
 							j = 8; //break loop
 						}
-						//rtl_udp
+						//rtl
 						else if (opts->audio_in_type == 3)
 						{
-							rtl_udp_tune (opts, state, tunable_freq);
+							#ifdef USE_RTLSDR
+							rtl_dev_tune (opts, tunable_freq);
 							//probably best to only set these when really tuning
 							state->p25_vc_freq[0] = state->p25_vc_freq[1] = tunable_freq;
 							opts->p25_is_tuned = 1;
+							state->last_vc_sync_time = time(NULL);
 							j = 8; //break loop
+							#endif
 						}
 					}    
 				}
@@ -710,9 +867,16 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			fprintf (stderr, "\n  Channel 2 [%04X] Group 2 [%d][%04X]", channel2, group2, group2);
 			freq2 = process_channel_to_freq (opts, state, channel2);
 
+			//add active channel to string for ncurses display
+			sprintf (state->active_channel[0], "Active Ch: %04X TG: %d; Ch: %04X TG: %d; ", channel1, group1, channel2, group2);
+			state->last_active_time = time(NULL);
+
 			//Skip tuning group calls if group calls are disabled
 			if (opts->trunk_tune_group_calls == 0) goto SKIPCALL;
 
+			//Skip tuning encrypted calls if enc calls are disabled -- abb formats do not carry svc bits :(
+      if (opts->trunk_tune_enc_calls == 0) goto SKIPCALL; //enable, or disable?
+
 			int loop = 1;
 			if (channel1 == channel2) loop = 1;
 			else loop = 2;
@@ -752,16 +916,16 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 					//reworked to set freq once on any call to process_channel_to_freq, and tune on that, independent of slot
 					if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && tunable_freq != 0) //if we aren't already on a VC and have a valid frequency already
 					{
-						//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
-						if (opts->mod_qpsk == 1) 
+						//changed to allow symbol rate change on C4FM Phase 2 systems as well as QPSK
+						if (1 == 1)
 						{
-							int spacing = state->p25_chan_spac[tunable_chan >> 12];
-							if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+							if (state->p25_chan_tdma[tunable_chan >> 12] == 1)
 							{
 								state->samplesPerSymbol = 8;
 								state->symbolCenter = 3;
-							}	
+							}
 						}
+
 						//rigctl
 						if (opts->use_rigctl == 1)
 						{
@@ -770,16 +934,20 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 							//probably best to only set these when really tuning
 							state->p25_vc_freq[0] = state->p25_vc_freq[1] = tunable_freq;
 							opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop 
+							state->last_vc_sync_time = time(NULL);
 							j = 8; //break loop
 						}
-						//rtl_udp
+						//rtl
 						else if (opts->audio_in_type == 3)
 						{
-							rtl_udp_tune (opts, state, tunable_freq);
+							#ifdef USE_RTLSDR
+							rtl_dev_tune (opts, tunable_freq);
 							//probably best to only set these when really tuning
 							state->p25_vc_freq[0] = state->p25_vc_freq[1] = tunable_freq;
 							opts->p25_is_tuned = 1;
+							state->last_vc_sync_time = time(NULL);
 							j = 8; //break loop
+							#endif
 						}
 					}    
 				}
@@ -806,15 +974,30 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			long int freq1 = 0;
 			long int freq2 = 0;
 
-			fprintf (stderr, "\n Group Voice Channel Grant Update - Explicit");
+			fprintf (stderr, "\n");
+
+			if (svc & 0x80) fprintf (stderr, " Emergency");
+      if (svc & 0x40) fprintf (stderr, " Encrypted");
+
+      if (opts->payload == 1) //hide behind payload due to len
+      {
+        if (svc & 0x20) fprintf (stderr, " Duplex");
+        if (svc & 0x10) fprintf (stderr, " Packet");
+        else fprintf (stderr, " Circuit");
+        if (svc & 0x8) fprintf (stderr, " R"); //reserved bit is on
+        fprintf (stderr, " Priority %d", svc & 0x7); //call priority
+      }
+			fprintf (stderr, " Group Voice Channel Grant Update - Explicit");
 			fprintf (stderr, "\n  SVC [%02X] CHAN-T [%04X] CHAN-R [%04X] Group [%d][%04X]", svc, channelt, channelr, group, group);
 			freq1 = process_channel_to_freq (opts, state, channelt);
-			freq2 = process_channel_to_freq (opts, state, channelr);
-			if (slot == 0)
-			{
-				state->lasttg = group;
-			}
-			else state->lasttgR = group;
+			if (channelr != 0 && channelr != 0xFFFF) freq2 = process_channel_to_freq (opts, state, channelr); //one system had this as channel 0xFFFF -- look up any particular meaning for that
+
+			//don't set the tg here, one multiple grant updates, will mess up the TG value on current call
+			// if (slot == 0)
+			// {
+			// 	state->lasttg = group;
+			// }
+			// else state->lasttgR = group;
 
 			for (int i = 0; i < state->group_tally; i++)
       {
@@ -828,36 +1011,44 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			//Skip tuning group calls if group calls are disabled
 			if (opts->trunk_tune_group_calls == 0) goto SKIPCALL;
 
+			//Skip tuning encrypted calls if enc calls are disabled
+      if ( (svc & 0x40) && opts->trunk_tune_enc_calls == 0) goto SKIPCALL;
+
 			//tune if tuning available
 			if (opts->p25_trunk == 1 && (strcmp(mode, "DE") != 0) && (strcmp(mode, "B") != 0))
   		{
 				//reworked to set freq once on any call to process_channel_to_freq, and tune on that, independent of slot
     		if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && freq1 != 0) //if we aren't already on a VC and have a valid frequency
     		{
-					//testing switch to P2 channel symbol rate with qpsk enabled, we need to know if we are going to a TDMA channel or an FDMA channel
-					if (opts->mod_qpsk == 1)
+
+					//changed to allow symbol rate change on C4FM Phase 2 systems as well as QPSK
+					if (1 == 1)
 					{
-						int spacing = state->p25_chan_spac[channelt >> 12];
-						if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
+						if (state->p25_chan_tdma[channelt >> 12] == 1)
 						{
 							state->samplesPerSymbol = 8;
 							state->symbolCenter = 3;
-						}	
+						}
 					}
+
 					//rigctl
           if (opts->use_rigctl == 1)
 					{
 						if (opts->setmod_bw != 0 ) SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
       			SetFreq(opts->rigctl_sockfd, freq1);
 						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq1;
-						opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop 
+						opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop
+						state->last_vc_sync_time = time(NULL);
 					}
-					//rtl_udp
+					//rtl
 					else if (opts->audio_in_type == 3)
 					{
-						rtl_udp_tune (opts, state, freq1);
+						#ifdef USE_RTLSDR
+						rtl_dev_tune (opts, freq1);
 						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq1;
 						opts->p25_is_tuned = 1;
+						state->last_vc_sync_time = time(NULL);
+						#endif
 					}
     		}    
   		}
@@ -940,7 +1131,7 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 		}
 
 		//Unit-to-Unit Answer Request (UU_ANS_REQ)
-		if (MAC[1+len_a] == 0x45)
+		if (MAC[1+len_a] == 0x45 && MAC[2+len_a] != 0x90)
 		{
 			int svc     = MAC[2+len_a];
 			int answer  = MAC[3+len_a];
@@ -952,17 +1143,17 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			
 		}
 
-		//Telephone Interconnect Voice Channel Grant (TELE_INT_CH_GRANT)
-		if (MAC[1+len_a] == 0x48)
-		{
-			fprintf (stderr, "\n Telephone Interconnect Voice Channel Grant ");	
-		}
+		//Telephone Interconnect Voice Channel Grant (TELE_INT_CH_GRANT) //look at PDU for this, see if this is tunable
+		// if (MAC[1+len_a] == 0x48 && MAC[2+len_a] != 0x90)
+		// {
+		// 	fprintf (stderr, "\n Telephone Interconnect Voice Channel Grant ");	
+		// }
 
-		//Telephone Interconnect Voice Channel Grant Update (TELE_INT_CH_GRANT_UPDT)
-		if (MAC[1+len_a] == 0x49)
-		{
-			fprintf (stderr, "\n Telephone Interconnect Voice Channel Grant Update ");	
-		}
+		// //Telephone Interconnect Voice Channel Grant Update (TELE_INT_CH_GRANT_UPDT)
+		// if (MAC[1+len_a] == 0x49 && MAC[2+len_a] != 0x90)
+		// {
+		// 	fprintf (stderr, "\n Telephone Interconnect Voice Channel Grant Update ");	
+		// }
 
 		//Synchronization Broadcast (SYNC_BCST)
 		if (MAC[1+len_a] == 0x70)
@@ -986,12 +1177,12 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			else offhour = ( (ltoff & 0b11111 ) / 2);
 			
 			int seconds = slots / 135; //very rough estimation, but may be close enough for grins
-			if (seconds > 60) seconds = 60; //sanity check for rounding error
+			if (seconds > 59) seconds = 59; //sanity check for rounding error
 			fprintf (stderr, "  Date: 20%02d.%02d.%02d Time: %02d:%02d:%02d UTC\n", 
 			          year, month, day, hour, min, seconds); 
 			fprintf (stderr, "  Local Time Offset: %.01f Hours;", offhour);
 			//if ist bit is set, then time on system may be considered invalid (i.e., no external time sync)
-			if (ist % 1)
+			if (ist == 1)
 			{
 				fprintf (stderr, " Invalid System Time ");
 			}
@@ -999,18 +1190,31 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 
 		}
 
-		//identifier update VHF/UHF
-		if (MAC[1+len_a] == 0x74)
+		//identifier update VHF/UHF 
+		if (MAC[1+len_a] == 0x74) 
 		{
 			state->p25_chan_iden = MAC[2+len_a] >> 4;
 			int iden = state->p25_chan_iden;
-
-			state->p25_chan_type[iden] = 1;
 			int bw_vu = (MAC[2+len_a] & 0xF);
 			state->p25_trans_off[iden] = (MAC[3+len_a] << 6) | (MAC[4+len_a] >> 2);
 			state->p25_chan_spac[iden] = ((MAC[4+len_a] & 0x3) << 8) | MAC[5+len_a];
 			state->p25_base_freq[iden] = (MAC[6+len_a] << 24) | (MAC[7+len_a] << 16) | (MAC[8+len_a] << 8) | (MAC[9+len_a] << 0);
 
+			//this is causing more issues -- need a different way to check on this
+			// if (state->p25_chan_spac[iden] == 0x64) //tdma
+			// {
+			// 	state->p25_chan_type[iden] = 4; //
+			// 	state->p25_chan_tdma[iden] = 1; //
+			// }
+			// else //fdma
+			// {
+			// 	state->p25_chan_type[iden] = 1; //
+			// 	state->p25_chan_tdma[iden] = 0; //
+			// }
+
+			state->p25_chan_type[iden] = 1; //set as old values for now
+			state->p25_chan_tdma[iden] = 0; //set as old values for now
+
 			fprintf (stderr, "\n Identifier Update UHF/VHF\n");
 			fprintf (stderr, "  Channel Identifier [%01X] BW [%01X] Transmit Offset [%04X]\n  Channel Spacing [%03X] Base Frequency [%08lX] [%09ld]",
 			                    state->p25_chan_iden, bw_vu, state->p25_trans_off[iden], state->p25_chan_spac[iden], state->p25_base_freq[iden], state->p25_base_freq[iden] * 5);
@@ -1023,6 +1227,7 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			int iden = state->p25_chan_iden;
 
 			state->p25_chan_type[iden] = 1;
+			state->p25_chan_tdma[iden] = 0;
 			int bw = ((MAC[2+len_a] & 0xF) << 5) | ((MAC[3+len_a] & 0xF8) >> 2);
 			state->p25_trans_off[iden] = (MAC[3+len_a] << 6) | (MAC[4+len_a] >> 2);
 			state->p25_chan_spac[iden] = ((MAC[4+len_a] & 0x3) << 8) | MAC[5+len_a];
@@ -1038,6 +1243,7 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 		{
 			state->p25_chan_iden = MAC[2+len_a] >> 4;
 			int iden = state->p25_chan_iden;
+			state->p25_chan_tdma[iden] = 1;
 			state->p25_chan_type[iden] = MAC[2+len_a] & 0xF;
 			state->p25_trans_off[iden] = (MAC[3+len_a] << 6) | (MAC[4+len_a] >> 2);
 			state->p25_chan_spac[iden] = ((MAC[4+len_a] & 0x3) << 8) | MAC[5+len_a];
@@ -1053,6 +1259,7 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 		{
 			state->p25_chan_iden = MAC[3+len_a] >> 4;
 			int iden = state->p25_chan_iden;
+			state->p25_chan_tdma[iden] = 1;
 			state->p25_chan_type[iden] = MAC[3+len_a] & 0xF;
 			state->p25_trans_off[iden] = (MAC[4+len_a] << 6) | (MAC[5+len_a] >> 2);
 			state->p25_chan_spac[iden] = ((MAC[5+len_a] & 0x3) << 8) | MAC[6+len_a];
@@ -1079,7 +1286,7 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			{
 
 				fprintf (stderr, "\n Secondary Control Channel Broadcast - Explicit\n");
-				fprintf (stderr, "  RFSS[%03d] SITE ID [%03X] CHAN-T [%04X] CHAN-R [%04X] SSC [%02X]", rfssid, siteid, channelt, channelr, sysclass);
+				fprintf (stderr, "  RFSS [%03d] SITE ID [%03X] CHAN-T [%04X] CHAN-R [%04X] SSC [%02X]", rfssid, siteid, channelt, channelr, sysclass);
 
 				process_channel_to_freq (opts, state, channelt);
 				process_channel_to_freq (opts, state, channelr);
@@ -1223,7 +1430,25 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			int src = (MAC[5+len_a] << 16) | (MAC[6+len_a] << 8) | MAC[7+len_a];
 
 			fprintf (stderr, "\n VCH %d - TG %d SRC %d ", slot, gr, src);
-			fprintf (stderr, "Group Voice");
+
+			if (svc & 0x80) fprintf (stderr, " Emergency");
+			if (svc & 0x40) fprintf (stderr, " Encrypted");
+
+			if (opts->payload == 1) //hide behind payload due to len
+			{
+				if (svc & 0x20) fprintf (stderr, " Duplex");
+				if (svc & 0x10) fprintf (stderr, " Packet");
+				else fprintf (stderr, " Circuit");
+				if (svc & 0x8) fprintf (stderr, " R"); //reserved bit is on
+				fprintf (stderr, " Priority %d", svc & 0x7); //call priority
+			}
+
+			fprintf (stderr, " Group Voice");
+
+			sprintf (state->call_string[slot], "   Group ");
+			if (svc & 0x80) strcat (state->call_string[slot], " Emergency  ");
+			else if (svc & 0x40) strcat (state->call_string[slot], " Encrypted  ");
+			else strcat (state->call_string[slot], "            ");
 
 			if (slot == 0)
 			{
@@ -1244,7 +1469,25 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			int src = (MAC[6+len_a] << 16) | (MAC[7+len_a] << 8) | MAC[8+len_a];
 
 			fprintf (stderr, "\n VCH %d - TG %d SRC %d ", slot, gr, src);
-			fprintf (stderr, "Unit to Unit Voice");
+
+			if (svc & 0x80) fprintf (stderr, " Emergency");
+			if (svc & 0x40) fprintf (stderr, " Encrypted");
+
+			if (opts->payload == 1) //hide behind payload due to len
+			{
+				if (svc & 0x20) fprintf (stderr, " Duplex");
+				if (svc & 0x10) fprintf (stderr, " Packet");
+				else fprintf (stderr, " Circuit");
+				if (svc & 0x8) fprintf (stderr, " R"); //reserved bit is on
+				fprintf (stderr, " Priority %d", svc & 0x7); //call priority
+			}
+
+			fprintf (stderr, " Unit to Unit Voice");
+
+			sprintf (state->call_string[slot], " Private ");
+			if (svc & 0x80) strcat (state->call_string[slot], " Emergency  ");
+			else if (svc & 0x40) strcat (state->call_string[slot], " Encrypted  ");
+			else strcat (state->call_string[slot], "            ");
 
 			if (slot == 0)
 			{
@@ -1300,7 +1543,7 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			int lcolorcode = ((MAC[12+len_a] & 0xF) << 8) | MAC[13+len_a];
 			fprintf (stderr, "\n Network Status Broadcast - Extended \n");
 			fprintf (stderr, "  LRA [%02X] WACN [%05X] SYSID [%03X] NAC [%03X] CHAN-T [%04X] CHAN-R [%04X]", lra, lwacn, lsysid, lcolorcode, channelt, channelr);
-			process_channel_to_freq (opts, state, channelt);
+			state->p25_cc_freq = process_channel_to_freq (opts, state, channelt);
 			process_channel_to_freq (opts, state, channelr);
 			state->p25_cc_is_tdma = 1; //flag on for CC tuning purposes when system is qpsk
 			if (state->p2_hardset == 0 ) //state->p2_is_lcch == 1 shim until CRC is working, prevent bogus data
@@ -1316,17 +1559,21 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 		if (MAC[1+len_a] == 0x7C) 
 		{
 			int lra = MAC[2+len_a];
+			int cfva = MAC[3+len_a] >> 4;
 			int lsysid = ((MAC[3+len_a] & 0xF) << 8) | MAC[4+len_a];
 			int rfssid = MAC[5+len_a];
 			int siteid = MAC[6+len_a];
 			int channelt = (MAC[7+len_a] << 8) | MAC[8+len_a];
 			int sysclass = MAC[9+len_a];
-			if (1 == 1) //state->p2_is_lcch == 1
-			{
-				fprintf (stderr, "\n Adjacent Status Broadcast - Abbreviated\n");
-				fprintf (stderr, "  LRA [%02X] RFSS[%03d] SYSID [%03X] SITE [%03X] CHAN-T [%04X] SSC [%02X]", lra, rfssid, lsysid, siteid, channelt, sysclass);
-				process_channel_to_freq (opts, state, channelt);
-			}
+			fprintf (stderr, "\n Adjacent Status Broadcast - Abbreviated\n");
+			fprintf (stderr, "  LRA [%02X] RFSS[%03d] SYSID [%03X] SITE [%03X] CHAN-T [%04X] SSC [%02X]\n  ", lra, rfssid, lsysid, siteid, channelt, sysclass);
+			if (cfva & 0x8) fprintf (stderr, " Conventional");
+			if (cfva & 0x4) fprintf (stderr, " Failure Condition");
+			if (cfva & 0x2) fprintf (stderr, " Up to Date (Correct)");
+			else fprintf (stderr, " Last Known");
+			if (cfva & 0x1) fprintf (stderr, " Valid RFSS Connection Active");
+			process_channel_to_freq (opts, state, channelt);
+
 
 		}
 
@@ -1334,19 +1581,23 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 		if (MAC[1+len_a] == 0xFC) 
 		{
 			int lra = MAC[2+len_a];
+			int cfva = MAC[3+len_a] >> 4; 
 			int lsysid = ((MAC[3+len_a] & 0xF) << 8) | MAC[4+len_a];
 			int rfssid = MAC[5+len_a];
 			int siteid = MAC[6+len_a];
 			int channelt = (MAC[7+len_a] << 8) | MAC[8+len_a];
 			int channelr = (MAC[9+len_a] << 8) | MAC[10+len_a];
-			int sysclass = MAC[9+len_a];
-			if (1 == 1) //state->p2_is_lcch == 1
-			{
-				fprintf (stderr, "\n Adjacent Status Broadcast - Extended\n");
-				fprintf (stderr, "  LRA [%02X] RFSS[%03d] SYSID [%03X] SITE [%03X] CHAN-T [%04X] CHAN-R [%04X] SSC [%02X]", lra, rfssid, lsysid, siteid, channelt, channelr, sysclass);
-				process_channel_to_freq (opts, state, channelt);
-				process_channel_to_freq (opts, state, channelr);
-			}
+			int sysclass = MAC[11+len_a];  //need to re-check this 
+			fprintf (stderr, "\n Adjacent Status Broadcast - Extended\n");
+			fprintf (stderr, "  LRA [%02X] RFSS[%03d] SYSID [%03X] SITE [%03X] CHAN-T [%04X] CHAN-R [%04X] SSC [%02X]\n  ", lra, rfssid, lsysid, siteid, channelt, channelr, sysclass);
+			if (cfva & 0x8) fprintf (stderr, " Conventional");
+			if (cfva & 0x4) fprintf (stderr, " Failure Condition");
+			if (cfva & 0x2) fprintf (stderr, " Up to Date (Correct)");
+			else fprintf (stderr, " Last Known");
+			if (cfva & 0x1) fprintf (stderr, " Valid RFSS Connection Active");
+			process_channel_to_freq (opts, state, channelt);
+			process_channel_to_freq (opts, state, channelr);
+
 
 		}
 

src/p25p2_xcch.c

@@ -13,6 +13,9 @@ void process_SACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[180]
 	//Figure out which PDU we are looking at, see above info on 8.4.1
 	//reorganize bits into bytes and process accordingly
 
+	//new slot variable with flipped assignment for SACCH
+	uint8_t slot = (state->currentslot ^ 1) & 1;
+
 	unsigned long long int SMAC[24] = {0}; //22.5 bytes for SACCH MAC PDUs
 	int byte = 0;
 	int k = 0;
@@ -117,6 +120,7 @@ void process_SACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[180]
 		{
 			//reset fourv_counter and dropbyte on PTT
 			state->fourv_counter[0] = 0;
+			state->dropL = 256;
 
 			state->dmrburstL = 20;
 			fprintf (stderr, "\n VCH 0 - ");
@@ -139,6 +143,7 @@ void process_SACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[180]
 				fprintf (stderr, "\n         ALG ID 0x%02X", state->payload_algid);
 				fprintf (stderr, " KEY ID 0x%04X", state->payload_keyid);
 				fprintf (stderr, " MI 0x%016llX", state->payload_miP);
+				if (state->R != 0 && state->payload_algid == 0xAA) fprintf (stderr, " Key 0x%010llX", state->R);
 				fprintf(stderr, " MPTT");
 				// fprintf (stderr, " %s", KRED);
 				// fprintf (stderr, "ENC");
@@ -150,6 +155,7 @@ void process_SACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[180]
 		{
 			//reset fourv_counter and dropbyte on PTT
 			state->fourv_counter[1] = 0;
+			state->dropR = 256;
 			state->payload_algidR = 0; //zero this out as well
 
 			state->dmrburstR = 20;
@@ -173,6 +179,7 @@ void process_SACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[180]
 				fprintf (stderr, "\n         ALG ID 0x%02X", state->payload_algidR);
 				fprintf (stderr, " KEY ID 0x%04X", state->payload_keyidR);
 				fprintf (stderr, " MI 0x%016llX", state->payload_miN);
+				if (state->RR != 0 && state->payload_algidR == 0xAA) fprintf (stderr, " Key 0x%010llX", state->RR);
 				fprintf(stderr, " MPTT");
 				// fprintf (stderr, " %s", KRED);
 				// fprintf (stderr, "ENC");
@@ -191,6 +198,7 @@ void process_SACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[180]
 		{
 			
 			state->fourv_counter[0] = 0;
+			state->dropL = 256;
 			state->dmrburstL = 23;
 			state->payload_algid = 0; 
 			state->payload_keyid = 0; 
@@ -206,11 +214,15 @@ void process_SACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[180]
 			//close any open MBEout files
  			if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state);
 
+			//blank the call string here -- slot variable is already flipped accordingly for sacch
+			sprintf (state->call_string[slot], "%s", "                     "); //21 spaces
+
 		}
 		if (state->currentslot == 0)
 		{
 			
 			state->fourv_counter[1] = 0;
+			state->dropR = 256;
 			state->dmrburstR = 23;
 			state->payload_algidR = 0;
 			state->payload_keyidR	= 0;
@@ -236,12 +248,25 @@ void process_SACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[180]
 		fprintf (stderr, "%s", KYEL);
 		process_MAC_VPDU(opts, state, 1, SMAC);
 		fprintf (stderr, "%s", KNRM);
+
+		//blank the call string here -- slot variable is already flipped accordingly for sacch
+		sprintf (state->call_string[slot], "%s", "                     "); //21 spaces
+
 	}
 	if (opcode == 0x4 && err == 0)
 	{
 		//disable to prevent blinking in ncurses terminal due to OSS preemption shim
-		//if (state->currentslot == 1) state->dmrburstL = 21;
-		//else state->dmrburstR = 21;
+		#ifdef AERO_BUILD
+		if (opts->audio_out_type != 5)
+		{
+			if (state->currentslot == 1) state->dmrburstL = 21;
+			else state->dmrburstR = 21;
+		}
+		#else
+		if (state->currentslot == 1) state->dmrburstL = 21;
+		else state->dmrburstR = 21;
+		#endif
+		
 		fprintf (stderr, " MAC_ACTIVE ");
 		fprintf (stderr, "%s", KYEL);
 		process_MAC_VPDU(opts, state, 1, SMAC);
@@ -251,13 +276,13 @@ void process_SACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[180]
 	{
 		if (state->currentslot == 1)
 		{
-			state->dmrburstL = 21;
+			state->dmrburstL = 22;
 			//close any open MBEout files
  			if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state);
 		} 
 		else
 		{
-			state->dmrburstR = 21;
+			state->dmrburstR = 22;
 			//close any open MBEout files
  			if (opts->mbe_out_fR != NULL) closeMbeOutFileR (opts, state);
 		}
@@ -280,6 +305,9 @@ void process_FACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[156]
 	//Figure out which PDU we are looking at, see above info on 8.4.1
 	//reorganize bits into bytes and process accordingly
 
+	//new slot variable
+	uint8_t slot = state->currentslot;
+
 	unsigned long long int FMAC[24] = {0}; //19.5 bytes for FACCH MAC PDUs, add padding to end
 	int byte = 0;
 	int k = 0;
@@ -347,6 +375,7 @@ void process_FACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[156]
 		{
 			//reset fourv_counter and dropbyte on PTT
 			state->fourv_counter[0] = 0;
+			state->dropL = 256;
 
 			state->dmrburstL = 20;
 			fprintf (stderr, "\n VCH 0 - ");
@@ -369,6 +398,7 @@ void process_FACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[156]
 				fprintf (stderr, "\n         ALG ID 0x%02X", state->payload_algid);
 				fprintf (stderr, " KEY ID 0x%04X", state->payload_keyid);
 				fprintf (stderr, " MI 0x%016llX", state->payload_miP);
+				if (state->R != 0 && state->payload_algid == 0xAA) fprintf (stderr, " Key 0x%010llX", state->R);
 				fprintf(stderr, " MPTT");
 				// fprintf (stderr, " %s", KRED);
 				// fprintf (stderr, "ENC");
@@ -380,6 +410,7 @@ void process_FACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[156]
 		{
 			//reset fourv_counter and dropbyte on PTT
 			state->fourv_counter[1] = 0;
+			state->dropR = 256;
 
 			state->dmrburstR = 20;
 			fprintf (stderr, "\n VCH 1 - ");
@@ -402,6 +433,7 @@ void process_FACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[156]
 				fprintf (stderr, "\n         ALG ID 0x%02X", state->payload_algidR);
 				fprintf (stderr, " KEY ID 0x%04X", state->payload_keyidR);
 				fprintf (stderr, " MI 0x%016llX", state->payload_miN);
+				if (state->RR != 0 && state->payload_algidR == 0xAA) fprintf (stderr, " Key 0x%010llX", state->RR);
 				fprintf(stderr, " MPTT");
 				// fprintf (stderr, " %s", KRED);
 				// fprintf (stderr, "ENC");
@@ -419,6 +451,7 @@ void process_FACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[156]
 		{
 			
 			state->fourv_counter[0] = 0;
+			state->dropL = 256;
 			state->dmrburstL = 23;
 			state->payload_algid = 0; //zero this out as well
 			state->payload_keyid = 0;
@@ -433,12 +466,16 @@ void process_FACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[156]
 
 			//close any open MBEout files
  			if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state);
+
+			//blank the call string here 
+			sprintf (state->call_string[slot], "%s", "                     "); //21 spaces
 			
 		}
 		if (state->currentslot == 1)
 		{
 			
 			state->fourv_counter[1] = 0;
+			state->dropR = 256;
 			state->dmrburstR = 23;
 			state->payload_algidR = 0; //zero this out as well
 			state->payload_keyidR = 0;
@@ -484,12 +521,25 @@ void process_FACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[156]
 		fprintf (stderr, "%s", KYEL);
 		process_MAC_VPDU(opts, state, 0, FMAC);
 		fprintf (stderr, "%s", KNRM);
+
+		//blank the call string here 
+		sprintf (state->call_string[slot], "%s", "                     "); //21 spaces
+			
 	}
 	if (opcode == 0x4 && err == 0)
 	{
 		//disable to prevent blinking in ncurses terminal due to OSS preemption shim
-		//if (state->currentslot == 0) state->dmrburstL = 21;
-		//else state->dmrburstR = 21;
+		#ifdef AERO_BUILD
+		if (opts->audio_out_type != 5)
+		{
+			if (state->currentslot == 0) state->dmrburstL = 21;
+			else state->dmrburstR = 21;
+		}
+		#else
+		if (state->currentslot == 0) state->dmrburstL = 21;
+		else state->dmrburstR = 21;
+		#endif
+		
 		fprintf (stderr, " MAC_ACTIVE ");
 		fprintf (stderr, "%s", KYEL);
 		process_MAC_VPDU(opts, state, 0, FMAC);

src/provoice.c

@@ -1,584 +1,432 @@
 #include "dsd.h"
 #include "provoice_const.h"
 
-void
-processProVoice (dsd_opts * opts, dsd_state * state)
+// #define PVDEBUG
+
+void processProVoice (dsd_opts * opts, dsd_state * state)
 {
-  int i, j, dibit, k;
-  uint8_t lid[80];
-  uint8_t lidbyte[10];
-  uint8_t init[64];
-  uint8_t initbyte[8];
+  int i, j, dibit;
   char imbe7100_fr1[7][24];
   char imbe7100_fr2[7][24];
   const int *w, *x;
 
+  //raw bits storage for analysis
+  uint8_t raw_bits[800];
+  memset (raw_bits, 0, sizeof(raw_bits)); 
+  //raw bytes storage for analysis
+  uint8_t raw_bytes[100];
+  memset (raw_bytes, 0, sizeof(raw_bytes));
+
+  unsigned long long int initial = 0; //initial 64-bits before the lid
+  uint16_t lid = 0;     //lid value 16-bit
+  unsigned long long int secondary = 0; //secondary 64-bits after lid, before voice
+
+  uint8_t spacer_bit[8]; //check this value to see if its a status thing (like P25 P1)
+  memset (spacer_bit, 0, sizeof (spacer_bit));
+  uint8_t spacer = 0;
+  uint16_t bf = 0; //the 16-bit value in-between imbe 2 and imbe 3 that is usually 2175
+
   fprintf (stderr," VOICE");
-  if (opts->p25_trunk == 1 && opts->p25_is_tuned == 1)
+
+  //print group and source values if EA trunked
+  if (opts->p25_trunk == 1 && opts->p25_is_tuned == 1 && state->ea_mode == 1)
   {
     fprintf (stderr, "%s", KGRN);
-    fprintf (stderr, " Site [%02llX][%03lld] Group [%05d] Source [%08d] LCN[%02d] ", 
-              state->edacs_site_id, state->edacs_site_id, state->lasttg, state->lastsrc, state->edacs_tuned_lcn);
+    fprintf (stderr, " Site: %lld Group: %d Source: %d LCN: %d ", 
+              state->edacs_site_id, state->lasttg, state->lastsrc, state->edacs_tuned_lcn);
+    fprintf (stderr, "%s", KNRM);
+  }
+  //print afs value if standard/networked trunked
+  else if (opts->p25_trunk == 1 && opts->p25_is_tuned == 1 && state->ea_mode == 0)
+  {
+    fprintf (stderr, "%s", KGRN);
+    fprintf (stderr, " Site: %lld AFS: %d-%d LCN: %d ", 
+              state->edacs_site_id, (state->lasttg >> 7) & 0xF, state->lasttg & 0x7F, state->edacs_tuned_lcn);
     fprintf (stderr, "%s", KNRM);
   }
 
-  for (i = 0; i < 64; i++)
-    {
-      dibit = getDibit (opts, state);
-      init[i] = dibit;
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"%i", dibit);
-#endif
-    }
-#ifdef PROVOICE_DUMP
-  fprintf (stderr," ");
-#endif
-  //iNitial 64 bits
+  //load all initial bits before voice into raw_bits array for analysis/handling
+  for (i = 0; i < 64+16+64; i++)
+    raw_bits[i] = getDibit (opts, state);
+
+  //Note: the initial 144-bits seem to be provisioned differently depending on system type
+  initial = (unsigned long long int)ConvertBitIntoBytes(&raw_bits[0], 64);
+  lid = (uint16_t)ConvertBitIntoBytes(&raw_bits[64], 16);
+  secondary = (unsigned long long int)ConvertBitIntoBytes(&raw_bits[80], 64);
   if (opts->payload == 1)
   {
-    k = 0;
-    fprintf (stderr, "\n N64: ");
-    for(i = 0; i < 8; i++)
-    {
-      initbyte[i] = 0;
-      for (j = 0; j < 8; j++)
-      {
-        initbyte[i] = initbyte[i] << 1;
-        initbyte[i] = initbyte[i] | init[k];
-        k++;
-      }
-      fprintf (stderr, "%02X", initbyte[i]);
-      if (i == 3) fprintf (stderr, "-");
-    }
-    fprintf (stderr, "\n");
+    fprintf (stderr, "\n N64: %016llX", initial);
+    fprintf (stderr, "\n LID: %04X", lid);
+    fprintf (stderr, " %016llX", secondary);
   }
-  // lid
-  for (i = 0; i < 16; i++)
-    {
-      dibit = getDibit (opts, state);
-      lid[i] = dibit;
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"%i", dibit);
-#endif
-    }
-#ifdef PROVOICE_DUMP
-  fprintf (stderr," ");
-#endif
-
-  for (i = 0; i < 64; i++)
-    {
-      dibit = getDibit (opts, state);
-      lid[i+16] = dibit;
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"%i", dibit);
-#endif
-    }
-#ifdef PROVOICE_DUMP
-  fprintf (stderr," ");
-#endif
-  //load lid (bits) into lidbyte
-  if (opts->payload == 1)
-  {
-    k = 0;
-    fprintf (stderr, " LID: ");
-    for(i = 0; i < 10; i++)
-    {
-      lidbyte[i] = 0;
-      for (j = 0; j < 8; j++)
-      {
-        lidbyte[i] = lidbyte[i] << 1;
-        lidbyte[i] = lidbyte[i] | lid[k];
-        k++;
-      }
-      fprintf (stderr, "%02X", lidbyte[i]);
-      if (i == 3 || i == 7) fprintf (stderr, "-");
-    }
-    // fprintf (stderr, "\n");
-  }
-
 
   // imbe frames 1,2 first half
   w = pW;
   x = pX;
 
   for (i = 0; i < 11; i++)
-    {
-      for (j = 0; j < 6; j++)
-        {
-          dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-          //fprintf (stderr,"%i", dibit);
-#endif
-          imbe7100_fr1[*w][*x] = dibit;
-          w++;
-          x++;
-        }
-#ifdef PROVOICE_DUMP
-      //fprintf (stderr,"_");
-#endif
-      w -= 6;
-      x -= 6;
-      for (j = 0; j < 6; j++)
-        {
-          dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-          fprintf (stderr,"%i", dibit);
-#endif
-          imbe7100_fr2[*w][*x] = dibit;
-          w++;
-          x++;
-        }
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"_");
-#endif
-    }
-
-  for (j = 0; j < 6; j++)
+  {
+    for (j = 0; j < 6; j++)
     {
       dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"%i", dibit);
-#endif
       imbe7100_fr1[*w][*x] = dibit;
       w++;
       x++;
+      raw_bits[144+j+(i*12)] = dibit;
     }
-#ifdef PROVOICE_DUMP
-  fprintf (stderr,"_");
-#endif
+
+    w -= 6;
+    x -= 6;
+    for (j = 0; j < 6; j++)
+    {
+      dibit = getDibit (opts, state);
+      imbe7100_fr2[*w][*x] = dibit;
+      w++;
+      x++;
+      raw_bits[150+j+(i*12)] = dibit;
+    }
+
+  }
+
+  for (j = 0; j < 6; j++)
+  {
+    dibit = getDibit (opts, state);
+    imbe7100_fr1[*w][*x] = dibit;
+    w++;
+    x++;
+    raw_bits[j+282] = dibit;
+  }
+
   w -= 6;
   x -= 6;
   for (j = 0; j < 4; j++)
-    {
-      dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"%i", dibit);
-#endif
-      imbe7100_fr2[*w][*x] = dibit;
-      w++;
-      x++;
-    }
-#ifdef PROVOICE_DUMP
-  fprintf (stderr," ");
-#endif
+  {
+    dibit = getDibit (opts, state);
+    imbe7100_fr2[*w][*x] = dibit;
+    w++;
+    x++;
+    raw_bits[j+288] = dibit;
+  }
 
   // spacer bits
   dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-  fprintf (stderr,"%i", dibit);
-#endif
+  spacer_bit[0] = dibit;
+  raw_bits[292] = dibit;
+
   dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-  fprintf (stderr,"%i", dibit);
-  fprintf (stderr," ");
-#endif
+  spacer_bit[1] = dibit;
+  raw_bits[293] = dibit;
 
   // imbe frames 1,2 second half
-
   for (j = 0; j < 2; j++)
-    {
-      dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"%i", dibit);
-#endif
-      imbe7100_fr2[*w][*x] = dibit;
-      w++;
-      x++;
-    }
-#ifdef PROVOICE_DUMP
-  fprintf (stderr,"_");
-#endif
+  {
+    dibit = getDibit (opts, state);
+    imbe7100_fr2[*w][*x] = dibit;
+    w++;
+    x++;
+    raw_bits[j+294] = dibit;
+  }
 
   for (i = 0; i < 3; i++)
-    {
-      for (j = 0; j < 6; j++)
-        {
-          dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-          fprintf (stderr,"%i", dibit);
-#endif
-          imbe7100_fr1[*w][*x] = dibit;
-          w++;
-          x++;
-        }
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"_");
-#endif
-      w -= 6;
-      x -= 6;
-      for (j = 0; j < 6; j++)
-        {
-          dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-          fprintf (stderr,"%i", dibit);
-#endif
-          imbe7100_fr2[*w][*x] = dibit;
-          w++;
-          x++;
-        }
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"_");
-#endif
-    }
-
-  for (j = 0; j < 5; j++)
+  {
+    for (j = 0; j < 6; j++)
     {
       dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"%i", dibit);
-#endif
       imbe7100_fr1[*w][*x] = dibit;
       w++;
       x++;
+      raw_bits[296+j+(i*12)] = dibit;
     }
-#ifdef PROVOICE_DUMP
-  fprintf (stderr,"_");
-#endif
-  w -= 5;
-  x -= 5;
-  for (j = 0; j < 5; j++)
+    w -= 6;
+    x -= 6;
+    for (j = 0; j < 6; j++)
     {
       dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"%i", dibit);
-#endif
       imbe7100_fr2[*w][*x] = dibit;
       w++;
       x++;
+      raw_bits[302+j+(i*12)] = dibit;
     }
-#ifdef PROVOICE_DUMP
-  fprintf (stderr,"_");
-#endif
+  }
+
+  for (j = 0; j < 5; j++)
+  {
+    dibit = getDibit (opts, state);
+    imbe7100_fr1[*w][*x] = dibit;
+    w++;
+    x++;
+    raw_bits[j+338] = dibit;
+  }
+
+  w -= 5;
+  x -= 5;
+  for (j = 0; j < 5; j++)
+  {
+    dibit = getDibit (opts, state);
+    imbe7100_fr2[*w][*x] = dibit;
+    w++;
+    x++;
+    raw_bits[j+343] = dibit;
+  }
 
   for (i = 0; i < 7; i++)
-    {
-      for (j = 0; j < 6; j++)
-        {
-          dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-          //fprintf (stderr,"%i", dibit);
-#endif
-          imbe7100_fr1[*w][*x] = dibit;
-          w++;
-          x++;
-        }
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"_");
-#endif
-      w -= 6;
-      x -= 6;
-      for (j = 0; j < 6; j++)
-        {
-          dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-          fprintf (stderr,"%i", dibit);
-#endif
-          imbe7100_fr2[*w][*x] = dibit;
-          w++;
-          x++;
-        }
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"_");
-#endif
-    }
-
-  for (j = 0; j < 5; j++)
+  {
+    for (j = 0; j < 6; j++)
     {
       dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"%i", dibit);
-#endif
       imbe7100_fr1[*w][*x] = dibit;
       w++;
       x++;
+      raw_bits[348+j+(i*12)] = dibit;
     }
-#ifdef PROVOICE_DUMP
-  fprintf (stderr,"_");
-#endif
-  w -= 5;
-  x -= 5;
-  for (j = 0; j < 5; j++)
+
+    w -= 6;
+    x -= 6;
+    for (j = 0; j < 6; j++)
     {
       dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"%i", dibit);
-#endif
       imbe7100_fr2[*w][*x] = dibit;
       w++;
       x++;
+      raw_bits[354+j+(i*12)] = dibit;
     }
-#ifdef PROVOICE_DUMP
-  fprintf (stderr," ");
-#endif
+
+  }
+
+  for (j = 0; j < 5; j++)
+  {
+    dibit = getDibit (opts, state);
+    imbe7100_fr1[*w][*x] = dibit;
+    w++;
+    x++;
+    raw_bits[j+438] = dibit;
+  }
+  w -= 5;
+  x -= 5;
+
+  for (j = 0; j < 5; j++)
+  {
+    dibit = getDibit (opts, state);
+    imbe7100_fr2[*w][*x] = dibit;
+    w++;
+    x++;
+    raw_bits[j+443] = dibit;
+  }
 
   processMbeFrame (opts, state, NULL, NULL, imbe7100_fr1);
   processMbeFrame (opts, state, NULL, NULL, imbe7100_fr2);
 
   // spacer bits
   dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-  fprintf (stderr,"%i", dibit);
-#endif
+  spacer_bit[2] = dibit;
+  raw_bits[448] = dibit;
+
   dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-  fprintf (stderr,"%i", dibit);
-  fprintf (stderr," ");
-#endif
+  spacer_bit[3] = dibit; 
+  raw_bits[449] = dibit;
+
+  //resume raw_bits at +6 current value to round out payload bytes
+  //easier to visualize patterns
 
   for (i = 0; i < 16; i++)
-    {
-      dibit = getDibit (opts, state); //HERE
-      init[i] = dibit; //recycle
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"%i", dibit);
-#endif
-    }
-#ifdef PROVOICE_DUMP
-  fprintf (stderr," ");
-#endif
-if (opts->payload == 1)
-{
-  k = 0;
-  fprintf (stderr, "\n 16B: ");
-  for(i = 0; i < 2; i++)
-  {
-    initbyte[i] = 0;
-    for (j = 0; j < 8; j++)
-    {
-      initbyte[i] = initbyte[i] << 1;
-      initbyte[i] = initbyte[i] | init[k];
-      k++;
-    }
-    fprintf (stderr, "%02X", initbyte[i]);
-  }
-  // fprintf (stderr, "\n");
-}
+    raw_bits[i+450+6] = getDibit (opts, state); 
+
+  bf = (uint16_t)ConvertBitIntoBytes(&raw_bits[456], 16);
+
+  if (opts->payload == 1)
+    fprintf (stderr, "\n BF: %04X ", bf);
+
   // imbe frames 3,4 first half
   w = pW;
   x = pX;
   for (i = 0; i < 11; i++)
-    {
-      for (j = 0; j < 6; j++)
-        {
-          dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-          fprintf (stderr,"%i", dibit);
-#endif
-          imbe7100_fr1[*w][*x] = dibit;
-          w++;
-          x++;
-        }
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"_");
-#endif
-      w -= 6;
-      x -= 6;
-      for (j = 0; j < 6; j++)
-        {
-          dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-          fprintf (stderr,"%i", dibit);
-#endif
-          imbe7100_fr2[*w][*x] = dibit;
-          w++;
-          x++;
-        }
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"_");
-#endif
-    }
-  for (j = 0; j < 6; j++)
+  {
+    for (j = 0; j < 6; j++)
     {
       dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"%i", dibit);
-#endif
       imbe7100_fr1[*w][*x] = dibit;
       w++;
       x++;
+      raw_bits[6+466+j+(i*12)] = dibit;
     }
-#ifdef PROVOICE_DUMP
-  fprintf (stderr,"_");
-#endif
+
+    w -= 6;
+    x -= 6;
+    for (j = 0; j < 6; j++)
+    {
+      dibit = getDibit (opts, state);
+      imbe7100_fr2[*w][*x] = dibit;
+      w++;
+      x++;
+      raw_bits[6+472+j+(i*12)] = dibit;
+    }
+  }
+
+  for (j = 0; j < 6; j++)
+  {
+    dibit = getDibit (opts, state);
+    imbe7100_fr1[*w][*x] = dibit;
+    w++;
+    x++;
+    raw_bits[j+604+6] = dibit;
+  }
+
   w -= 6;
   x -= 6;
   for (j = 0; j < 4; j++)
-    {
-      dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-      fprintf (stderr,"%i", dibit);
-#endif
-      imbe7100_fr2[*w][*x] = dibit;
-      w++;
-      x++;
-    }
-#ifdef PROVOICE_DUMP
-  fprintf (stderr," ");
-#endif
+  {
+    dibit = getDibit (opts, state);
+    imbe7100_fr2[*w][*x] = dibit;
+    w++;
+    x++;
+    raw_bits[i+610+6] = dibit; 
+  }
 
   // spacer bits
   dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-  //fprintf (stderr,"%i", dibit);
-#endif
+  spacer_bit[4];
+  raw_bits[614+2] = dibit;
+
   dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-  //fprintf (stderr,"%i", dibit);
-  //fprintf (stderr,"_");
-#endif
+  spacer_bit[5];
+  raw_bits[615+2] = dibit;
 
   // imbe frames 3,4 second half
   for (j = 0; j < 2; j++)
-    {
-      dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-      //fprintf (stderr,"%i", dibit);
-#endif
-      imbe7100_fr2[*w][*x] = dibit;
-      w++;
-      x++;
-    }
-#ifdef PROVOICE_DUMP
-  //fprintf (stderr,"_");
-#endif
+  {
+    dibit = getDibit (opts, state);
+    imbe7100_fr2[*w][*x] = dibit;
+    w++;
+    x++;
+    raw_bits[j+616+6] = dibit;
+  }
   for (i = 0; i < 3; i++)
-    {
-      for (j = 0; j < 6; j++)
-        {
-          dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-          //fprintf (stderr,"%i", dibit);
-#endif
-          imbe7100_fr1[*w][*x] = dibit;
-          w++;
-          x++;
-        }
-#ifdef PROVOICE_DUMP
-      //fprintf (stderr,"_");
-#endif
-      w -= 6;
-      x -= 6;
-      for (j = 0; j < 6; j++)
-        {
-          dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-          //fprintf (stderr,"%i", dibit);
-#endif
-          imbe7100_fr2[*w][*x] = dibit;
-          w++;
-          x++;
-        }
-#ifdef PROVOICE_DUMP
-      //fprintf (stderr,"_");
-#endif
-    }
-
-  for (j = 0; j < 5; j++)
+  {
+    for (j = 0; j < 6; j++)
     {
       dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-      //fprintf (stderr,"%i", dibit);
-#endif
       imbe7100_fr1[*w][*x] = dibit;
       w++;
       x++;
+      raw_bits[6+618+j+(i*12)] = dibit;
     }
-#ifdef PROVOICE_DUMP
-  //fprintf (stderr,"_");
-#endif
-  w -= 5;
-  x -= 5;
-  for (j = 0; j < 5; j++)
+    w -= 6;
+    x -= 6;
+    for (j = 0; j < 6; j++)
     {
       dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-      //fprintf (stderr,"%i", dibit);
-#endif
       imbe7100_fr2[*w][*x] = dibit;
       w++;
       x++;
+      raw_bits[6+624+j+(i*12)] = dibit;
     }
-#ifdef PROVOICE_DUMP
-  //fprintf (stderr," ");
-#endif
+  }
+
+  for (j = 0; j < 5; j++)
+  {
+    dibit = getDibit (opts, state);
+    imbe7100_fr1[*w][*x] = dibit;
+    w++;
+    x++;
+    raw_bits[j+660+6] = dibit;
+  }
+  w -= 5;
+  x -= 5;
+  for (j = 0; j < 5; j++)
+  {
+    dibit = getDibit (opts, state);
+    imbe7100_fr2[*w][*x] = dibit;
+    w++;
+    x++;
+    raw_bits[j+665+6] = dibit;
+  }
 
   for (i = 0; i < 7; i++)
-    {
-      for (j = 0; j < 6; j++)
-        {
-          dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-          //fprintf (stderr,"%i", dibit);
-#endif
-          imbe7100_fr1[*w][*x] = dibit;
-          w++;
-          x++;
-        }
-#ifdef PROVOICE_DUMP
-      //fprintf (stderr,"_");
-#endif
-      w -= 6;
-      x -= 6;
-      for (j = 0; j < 6; j++)
-        {
-          dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-          //fprintf (stderr,"%i", dibit);
-#endif
-          imbe7100_fr2[*w][*x] = dibit;
-          w++;
-          x++;
-        }
-#ifdef PROVOICE_DUMP
-      //fprintf (stderr,"_");
-#endif
-    }
-
-  for (j = 0; j < 5; j++)
+  {
+    for (j = 0; j < 6; j++)
     {
       dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-      //fprintf (stderr,"%i", dibit);
-#endif
       imbe7100_fr1[*w][*x] = dibit;
       w++;
       x++;
+      raw_bits[6+670+j+(i*12)] = dibit;
     }
-#ifdef PROVOICE_DUMP
-  //fprintf (stderr,"_");
-#endif
-  w -= 5;
-  x -= 5;
-  for (j = 0; j < 5; j++)
+    w -= 6;
+    x -= 6;
+    for (j = 0; j < 6; j++)
     {
       dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-      //fprintf (stderr,"%i", dibit);
-#endif
       imbe7100_fr2[*w][*x] = dibit;
       w++;
       x++;
+      raw_bits[6+676+j+(i*12)] = dibit;
     }
-#ifdef PROVOICE_DUMP
-  //fprintf (stderr," ");
-#endif
+  }
+
+  for (j = 0; j < 5; j++)
+  {
+    dibit = getDibit (opts, state);
+    imbe7100_fr1[*w][*x] = dibit;
+    w++;
+    x++;
+    raw_bits[j+760+6] = dibit;
+  }
+
+  w -= 5;
+  x -= 5;
+  for (j = 0; j < 5; j++)
+  {
+    dibit = getDibit (opts, state);
+    imbe7100_fr2[*w][*x] = dibit;
+    w++;
+    x++;
+    raw_bits[j+765+6] = dibit;
+  }
 
   processMbeFrame (opts, state, NULL, NULL, imbe7100_fr1);
   processMbeFrame (opts, state, NULL, NULL, imbe7100_fr2);
 
   // spacer bits
   dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-  //fprintf (stderr,"%i", dibit);
-#endif
+  spacer_bit[6] = dibit;
+  raw_bits[782] = dibit;
+
   dibit = getDibit (opts, state);
-#ifdef PROVOICE_DUMP
-  //fprintf (stderr,"%i", dibit);
-  //fprintf (stderr," ");
+  spacer_bit[7] = dibit;
+  raw_bits[783] = dibit;
+
+#ifdef PVDEBUG
+
+  spacer = (uint8_t)ConvertBitIntoBytes(&spacer_bit[0], 8);
+  if (opts->payload == 1)
+    fprintf (stderr, "\n SP: %X", spacer);
+
+  //convert raw bits into raw bytes for payload analysis
+  for (j = 0; j < 98; j++)
+  {
+    raw_bytes[j] = (uint8_t)ConvertBitIntoBytes(&raw_bits[(j*8)], 8);
+  }
+
+  //payload on all raw bytes for analysis...its a lot of 'em
+  if (opts->payload == 1) //find better thingy later or change this
+  // if (opcode != 0x3333)
+  {
+    fprintf (stderr, "%s", KCYN);
+    fprintf (stderr, "\n pV Payload Dump: \n  ");
+    for (j = 0; j < 98; j++)
+    {
+      fprintf (stderr, "[%02X]", raw_bytes[j]);
+      if (j == 17 || j == 35 || j == 53 || j == 71 || j == 89)
+      {
+        fprintf (stderr, "\n  ");
+      }
+    }
+    fprintf (stderr, "%s", KNRM);
+  }
+
 #endif
 
-  if (opts->errorbars == 1)
-    {
-      fprintf (stderr,"\n");
-    }
+  //line break at end of frame
+  fprintf (stderr,"\n");
+
 }

src/rtl_sdr_fm.cpp

@@ -31,12 +31,12 @@
 #include <rtl-sdr.h>
 #include "dsd.h"
 
-//#define DEFAULT_SAMPLE_RATE		48000 //moved to opts->rtl_bandwidth
+#define DEFAULT_SAMPLE_RATE		48000
 #define DEFAULT_BUF_LENGTH		(1 * 16384)
-#define MAXIMUM_OVERSAMPLE		16 //16
+#define MAXIMUM_OVERSAMPLE		16
 #define MAXIMUM_BUF_LENGTH		(MAXIMUM_OVERSAMPLE * DEFAULT_BUF_LENGTH)
 #define AUTO_GAIN			-100
-#define BUFFER_DUMP			4096
+#define BUFFER_DUMP		4096
 
 #define FREQUENCIES_LIMIT		  1000
 
@@ -46,7 +46,8 @@ static int ACTUAL_BUF_LENGTH;
 static int *atan_lut = NULL;
 static int atan_lut_size = 131072; /* 512 KB */
 static int atan_lut_coef = 8;
-//new for UDP
+
+//UDP -- keep for compatibility reasons
 #include <netinet/in.h>
 #include <arpa/inet.h>
 static pthread_t socket_freq;
@@ -57,7 +58,7 @@ int bandwidth_divisor = 48000; //divide bandwidth by this to get multiplier for
 
 short int volume_multiplier;
 short int port;
-//
+
 struct dongle_state
 {
 	int      exit_flag;
@@ -597,7 +598,6 @@ static void *demod_thread_fn(void *arg)
 
 int nearest_gain(rtlsdr_dev_t *dev, int target_gain)
 {
-	//target_gain = 36;
 	int i, r, err1, err2, count, nearest;
 	int* gains;
 	r = rtlsdr_set_tuner_gain_mode(dev, 1);
@@ -628,10 +628,9 @@ int verbose_set_frequency(rtlsdr_dev_t *dev, uint32_t frequency)
 	int r;
 	r = rtlsdr_set_center_freq(dev, frequency);
 	if (r < 0) {
-		fprintf (stderr, "WARNING: Failed to set center freq.\n");
+		fprintf (stderr, " (WARNING: Failed to set Center Frequency). \n");
 	} else {
-		//fprintf (stderr, "Tuned to %u Hz.\n", frequency);
-		fprintf (stderr, "Tuned to center frequency %u Hz.\n", frequency);
+		fprintf (stderr, " (Center Frequency: %u Hz.) \n", frequency);
 	}
 	return r;
 }
@@ -679,7 +678,6 @@ int verbose_offset_tuning(rtlsdr_dev_t *dev)
 
 int verbose_auto_gain(rtlsdr_dev_t *dev)
 {
-
 	int r;
 	r = rtlsdr_set_tuner_gain_mode(dev, 0);
 	if (r != 0) {
@@ -692,7 +690,6 @@ int verbose_auto_gain(rtlsdr_dev_t *dev)
 
 int verbose_gain_set(rtlsdr_dev_t *dev, int gain)
 {
-	//gain = 36;
 	int r;
 	r = rtlsdr_set_tuner_gain_mode(dev, 1);
 	if (r < 0) {
@@ -710,7 +707,6 @@ int verbose_gain_set(rtlsdr_dev_t *dev, int gain)
 
 int verbose_ppm_set(rtlsdr_dev_t *dev, int ppm_error)
 {
-	//ppm_error = -2; //fix this opt arg to accept negative float values, i.e. float or double??
 	int r;
 	if (ppm_error == 0) {
 		return 0;}
@@ -732,25 +728,23 @@ int verbose_reset_buffer(rtlsdr_dev_t *dev)
 	return r;
 }
 
-//static void optimal_settings(struct fm_state *fm, int freq, int hopping)
-static void optimal_settings(int freq, int rate) //
+static void optimal_settings(int freq, int rate)
 {
 	// giant ball of hacks
 	// seems unable to do a single pass, 2:1
-	//int r, capture_freq, capture_rate;
 	int capture_freq, capture_rate;
 	struct dongle_state *d = &dongle;
 	struct demod_state *dm = &demod;
 	struct controller_state *cs = &controller;
-	dm->downsample = (1000000 / dm->rate_in) + 1;
+	dm->downsample = (1000000 / dm->rate_in) + 1; //dm->rate_in is the rtl_bandwidth value
 	if (dm->downsample_passes) {
 		dm->downsample_passes = (int)log2(dm->downsample) + 1;
 		dm->downsample = 1 << dm->downsample_passes;
 	}
 	capture_freq = freq;
-	capture_rate = dm->downsample * dm->rate_in;
+	capture_rate = dm->downsample * dm->rate_in; //
 	if (!d->offset_tuning) {
-		capture_freq = freq + capture_rate/4;}
+		capture_freq = freq + capture_rate/4;} //
 	capture_freq += cs->edge * dm->rate_in / 2;
 	dm->output_scale = (1<<15) / (128 * dm->downsample);
 	if (dm->output_scale < 1) {
@@ -759,6 +753,7 @@ static void optimal_settings(int freq, int rate) //
 		dm->output_scale = 1;}
 	d->freq = (uint32_t)capture_freq;
 	d->rate = (uint32_t)capture_rate;
+	// fprintf (stderr, "Capture Frequency: %i Rate: %i \n", capture_freq, capture_rate);
 }
 
 static void *controller_thread_fn(void *arg)
@@ -790,7 +785,6 @@ static void *controller_thread_fn(void *arg)
 	/* Set the sample rate */
 	verbose_set_sample_rate(dongle.dev, dongle.rate);
 	fprintf (stderr, "Output at %u Hz.\n", demod.rate_in/demod.post_downsample);
-	fprintf (stderr, "Press CTRL + C to close.\n"); 
 
 	while (!exitflag) {
 		safe_cond_wait(&s->hop, &s->hop_m);
@@ -807,20 +801,16 @@ static void *controller_thread_fn(void *arg)
 
 void dongle_init(struct dongle_state *s)
 {
-	//s->rate = DEFAULT_SAMPLE_RATE;
 	s->rate = rtl_bandwidth;
 	s->gain = AUTO_GAIN; // tenths of a dB
 	s->mute = 0;
 	s->direct_sampling = 0;
-	s->offset_tuning = 0; //
+	s->offset_tuning = 0; //E4000 tuners only
 	s->demod_target = &demod;
-
 }
 
 void demod_init(struct demod_state *s)
 {
-	//s->rate_in = DEFAULT_SAMPLE_RATE;
-	//s->rate_out = DEFAULT_SAMPLE_RATE;
 	s->rate_in = rtl_bandwidth;
 	s->rate_out = rtl_bandwidth;
 	s->squelch_level = 0;
@@ -830,16 +820,16 @@ void demod_init(struct demod_state *s)
 	s->downsample_passes = 0;
 	s->comp_fir_size = 0;
 	s->prev_index = 0;
-	s->post_downsample = 1;  // once this works, default = 4
+	s->post_downsample = 1;  //1 -- once this works, default = 4 -- doesn't work on the official rtl-sdr source code either
 	s->custom_atan = 0;
 	s->deemph = 0;
-	s->rate_out2 = -1;  // flag for disabled
+	s->rate_out2 = rtl_bandwidth;  // -1 flag for disabled -- this enables low_pass_real, seems to work okay
 	s->mode_demod = &fm_demod;
 	s->pre_j = s->pre_r = s->now_r = s->now_j = 0;
 	s->prev_lpr_index = 0;
 	s->deemph_a = 0;
 	s->now_lpr = 0;
-	s->dc_block = 0;
+	s->dc_block = 1; //enabling by default, but offset tuning is also enabled, so center spike shouldn't be an issue
 	s->dc_avg = 0;
 	pthread_rwlock_init(&s->rw, NULL);
 	pthread_cond_init(&s->ready, NULL);
@@ -856,7 +846,6 @@ void demod_cleanup(struct demod_state *s)
 
 void output_init(struct output_state *s)
 {
-	//s->rate = DEFAULT_SAMPLE_RATE;
 	s->rate = rtl_bandwidth;
 	pthread_rwlock_init(&s->rw, NULL);
 	pthread_cond_init(&s->ready, NULL);
@@ -904,7 +893,8 @@ void sanity_checks(void)
 	}
 
 }
-//UDP remote all below HERE
+
+//UDP remote stuff
 static unsigned int chars_to_int(unsigned char* buf) {
 
 	int i;
@@ -918,9 +908,7 @@ static unsigned int chars_to_int(unsigned char* buf) {
 }
 
 static void *socket_thread_fn(void *arg) {
-	//struct fm_state *fm = arg;
 	struct demod_state *d = static_cast<demod_state*>(arg);
-	//int port = 6020;
   int r, n;
   int sockfd, newsockfd, portno;
   socklen_t clilen;
@@ -952,114 +940,34 @@ static void *socket_thread_fn(void *arg) {
 	while((n = read(sockfd,buffer,5)) != 0) {
 		if(buffer[0] == 0) {
 			new_freq = chars_to_int(buffer);
-			dongle.freq = new_freq; //
-			//opts->rtlsdr_center_freq = new_freq; //or dongle.freq, this should update the freq displayed in ncurses terminal hopefully and not do anything naughty
-
+			dongle.freq = new_freq;
 			optimal_settings(new_freq, demod.rate_in);
 			rtlsdr_set_center_freq(dongle.dev, dongle.freq);
-			//verbose_set_frequency (dongle.dev, new_freq);
-			//fprintf (stderr, "Tuning to: %d [Hz] (central freq: %d [Hz])\n", new_freq, new_freq + freq_offset);
 			fprintf (stderr, "\nTuning to: %d [Hz] \n", new_freq);
 		}
-/*
-		if(buffer[0] == 1) {
-			// change demod type
-			int type = chars_to_int(buffer);
 
-			switch(type) {
-				case 0:
-					fprintf (stderr, "Changing demod type to FM\n");
-      		fm->mode_demod = &fm_demod;
-      	break;
-				case 1:
-					fprintf (stderr, "Changing demod type to AM\n");
-      		fm->mode_demod = &am_demod;
-      	break;
-				case 2:
-					fprintf (stderr, "Changing demod type to USB\n");
-      		fm->mode_demod = &usb_demod;
-      		fm->custom_atan = 1;
-      	break;
-				case 3:
-					fprintf (stderr, "Changing demod type to LSB\n");
-      		fm->mode_demod = &lsb_demod;
-      	break;
-				default:
-					fprintf (stderr, "Unknown demod type %d\n", type);
-      	break;
-      }
-		}
-*/
 
-//SQUELCH HERE
-
-		if (buffer[0] == 2) {
-			new_squelch = chars_to_int(buffer);
-			demod.squelch_level = new_squelch; //demod, or d*? or d->
-			//full_demod(d);
-			//new_freq = 850000000;
-			//dongle.freq = new_freq;
-			//optimal_settings(new_freq, demod.rate_in); //hacky way to 'squelch', just setting it to a dead freq instead
-			//rtlsdr_set_center_freq(dongle.dev, dongle.freq);
-			fprintf (stderr, "Changing squelch to %d \n", new_squelch);
-		}
-
-/*
-		if (buffer[0] == 3) {
-			new_gain = chars_to_int(buffer);
-			if (new_gain == AUTO_GAIN) {
-				r = rtlsdr_set_tuner_gain_mode(dev, 0);
-			} else {
-				r = rtlsdr_set_tuner_gain_mode(dev, 1);
-				new_gain = nearest_gain(new_gain);
-				r = rtlsdr_set_tuner_gain(dev, new_gain);
-			}
-
-			if (r != 0) {
-				fprintf (stderr, "WARNING: Failed to set tuner gain.\n");
-			} else if (new_gain == AUTO_GAIN) {
-				fprintf (stderr, "Tuner gain set to automatic.\n");
-			} else {
-				fprintf (stderr, "Tuner gain set to %0.2f dB.\n", new_gain/10.0);
-			}
-		}
-*/
-/*
-		if (buffer[0] == 8) {
-			agc_mode = chars_to_int(buffer);
-			if (agc_mode == 0 || agc_mode == 1) {
-				fprintf (stderr, "Setting AGC to %d\n", agc_mode);
-				rtlsdr_set_agc_mode(dev, agc_mode);
-			} else {
-				fprintf (stderr, "Failed to set AGC to %d\n", agc_mode);
-			}
-		}
-*/
 	}
 
 	close(sockfd);
 	return 0;
 }
-//UDP Control all above HERE
+//UDP stuff end
 
 void rtlsdr_sighandler()
 {
-	//fprintf (stderr, "Signal caught, exiting!\n");
-	//fprintf (stderr, "Press CTRL + C again to close. Thanks. \n"); //Kindly remind user to double tap CTRL + C
-
+	fprintf (stderr, "Signal caught, exiting!\n");
 	rtlsdr_cancel_async(dongle.dev);
-	//cleanup_rtlsdr_stream(); //thank the wraith for this one...if it works...didn't work
-	//_Exit(1);
 }
 
 void open_rtlsdr_stream(dsd_opts *opts)
 {
   struct sigaction sigact;
   int r;
-	rtl_bandwidth =  opts->rtl_bandwidth * 1000; //multiple by 1000 to get rate
-	//rtl_bandwidth = 48000;
+	rtl_bandwidth =  opts->rtl_bandwidth * 1000; //reverted back to straight value
 	bandwidth_multiplier = (bandwidth_divisor / rtl_bandwidth);
-	//bandwidth_multiplier = 1;
+
+	//this needs to be initted first, then we set the parameters
   dongle_init(&dongle);
   demod_init(&demod);
   output_init(&output);
@@ -1070,29 +978,23 @@ void open_rtlsdr_stream(dsd_opts *opts)
 		controller.freq_len++;
 	}
 
-	if (opts->rtlsdr_ppm_error > 0 || opts->rtlsdr_ppm_error < 0) { //this way will adjust PPM based on negative values as well
+	if (opts->rtlsdr_ppm_error != 0) {
 		dongle.ppm_error = opts->rtlsdr_ppm_error;
 		fprintf (stderr, "Setting RTL PPM Error Set to %d\n", opts->rtlsdr_ppm_error);
 	}
 
-	if (opts->audio_in_type == 3) {
-		dongle.dev_index = opts->rtl_dev_index;
-		//rtl_bandwidth =  opts->rtl_bandwidth * 1000; //multiple by 1000 to get rate
-		//rtl_bandwidth = 48000;
-		//bandwidth_multiplier = rtl_bandwidth / bandwidth_divisor; //find multiple with no remainder if oddball number entered
-		//bandwidth_multiplier = 1;
-		demod.squelch_level = opts->rtl_squelch_level;  //adding user definable squelch level to prevent false positives on account of noise in NXDN etc
-		fprintf (stderr, "Setting RTL VFO Bandwidth to %d Hz\n", rtl_bandwidth);
-		fprintf (stderr, "Setting RTL Sample Multiplier to %d\n", bandwidth_multiplier);
-		fprintf (stderr, "Setting RTL Squelch Level to %d\n", demod.squelch_level);
-		port = opts->rtl_udp_port;
-	}
-
+	dongle.dev_index = opts->rtl_dev_index;
+	// demod.squelch_level = opts->rtl_squelch_level; //no longer used here, used in framesync vc rms value under select conditions
+	fprintf (stderr, "Setting RTL Bandwidth to %d Hz\n", rtl_bandwidth);
+	// fprintf (stderr, "Setting RTL Sample Multiplier to %d\n", bandwidth_multiplier);
+	fprintf (stderr, "Setting RTL RMS Squelch Level to %d\n", opts->rtl_squelch_level);
+	if (opts->rtl_udp_port != 0) port = opts->rtl_udp_port; //set this here, only open socket thread if set
 	if (opts->rtl_gain_value > 0) {
-		dongle.gain = opts->rtl_gain_value * 10; //multiple by ten to make it consitent with the way rtl_fm really works
+		dongle.gain = opts->rtl_gain_value * 10; //multiple by ten to make it consitent with the way rtl_fm works
 	}
   volume_multiplier = opts->rtl_volume_multiplier;
-	fprintf (stderr, "Setting RTL Volume Multiplier to %d\n", volume_multiplier);
+	// fprintf (stderr, "Setting RTL Volume Multiplier to %d\n", volume_multiplier);
+
   /* quadruple sample_rate to limit to Δθ to ±π/2 */
 	demod.rate_in *= demod.post_downsample;
 
@@ -1103,24 +1005,16 @@ void open_rtlsdr_stream(dsd_opts *opts)
 	if (controller.freq_len > 1) demod.terminate_on_squelch = 0;
 
   ACTUAL_BUF_LENGTH = lcm_post[demod.post_downsample] * DEFAULT_BUF_LENGTH;
-  r = rtlsdr_open(&dongle.dev, (uint32_t)dongle.dev_index);
 
+  r = rtlsdr_open(&dongle.dev, (uint32_t)dongle.dev_index);
   if (r < 0)
   {
     fprintf (stderr, "Failed to open rtlsdr device %d.\n", dongle.dev_index);
     exit(1);
   } else {
-		fprintf (stderr, "Using RTLSDR Device Index: %d. \n", dongle.dev_index); //Kindly tell us which device we are using
+		fprintf (stderr, "Using RTLSDR Device Index: %d. \n", dongle.dev_index);
 	}
 
-  // sigact.sa_handler = sighandler;
-  // sigemptyset(&sigact.sa_mask);
-  // sigact.sa_flags = 0;
-  // sigaction(SIGINT, &sigact, NULL);
-  // sigaction(SIGTERM, &sigact, NULL);
-  // sigaction(SIGQUIT, &sigact, NULL);
-  // sigaction(SIGPIPE, &sigact, NULL);
-
   if (demod.deemph) {
 		demod.deemph_a = (int)round(1.0/((1.0-exp(-1.0/(demod.rate_out * 75e-6)))));
 	}
@@ -1128,9 +1022,11 @@ void open_rtlsdr_stream(dsd_opts *opts)
   /* Set the tuner gain */
 	if (dongle.gain == AUTO_GAIN) {
 		verbose_auto_gain(dongle.dev);
+		fprintf (stderr, "Setting RTL Autogain. \n");
 	} else {
 		dongle.gain = nearest_gain(dongle.dev, dongle.gain);
 		verbose_gain_set(dongle.dev, dongle.gain);
+		// fprintf (stderr, "Setting RTL Nearest Gain to %d. \n", dongle.gain); //seems to be working now
 	}
 
   verbose_ppm_set(dongle.dev, dongle.ppm_error);
@@ -1142,7 +1038,8 @@ void open_rtlsdr_stream(dsd_opts *opts)
   usleep(100000);
   pthread_create(&demod.thread, NULL, demod_thread_fn, (void*)(&demod));
   pthread_create(&dongle.thread, NULL, dongle_thread_fn, (void*)(&dongle));
-	pthread_create(&socket_freq, NULL, socket_thread_fn, (void *)(&controller));
+	//only create socket thread IF user specified (for legacy uses), else don't use it
+	if (port != 0) pthread_create(&socket_freq, NULL, socket_thread_fn, (void *)(&controller));
 }
 
 void cleanup_rtlsdr_stream()
@@ -1155,8 +1052,6 @@ void cleanup_rtlsdr_stream()
   safe_cond_signal(&output.ready, &output.ready_m);
   safe_cond_signal(&controller.hop, &controller.hop_m);
   pthread_join(controller.thread, NULL);
-	//add socket thread
-	//pthread_join(socket_freq, NULL);
 
   //dongle_cleanup(&dongle);
   demod_cleanup(&demod);
@@ -1164,32 +1059,69 @@ void cleanup_rtlsdr_stream()
   controller_cleanup(&controller);
 
   rtlsdr_close(dongle.dev);
-
 }
 
-//void get_rtlsdr_sample(int16_t *sample)
+//original for safe keeping
+// void get_rtlsdr_sample(int16_t *sample, dsd_opts * opts, dsd_state * state)
+// {
+// 	if (output.queue.empty())
+// 	{
+// 		safe_cond_wait(&output.ready, &output.ready_m);
+// 	}
+// 	pthread_rwlock_wrlock(&output.rw);
+// 	*sample = output.queue.front() * volume_multiplier;
+// 	output.queue.pop();
+// 	pthread_rwlock_unlock(&output.rw);
+// }
+
+//find way to modify this function to allow hopping (tuning) while squelched and send 0 sample?
 void get_rtlsdr_sample(int16_t *sample, dsd_opts * opts, dsd_state * state)
 {
 	if (output.queue.empty())
 	{
-		if (opts->use_ncurses_terminal == 1)
-		{
-			//ncursesPrinter(opts, state);
-			//printw ("\n\n\n HELP I'M LOCKED!\n");
-		}
 		safe_cond_wait(&output.ready, &output.ready_m);
-		//goto END;
 	}
-
 	pthread_rwlock_wrlock(&output.rw);
-	//*sample = output.queue.front();
-
-	*sample = output.queue.front() * volume_multiplier; //try multiplying by numbers here for 'gain'
+	*sample = output.queue.front() * volume_multiplier;
 	output.queue.pop();
 	pthread_rwlock_unlock(&output.rw);
-	// END:
-	// if (1 == 2)
-	// {
-	// 	fprintf (stderr, "This is a dumb thing to fix");
-	// }
 }
+
+//function may lag since it isn't running as its own thread
+void rtl_dev_tune(dsd_opts * opts, long int frequency)
+{
+	int r;
+	if (opts->payload == 1)
+		fprintf (stderr, "\nTuning to %lu Hz.", frequency);
+	dongle.freq = opts->rtlsdr_center_freq = frequency;
+	optimal_settings(dongle.freq, demod.rate_in);
+	if (opts->payload == 1)
+		fprintf (stderr, " (Center Frequency: %u Hz.) \n", dongle.freq);
+	r = rtlsdr_set_center_freq(dongle.dev, dongle.freq);
+	if (r < 0)
+		fprintf (stderr, " (WARNING: Failed to set Center Frequency %u). \n", dongle.freq);
+
+	pthread_rwlock_wrlock(&output.rw); //prevent possible segfault when cleaning the queue
+	rtl_clean_queue();
+	pthread_rwlock_unlock(&output.rw); //resume 
+
+}
+
+//return RMS value (root means square) power level -- used as soft squelch inside of framesync
+int rtl_return_rms()
+{
+	int sr = 0;
+	sr = rms(demod.lowpassed, demod.lp_len, 1);
+	// 'Fix' potential negative value overflow from the rms function -- Observed in Windows builds
+	sr = abs(sr);
+	if (sr > 9999) sr = 9999;
+	return (sr);
+}
+
+//simple function to clear the rtl sample queue when tuning and during other events (ncurses menu open/close)
+void rtl_clean_queue()
+{
+	//insert method to clear the entire queue to prevent sample 'lag'
+	std::queue<int16_t> empty; //create an empty queue
+	std::swap( output.queue, empty ); //swap in empty queue to effectively zero out current queue
+}

src/x2tdma_voice.c

@@ -630,7 +630,7 @@ processX2TDMAvoice (dsd_opts * opts, dsd_state * state)
     {
       if ((eeei == 0) && (aiei == 0))
         {
-          processP25lcw (opts, state, lcformat, mfid, lcinfo);
+          // processP25lcw (opts, state, lcformat, mfid, lcinfo);
         }
       if (opts->p25enc == 1)
         {

virtualsink.sh

@@ -0,0 +1,4 @@
+pactl load-module module-null-sink sink_name=virtual_sink  sink_properties=device.description=Virtual_Sink
+pactl load-module module-null-sink sink_name=virtual_sink2  sink_properties=device.description=Virtual_Sink2
+
+