dPMR Scrambler Key Support;

'Lite' Optimizations and Tweaks for Win32CYG Build
2026-11-13 09:17:20 -05:00 · 2023-01-07 18:41:44 -05:00 · 2023-01-05 18:38:12 -05:00
65 changed files with 3503 additions and 8752 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -5,6 +5,3 @@ build
 *.sh
 *.csv
 examples
 *.bin
 *.ans
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,43 +1,11 @@
-#Ubuntu 20.04 uses 3.16.3
+project(dsd-fme-lite)
-#Ubuntu 22.04 uses 3.22.1
+cmake_minimum_required(VERSION 2.8.11)
 #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 -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 new NXDN Sync Pattern Testing
 option(NXDN
    "Build with new NXDN Sync Pattern Testing Enabled" OFF)
 if (NXDN)
    add_definitions(-DNXDNTESTSYNC) 
 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 ()
 include(git_revision)
 git_describe(GIT_TAG)
@@ -46,7 +14,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})
@@ -70,24 +38,24 @@ list(APPEND SRCS "${CMAKE_CURRENT_BINARY_DIR}/git_ver.c")
 include_directories("${PROJECT_SOURCE_DIR}/include")
-ADD_EXECUTABLE(dsd-fme ${SRCS} ${HEADERS})
+ADD_EXECUTABLE(dsd-fme-lite ${SRCS} ${HEADERS})
-TARGET_LINK_LIBRARIES(dsd-fme ${LIBS})
+TARGET_LINK_LIBRARIES(dsd-fme-lite ${LIBS})
 include(GNUInstallDirs)
-install(TARGETS dsd-fme DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(TARGETS dsd-fme-lite DESTINATION ${CMAKE_INSTALL_BINDIR})
 # man page
 find_program(HELP2MAN_FOUND help2man)
 if (HELP2MAN_FOUND)
-    add_custom_command(TARGET dsd-fme POST_BUILD
+    add_custom_command(TARGET dsd-fme-lite POST_BUILD
        COMMAND help2man
        ARGS -n "Digital Speech Decoder"
            --version-string=${GIT_TAG}
-            -o ${CMAKE_CURRENT_BINARY_DIR}/dsd-fme.1
+            -o ${CMAKE_CURRENT_BINARY_DIR}/dsd-fme-lite.1
            --no-info
-            $<TARGET_FILE:dsd-fme>
+            $<TARGET_FILE:dsd-fme-lite>
    )
-    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/dsd-fme.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
+    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/dsd-fme-lite.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
 endif()
 # uninstall target
--- a/README.md
+++ b/README.md
@@ -1,10 +1,17 @@
 ## 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"), [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.
+[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.
-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.
+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")
 ![DSD-FME](https://github.com/lwvmobile/dsd-fme/blob/main/dsd-fme2.png)
@@ -14,6 +21,10 @@ This project wouldn't be possible without a few good people providing me plenty
 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)
--- a/cmake/FindPULSEAUDIO.cmake
+++ b/cmake/FindPULSEAUDIO.cmake
--- a/download-and-install-nodeps.sh
+++ b/download-and-install-nodeps.sh
@@ -1,23 +0,0 @@
 #! /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
--- a/download-and-install.sh
+++ b/download-and-install.sh
@@ -1,67 +0,0 @@
 #! /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
--- a/dsd-fme2.png
+++ b/dsd-fme2.png
--- a/dsd-fme3.png
+++ b/dsd-fme3.png
--- a/examples/Example_Usage.md
+++ b/examples/Example_Usage.md
@@ -1,3 +1,7 @@
 ## Notice
 These examples will need to be modified to run on the 'lite' branch, or any precompiled Windows binaries released. (i.e. dsd-fme to dsd-fme-lite.exe, -i pulse -o pulse, etc)
 ### 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.
@@ -16,24 +20,6 @@
 -fx X2-TDMA
 ```
 ## New -- Experimental 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 NXDN98 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 is purely set by your CPU/GPU, and also by other factors like using SDR++ server to connect to a SDR++ client, or RTL_TCP server to client, etc, so faster computers scan faster, and slower will scan slower, slower scans may require multiple duplicate entries into your scanner csv file if you make a really large one.
 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.
@@ -135,18 +121,14 @@ 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 '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 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, 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.
-Trunking Note4: NXDN Trunking v1 will require a channel map. Please see the example folder for an appropriate channel map. NOTICE: NXDN trunking will not work properly with RTL input method due to the internal handling of the RTL dongle, when using squelch, it will effectively stop all processing (including trunking/tuning) until signal is regained, but squelch is required on NXDN to prevent false sync patterns.
+Currently uncoded/unknown DMR trunking systems include Hytera XPT.
-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.
+Trunking Note4: 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 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: Experimental 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:
@@ -169,7 +151,6 @@ s - stop playing symbol capture bin or wav input file
 P - start per call decoded wav files
 p - stop per call decoded wav files
 t - toggle trunking (needs either rtl input, or rigctl connection)
 y - toggle scanner (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)
 0 - Toggle Audio Smoothing - May produce crackling if enabled on RTL/TCP or wav/bin files
--- a/examples/Install_Notes.md
+++ b/examples/Install_Notes.md
@@ -1,3 +1,7 @@
 ## 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:
@@ -98,8 +102,8 @@ Optional 'Virtual Sinks' for routing audio from SDR++ or GQRX, Media Players, et
 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.
 ```
-pactl load-module module-null-sink sink_name=virtual_sink  sink_properties=device.description=Virtual_Sink
+pacmd 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
+pacmd 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:
--- a/examples/hytera_xpt_chan.csv
+++ b/examples/hytera_xpt_chan.csv
@@ -1,10 +0,0 @@
 LSN Number(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
--- a/examples/multi_key.csv
+++ b/examples/multi_key.csv
@@ -1,6 +0,0 @@
 key id or tg id (dec), key number or value (dec) //NXDN, BP, 10-char Hytera BP only
 2,70
 1,123
 100,70
 12,48713912656
 672560,254
--- a/examples/nxdn_chan_map.csv
+++ b/examples/nxdn_chan_map.csv
@@ -1,8 +0,0 @@
 channel(dec), freq(Hz)
 141,423862500
 142,424337500
 143,424912500
 203,424100000
 204,424625000
 271,422650000
 302,423287500
--- a/examples/nxdn_sc_key.csv
+++ b/examples/nxdn_sc_key.csv
@@ -1,5 +0,0 @@
 key(dec) or tg(dec), value(dec), load any single keys as key 0
 0,23466
 1,12345
 2,32700
 63,32767
--- a/examples/trunking.sh
+++ b/examples/trunking.sh
@@ -13,7 +13,7 @@
 #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
-#DMR TIII, Con+, Cap+, XPT
+#DMR TIII, Con+, Cap+
 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
@@ -21,13 +21,13 @@ dsd-fme -fs -i tcp -U 4532 -T -C dmr_t3_chan.csv -G group.csv -N 2> log.ans
 #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
 #NXDN48 Trunking with Standard Band Plan (Channels 0-800)
 #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
 #NXDN48 Trunking with Channel Map (Custom Channels > 800)
 #dsd-fme -fi -i tcp -T -U 4532 -C channel_map.csv -N 2> log.ans
-#NOTE! NXDN Trunking will not work correctly with the RTL input method
+#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 (Custom Channels > 800)
 #dsd-fme -fn -i tcp -T -U 4532 -C channel_map.csv -N 2> log.ans
 #NOTE! NXDN Trunking will not work correctly with the RTL input method
 #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
--- a/include/dsd.h
+++ b/include/dsd.h
@@ -17,8 +17,7 @@
 * PERFORMANCE OF THIS SOFTWARE.
 */
-//defined by CMakeLists.txt -- Disable by using cmake -DCOLORS=OFF ..
+//pretty pretty colors
 #ifdef PRETTY_COLORS
 #define KNRM  "\x1B[0m"
 #define KRED  "\x1B[31m"
 #define KGRN  "\x1B[32m"
@@ -27,16 +26,6 @@
 #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>
@@ -58,11 +47,14 @@
 #include "p25p1_heuristics.h"
 //OSS support
 #include <sys/soundcard.h>
 #include <pulse/simple.h>     //PULSE AUDIO
 #include <pulse/error.h>      //PULSE AUDIO
 #define SAMPLE_RATE_IN 48000 //48000
-#define SAMPLE_RATE_OUT 8000 //8000,
+#define SAMPLE_RATE_OUT 48000 //8000,
 #ifdef USE_RTLSDR
 #include <rtl-sdr.h>
@@ -201,6 +193,7 @@ typedef struct
  int audio_in_type; 
  char audio_out_dev[1024];
  int audio_out_fd;
  int audio_out_fdR; //right channel audio for OSS hack
  SNDFILE *audio_out_file;
  SF_INFO *audio_out_file_info;
@@ -210,10 +203,8 @@ typedef struct
  int playoffsetR;
  char mbe_out_dir[1024];
  char mbe_out_file[1024];
  char mbe_out_fileR[1024]; //second slot on a TDMA system
  char mbe_out_path[2048]; //1024
  FILE *mbe_out_f;
  FILE *mbe_out_fR; //second slot on a TDMA system
  FILE *symbol_out_f;
  float audio_gain;
  float audio_gainR;
@@ -227,7 +218,6 @@ typedef struct
  char szNumbers[1024]; //**tera 10/32/64 char str
  short int symbol_out;
  short int mbe_out; //flag for mbe out, don't attempt fclose more than once
  short int mbe_outR; //flag for mbe out, don't attempt fclose more than once
  SNDFILE *wav_out_f;
  SNDFILE *wav_out_fR;
  SNDFILE *wav_out_raw;
@@ -332,15 +322,12 @@ 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
-  float trunk_hangtime; //hangtime in seconds before tuning back to CC
+  int 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];
  char lcn_in_file[1024];
  char chan_in_file[1024]; 
  char key_in_file[1024]; 
  //end import filenames
  //reverse mute
@@ -365,12 +352,8 @@ typedef struct
  //Trunking - Tune Data Calls
  uint8_t trunk_tune_data_calls;
-  //Trunking - Tune Enc Calls (P25 only on applicable grants with svc opts)
+  //OSS audio - slot preference
-  uint8_t trunk_tune_enc_calls;
+  uint8_t slot_preference;
  //'DSP' Format Output
  uint8_t use_dsp_output;
  char dsp_out_file[2048];
 } dsd_opts;
@@ -525,32 +508,27 @@ typedef struct
  unsigned int dmr_fid;
  unsigned int dmr_so;
  unsigned int dmr_flco;
  unsigned int dmr_fidR;
  unsigned int dmr_soR;
  unsigned int dmr_flcoR;
  char slot1light[8];
  char slot2light[8];
  int directmode;
  int dmr_stereo_payload[144];    //load up 144 dibit buffer for every single DMR TDMA frame
-  int data_header_blocks[2];      //collect number of blocks to follow from data header per slot
+  uint8_t 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 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 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 time slot
  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)
+  char dmr_embedded_signalling[2][6][48]; //embedded signalling 2 slots by 6 vc by 48 bits (replacing TS1SuperFrame.TimeSlotRawVoiceFrame.Sync structure)
  char dmr_cach_fragment[4][17]; //unsure of size, will need to check/verify
  int dmr_cach_counter; //counter for dmr_cach_fragments 0-3; not sure if needed yet.
@@ -563,7 +541,6 @@ 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;
@@ -595,8 +572,6 @@ typedef struct
  unsigned long long int p2_wacn;
  unsigned long long int p2_sysid;
  unsigned long long int p2_cc;    //p1 NAC
  unsigned long long int p2_siteid;
  unsigned long long int p2_rfssid;
  int p2_hardset; //flag for checking whether or not P2 wacn and sysid are hard set by user
  int p2_scramble_offset; //offset counter for scrambling application
  int p2_vch_chan_num; //vch channel number (0 or 1, not the 0-11 TS)
@@ -605,7 +580,6 @@ 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];
@@ -651,7 +625,6 @@ 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
@@ -663,28 +636,17 @@ 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;
  //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];
  //dmr manufacturer branding and sub_branding (i.e., Motorola and Con+)
-  char dmr_branding[99];
+  char dmr_branding[20];
-  char dmr_branding_sub[99];
+  char dmr_branding_sub[80];
  //Remus DMR End Call Alert Beep
  int dmr_end_alert[2]; //dmr TLC end call alert beep has already played once flag
@@ -750,26 +712,6 @@ 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"
@@ -808,16 +750,13 @@ int get_dibit_and_analog_signal (dsd_opts * opts, dsd_state * state, int * out_a
 void skipDibit (dsd_opts * opts, dsd_state * state, int count);
 void saveImbe4400Data (dsd_opts * opts, dsd_state * state, char *imbe_d);
 void saveAmbe2450Data (dsd_opts * opts, dsd_state * state, char *ambe_d);
 void saveAmbe2450DataR (dsd_opts * opts, dsd_state * state, char *ambe_d); //tdma slot 2
 void PrintAMBEData (dsd_opts * opts, dsd_state * state, char *ambe_d);
 void PrintIMBEData (dsd_opts * opts, dsd_state * state, char *imbe_d);
 int readImbe4400Data (dsd_opts * opts, dsd_state * state, char *imbe_d);
 int readAmbe2450Data (dsd_opts * opts, dsd_state * state, char *ambe_d);
 void openMbeInFile (dsd_opts * opts, dsd_state * state);
 void closeMbeOutFile (dsd_opts * opts, dsd_state * state);
 void closeMbeOutFileR (dsd_opts * opts, dsd_state * state); //tdma slot 2
 void openMbeOutFile (dsd_opts * opts, dsd_state * state);
 void openMbeOutFileR (dsd_opts * opts, dsd_state * state); //tdma slot 2
 void openWavOutFile (dsd_opts * opts, dsd_state * state);
 void openWavOutFileL (dsd_opts * opts, dsd_state * state);
 void openWavOutFileR (dsd_opts * opts, dsd_state * state);
@@ -851,9 +790,6 @@ 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);
@@ -866,14 +802,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); //P25 Trunking Single Block
+void processTSBK(dsd_opts * opts, dsd_state * state);
 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);
-uint64_t ConvertBitIntoBytes(uint8_t * BufferIn, uint32_t BitLength);
+/* Global functions */ 
 uint32_t ConvertBitIntoBytes(uint8_t * BufferIn, uint32_t BitLength);
 void ncursesOpen (dsd_opts * opts, dsd_state * state);
 void ncursesPrinter (dsd_opts * opts, dsd_state * state);
@@ -882,15 +818,10 @@ 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], uint8_t type);
+void nxdn_deperm_facch2_udch (dsd_opts * opts, dsd_state * state, uint8_t bits[348]);
 //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]);
@@ -900,7 +831,6 @@ 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);
@@ -923,9 +853,7 @@ 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_decode_adj_site(dsd_opts * opts, dsd_state * state, uint8_t * Message);
+void nxdn_location_id_handler (dsd_state * state, uint32_t location_id);
 //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);
@@ -941,7 +869,7 @@ int32_t GetdPmrColorCode(uint8_t ChannelCodeBit[24]);
 void BPTCDeInterleaveDMRData(uint8_t * Input, uint8_t * Output);
 uint32_t BPTC_196x96_Extract_Data(uint8_t InputDeInteleavedData[196], uint8_t DMRDataExtracted[96], uint8_t R[3]);
 uint32_t BPTC_128x77_Extract_Data(uint8_t InputDataMatrix[8][16], uint8_t DMRDataExtracted[77]);
-uint32_t BPTC_16x2_Extract_Data(uint8_t InputInterleavedData[32], uint8_t DMRDataExtracted[32], uint32_t ParityCheckTypeOdd);
+uint32_t BPTC_16x2_Extract_Data(uint8_t InputInterleavedData[32], uint8_t DMRDataExtracted[32]);
 //Reed Solomon (12,9) functions
 void rs_12_9_calc_syndrome(rs_12_9_codeword_t *codeword, rs_12_9_poly_t *syndrome);
@@ -954,9 +882,6 @@ uint16_t ComputeCrcCCITT(uint8_t * DMRData);
 uint16_t ComputeCrcCCITT16d(const uint8_t buf[], uint8_t len);
 uint32_t ComputeAndCorrectFullLinkControlCrc(uint8_t * FullLinkControlDataBytes, uint32_t * CRCComputed, uint32_t CRCMask);
 uint8_t ComputeCrc5Bit(uint8_t * DMRData);
 uint16_t ComputeCrc9Bit(uint8_t * DMRData, uint32_t NbData);
 uint32_t ComputeCrc32Bit(uint8_t * DMRData, uint32_t NbData);
 //new simplified dmr functions
 void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196], uint8_t databurst);
@@ -980,12 +905,11 @@ 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[], uint8_t dheader_bits[], uint32_t CRCCorrect, uint32_t IrrecoverableErrors);
+void dmr_dheader (dsd_opts * opts, dsd_state * state, uint8_t dheader[], 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);
-void dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR_PDU[]);
+uint8_t 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);
@@ -993,19 +917,14 @@ void dmr_alg_refresh (dsd_opts * opts, dsd_state * state);
 void dmr_late_entry_mi_fragment (dsd_opts * opts, dsd_state * state, uint8_t vc, char ambe_fr[4][24], char ambe_fr2[4][24], char ambe_fr3[4][24]);
 void dmr_late_entry_mi (dsd_opts * opts, dsd_state * state);
 //handle Single Burst (Voice Burst F) or Reverse Channel Signalling
 void dmr_sbrc (dsd_opts * opts, dsd_state * state, uint8_t power);
 //DMR FEC/CRC from Boatbod - OP25
 bool Hamming17123(uint8_t* d);
 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/
 void LFSR(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);
@@ -1090,7 +1009,6 @@ 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);
 #ifdef __cplusplus
 extern "C" {
@@ -1116,7 +1034,7 @@ bool CDMRTrellisDecode(const unsigned char* data, unsigned char* payload);
 int ez_rs28_ess (int payload[96], int parity[168]); //ezpwd bridge for FME
 int ez_rs28_facch (int payload[156], int parity[114]); //ezpwd bridge for FME
 int ez_rs28_sacch (int payload[180], int parity[132]); //ezpwd bridge for FME
-int isch_lookup (unsigned long long int isch); //isch map lookup
+unsigned long long int isch_lookup (unsigned long long int isch); //isch map lookup
 int bd_bridge (int payload[196], uint8_t decoded[12]); //bridge to Michael Ossmann Block De-interleaver and 1/2 rate trellis decoder
 int crc16_lb_bridge (int payload[190], int len);
 int crc12_xb_bridge (int payload[190], int len);
--- a/rebuild.sh
+++ b/rebuild.sh
@@ -1,16 +0,0 @@
 #! /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
--- a/src/bptc.c
+++ b/src/bptc.c
@@ -134,13 +134,6 @@ const uint8_t DeInterleaveReverseChannelBptc[32] =
  24,  9, 26, 11, 28, 13, 30, 15
 };
 const uint8_t DeInterleaveReverseChannelBptcPlacement[32] =
 {
   0, 16,  1, 17,  2, 18,  3, 19,
   4, 20,  5, 21,  6, 22,  7, 23,
   8, 24,  9, 25, 10, 26, 11, 27,
  12, 28, 13, 29, 14, 30, 15, 31
 };
 /* Functions ----------------------------------------------------------------*/
@@ -199,10 +192,18 @@ uint32_t BPTC_196x96_Extract_Data(uint8_t InputDeInteleavedData[196], uint8_t DM
    }
  }
  /* R(0) to R(2) may be used to transport some
   * Restricted Access System (RAS) information,
   * So save these three bytes before reset all of them
   * See patent US 2013/0288643 A1 */
  R[0] = DataMatrix[0][2]; /* Save R(0) */
  R[1] = DataMatrix[0][1]; /* Save R(1) */
  R[2] = DataMatrix[0][0]; /* Save R(2) */
  /* Set to 0 R(0) to R(2) - See DMR standard chapter B1.1 BPTC (196,96) */
-  // DataMatrix[0][0] = 0; /* R(2) */
+  DataMatrix[0][0] = 0; /* R(2) */
-  // DataMatrix[0][1] = 0; /* R(1) */
+  DataMatrix[0][1] = 0; /* R(1) */
-  // DataMatrix[0][2] = 0; /* R(0) */
+  DataMatrix[0][2] = 0; /* R(0) */
  /* Init the Hamming (15,11,3) library
   * Not needed because it has already been done
@@ -355,14 +356,6 @@ uint32_t BPTC_196x96_Extract_Data(uint8_t InputDeInteleavedData[196], uint8_t DM
    }
  }
  /* R(0) to R(2) may be used to transport some
   * Restricted Access System (RAS) information,
   * So save these three bits after hamming correction
   * See patent US 2013/0288643 A1 */
  R[0] = DataMatrix[0][2]; /* Save R(0) */
  R[1] = DataMatrix[0][1]; /* Save R(1) */
  R[2] = DataMatrix[0][0]; /* Save R(2) */
  /* Return the number of irrecoverable Hamming errors */
  return HammingIrrecoverableErrorNb;
 } /* End BPTC_196x96_Extract_Data() */
@@ -505,38 +498,33 @@ uint32_t BPTC_128x77_Extract_Data(uint8_t InputDataMatrix[8][16], uint8_t DMRDat
 *                           DMRDataExtracted[11..15] = Hamming data
 *                           DMRDataExtracted[16..31] = 16 bits of odd parity (to be checked)
 *
 * @param ParityCheckTypeOdd : 0 = Parity to check is even (used in Non-Reverse Channel Single Burst BPTC)
 *                             1 = Parity to check is odd (used in Reverse Channel Single Burst BPTC)
 *
 * @return 0 = All is OK
 *         Other = Error - Irrecoverable Hamming parity check error number
 */
-uint32_t BPTC_16x2_Extract_Data(uint8_t InputInterleavedData[32], uint8_t DMRDataExtracted[32], uint32_t ParityCheckTypeOdd)
+uint32_t BPTC_16x2_Extract_Data(uint8_t InputInterleavedData[32], uint8_t DMRDataExtracted[32])
 {
  uint32_t i;
  uint8_t  DataMatrix[32];
  uint8_t  LineUncorrected[16];
  uint8_t  LineCorrected[11];
  uint32_t HammingIrrecoverableErrorNb = 0;
-  uint32_t ParityCheckOddErrorNb = 0;
+  uint32_t ParityCheckErrorNb = 0;
  uint32_t ParityCheckEvenErrorNb = 0;
  //TODO: make this so we can load either rc interleave, or single burst interleave
  for(i = 0; i < 32; i++)
  {
-    DataMatrix[DeInterleaveReverseChannelBptcPlacement[DeInterleaveReverseChannelBptc[i]]] = InputInterleavedData[i] & 1;
+    DataMatrix[DeInterleaveReverseChannelBptc[i]] = InputInterleavedData[i] & 1;
  }
  /* Copy the entire input buffer to the output buffer */
  for(i = 0; i < 32; i++)
  {
-    DMRDataExtracted[i] = DataMatrix[i] & 1;
+    DMRDataExtracted[i] = DataMatrix[i];
  }
  /* Prepare the line to be corrected */
  for(i = 0; i < 16; i++)
  {
-    LineUncorrected[i] = DataMatrix[i] & 1;
+    LineUncorrected[i] = DataMatrix[i];
  }
  /* Apply Hamming (16,11,4) code correction */
@@ -548,7 +536,7 @@ uint32_t BPTC_16x2_Extract_Data(uint8_t InputInterleavedData[32], uint8_t DMRDat
  /* Copy the corrected content to the output buffer */
  for(i = 0; i < 11; i++)
  {
-    DMRDataExtracted[i] = LineCorrected[i] & 1;
+    DMRDataExtracted[i] = LineCorrected[i];
  }
  /* Check Parity bits */
@@ -556,24 +544,14 @@ uint32_t BPTC_16x2_Extract_Data(uint8_t InputInterleavedData[32], uint8_t DMRDat
  {
    /* Odd parity ==> If data = 1 then parity = 0
     *                If data = 0 then parity = 1 */
-    if((DMRDataExtracted[i] & 1) == (DMRDataExtracted[i + 16] & 1)) ParityCheckOddErrorNb++;
+    if(DMRDataExtracted[i] == DMRDataExtracted[i + 16]) ParityCheckErrorNb++;
    if((DMRDataExtracted[i] & 1) != (DMRDataExtracted[i + 16] & 1)) ParityCheckEvenErrorNb++;
  }
-  //fprintf(stderr, "Hamming ERR=%u ; Parity odd ERR=%u, Parity even ERR=%u, ", HammingIrrecoverableErrorNb, ParityCheckOddErrorNb, ParityCheckEvenErrorNb);
+  //fprintf(stderr, "Hamming ERR=%u ; Parity ERR=%u", HammingIrrecoverableErrorNb, ParityCheckErrorNb);
  //fprintf(stderr, "Content =\n");
  //for(i = 0; i < 32; i++)
  //{
  //  fprintf(stderr, "%u", DMRDataExtracted[i] & 1);
  //  if((i == 15) || (i == 31)) fprintf(stderr, "\n");
  //  else fprintf(stderr, "-");
  //}
  /* Return the number of irrecoverable Hamming errors +
   * the number of parity check error */
-  if(ParityCheckTypeOdd) return (HammingIrrecoverableErrorNb + ParityCheckOddErrorNb);
+  return (HammingIrrecoverableErrorNb + ParityCheckErrorNb);
  else return (HammingIrrecoverableErrorNb + ParityCheckEvenErrorNb);
 } /* End BPTC_16x2_Extract_Data() */
--- a/src/dmr_block.c
+++ b/src/dmr_block.c
--- a/src/dmr_bs.c
+++ b/src/dmr_bs.c
@@ -42,11 +42,6 @@ void dmrBS (dsd_opts * opts, dsd_state * state)
  uint8_t vc1;
  uint8_t vc2;
  //assign as nonsensical numbers
  uint8_t cc = 25;
  uint8_t power = 9; //power and pre-emption indicator
  uint8_t lcss = 9;
  //would be ideal to grab all dibits and break them into bits to pass to new data handler?
  uint8_t dummy_bits[196]; 
  memset (dummy_bits, 0, sizeof(dummy_bits));
@@ -114,8 +109,13 @@ 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) goto END; //when going to end for bad tact or emb, consider using getdibit or skipdibit to 'stash' dibits and get better return on next sync pattern? in data particularly
+  if (tact_okay != 1)
-
+  {
    if (opts->aggressive_framesync == 1)
    {
      goto END;
    } 
  }
  internalslot = state->currentslot = tact_bits[1];
@@ -189,13 +189,13 @@ void dmrBS (dsd_opts * opts, dsd_state * state)
    syncdata[(2*i)+1] = (1 & dibit);         // bit 0
    //embedded link control
-    if(internalslot == 0 && vc1 > 1 && vc1 < 7) //grab on vc1 values 2-5 B C D and E (F for Single/RC)
+    if(internalslot == 0 && vc1 > 1 && vc1 < 6) //grab on vc1 values 2-5 B C D and E
    {
      state->dmr_embedded_signalling[internalslot][vc1-1][i*2]   = (1 & (dibit >> 1)); // bit 1
      state->dmr_embedded_signalling[internalslot][vc1-1][i*2+1] = (1 & dibit); // bit 0
    }
-    if(internalslot == 1 && vc2 > 1 && vc2 < 7) //grab on vc2 values 2-5 B C D and E (F for Single/RC)
+    if(internalslot == 1 && vc2 > 1 && vc2 < 6) //grab on vc2 values 2-5 B C D and E
    {
      state->dmr_embedded_signalling[internalslot][vc2-1][i*2]   = (1 & (dibit >> 1)); // bit 1
      state->dmr_embedded_signalling[internalslot][vc2-1][i*2+1] = (1 & dibit); // bit 0
@@ -265,9 +265,6 @@ void dmrBS (dsd_opts * opts, dsd_state * state)
      else fprintf (stderr,"Sync: -DMR  ");
      vc1 = 1;
      //close MBEout file - slot 1
      if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state); 
    }
    if (internalslot == 1)
    {
@@ -279,9 +276,6 @@ void dmrBS (dsd_opts * opts, dsd_state * state)
      vc2 = 1;
      //close MBEout file - slot 2
      if (opts->mbe_out_fR != NULL) closeMbeOutFileR (opts, state);
    }
    dmr_data_sync (opts, state);
    skipcount++;
@@ -300,9 +294,9 @@ void dmrBS (dsd_opts * opts, dsd_state * state)
    if ( (strcmp (sync, DMR_BS_VOICE_SYNC) != 0) && emb_ok == 0) goto END; //fprintf (stderr, "EMB BAD? ");
    else if (emb_ok == 1)
    {
-      cc = ((EmbeddedSignalling[0] << 3) + (EmbeddedSignalling[1] << 2) + (EmbeddedSignalling[2] << 1) + EmbeddedSignalling[3]);
+      uint8_t cc = ((EmbeddedSignalling[0] << 3) + (EmbeddedSignalling[1] << 2) + (EmbeddedSignalling[2] << 1) + EmbeddedSignalling[3]);
-      power = EmbeddedSignalling[4];
+      uint8_t power = EmbeddedSignalling[4];
-      lcss = ((EmbeddedSignalling[5] << 1) + EmbeddedSignalling[6]);
+      uint8_t lcss = ((EmbeddedSignalling[5] << 1) + EmbeddedSignalling[6]);
    }
@@ -318,16 +312,12 @@ void dmrBS (dsd_opts * opts, dsd_state * state)
      state->dmrburstL = 16;
      vc = vc1;
      sprintf (light, "%s", " [SLOT1]  slot2  ");
      //open MBEout file - slot 1
      if ((opts->mbe_out_dir[0] != 0) && (opts->mbe_out_f == NULL)) openMbeOutFile (opts, state);
    } 
    else
    {
      state->dmrburstR = 16;
      vc = vc2;
      sprintf (light, "%s", "  slot1  [SLOT2] ");
      //open MBEout file - slot 2
      if ((opts->mbe_out_dir[0] != 0) && (opts->mbe_out_fR == NULL)) openMbeOutFileR (opts, state);
    } 
    if (opts->inverted_dmr == 0) sprintf (polarity, "%s", "+");
    else sprintf (polarity, "%s", "-");
@@ -339,8 +329,6 @@ 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);
    }
    if (internalslot == 1 && vc2 == 6) 
@@ -348,8 +336,6 @@ 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);
    }
    if (opts->payload == 1) fprintf (stderr, "\n"); //extra line break necessary here
@@ -361,12 +347,25 @@ void dmrBS (dsd_opts * opts, dsd_state * state)
    memcpy (m2, ambe_fr2, sizeof(m2));
    memcpy (m3, ambe_fr3, sizeof(m3));
    // if ( opts->audio_in_type == 5 && internalslot == 0 && state->dmrburstR != 16 ) //(OSS shim)
    // {
    //   processMbeFrame (opts, state, NULL, ambe_fr, NULL);
    //   processMbeFrame (opts, state, NULL, ambe_fr2, NULL);
    //   processMbeFrame (opts, state, NULL, ambe_fr3, NULL);
    // }
    // if ( opts->audio_in_type == 5 && internalslot == 1 && state->dmrburstL != 16 ) //(OSS shim)
    // {
    //   processMbeFrame (opts, state, NULL, ambe_fr, NULL);
    //   processMbeFrame (opts, state, NULL, ambe_fr2, NULL);
    //   processMbeFrame (opts, state, NULL, ambe_fr3, NULL);
    // }
    processMbeFrame (opts, state, NULL, ambe_fr, NULL);
    processMbeFrame (opts, state, NULL, ambe_fr2, NULL);
    processMbeFrame (opts, state, NULL, ambe_fr3, NULL);    
    cach_err = dmr_cach (opts, state, cachdata); 
-    if (opts->payload == 0) fprintf (stderr, "\n");
+    fprintf (stderr, "\n");
    // run alg refresh after vc6 ambe processing
    if (internalslot == 0 && vc1 == 6) dmr_alg_refresh (opts, state);
@@ -385,36 +384,11 @@ void dmrBS (dsd_opts * opts, dsd_state * state)
      state->last_cc_sync_time = time(NULL);
    } 
    //'DSP' output to file
    if (opts->use_dsp_output == 1)
    {
      FILE * pFile; //file pointer
      pFile = fopen (opts->dsp_out_file, "a");
      fprintf (pFile, "\n%d 98 ", internalslot+1); //'98' is CACH designation value
      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, "\n%d 10 ", internalslot+1); //0x10 for voice burst
      for (i = 6; i < 72; i++) //33 bytes, no CACH
      {
        int dsp_byte = (state->dmr_stereo_payload[i*2] << 2) | state->dmr_stereo_payload[i*2 + 1];
        fprintf (pFile, "%X", dsp_byte);
      }
      fclose (pFile);
    }
    //reset err checks
    cach_err = 1;
    tact_okay = 0;
    emb_ok = 0;
    //reset emb components
    cc = 25;
    power = 9;
    lcss = 9;
    //Extra safeguards to break loop
    // if ( (vc1 > 7 && vc2 > 7) ) goto END;
    if ( (vc1 > 14 || vc2 > 14) ) goto END;
@@ -446,10 +420,6 @@ void dmrBS (dsd_opts * opts, dsd_state * state)
 state->errs2R = 0;
 state->errs2 = 0;
 //close any open MBEout files
 if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state);
 if (opts->mbe_out_fR != NULL) closeMbeOutFileR (opts, state);
 //if we have a tact or emb err, then produce sync pattern/err message
 if (tact_okay != 1 || emb_ok != 1)
 {
@@ -460,16 +430,18 @@ void dmrBS (dsd_opts * opts, dsd_state * state)
  fprintf (stderr, "| VOICE CACH/EMB ERR");
  fprintf (stderr, "%s", KNRM);
  fprintf (stderr, "\n");
-  //run refresh if either slot had an active MI in it.
+  //run LFSR if either slot had an active MI in it.
-  if (state->payload_algid != 0)
+  if (state->payload_algid >= 0x21)
  {
-    state->currentslot = 0;
+  state->currentslot = 0;
-    dmr_alg_refresh (opts, state);
+  LFSR(state);
  fprintf (stderr, "\n");
  }
-  if (state->payload_algidR != 0) 
+  if (state->payload_algidR >= 0x21) 
  {
-    state->currentslot = 1;
+  state->currentslot = 1;
-    dmr_alg_refresh (opts, state);
+  LFSR(state);
  fprintf (stderr, "\n");
  }
  //failsafe to reset all data header and blocks when bad tact or emb
@@ -499,7 +471,6 @@ void dmrBSBootstrap (dsd_opts * opts, dsd_state * state)
  uint8_t cach_err = 0;
  uint8_t sync_okay = 1;
  uint8_t internalslot;
  char cachdata[25]; 
  int cachInterleave[24] =
@@ -532,7 +503,10 @@ void dmrBSBootstrap (dsd_opts * opts, dsd_state * state)
  {
    dibit = *dibit_p;
    dibit_p++;
-    if(opts->inverted_dmr == 1) dibit = (dibit ^ 2) & 3;
+    if(opts->inverted_dmr == 1)
    {
      dibit = (dibit ^ 2);
    }
    state->dmr_stereo_payload[i] = dibit;
  }
@@ -552,10 +526,15 @@ 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) goto END; 
+  if (tact_okay != 1)
  {
    if (opts->aggressive_framesync == 1)
    {
      goto END;
    } 
  }
-
+  state->currentslot = tact_bits[1];
  internalslot = state->currentslot = tact_bits[1];
  //Setup for first AMBE Frame
@@ -611,15 +590,17 @@ void dmrBSBootstrap (dsd_opts * opts, dsd_state * state)
  if ( strcmp (sync, DMR_BS_VOICE_SYNC) != 0)
  {
-    sync_okay = 0;
+    if (opts->aggressive_framesync == 1)
-    goto END; 
+    {
      sync_okay = 0;
      goto END;
    } 
  }
  //Continue Second AMBE Frame, 18 after Sync or EmbeddedSignalling
  for(i = 0; i < 18; i++)
  {
    dibit = getDibit(opts, state);
    state->dmr_stereo_payload[i+90] = dibit;
    ambe_fr2[*w][*x] = (1 & (dibit >> 1)); // bit 1
    ambe_fr2[*y][*z] = (1 & dibit);        // bit 0
@@ -642,7 +623,6 @@ void dmrBSBootstrap (dsd_opts * opts, dsd_state * state)
  for(i = 0; i < 36; i++)
  {
    dibit = getDibit(opts, state);
    state->dmr_stereo_payload[i+108] = dibit;
    ambe_fr3[*w][*x] = (1 & (dibit >> 1)); // bit 1
    ambe_fr3[*y][*z] = (1 & dibit);        // bit 0
@@ -653,26 +633,6 @@ void dmrBSBootstrap (dsd_opts * opts, dsd_state * state)
  }
  //'DSP' output to file
  if (opts->use_dsp_output == 1)
  {
    FILE * pFile; //file pointer
    pFile = fopen (opts->dsp_out_file, "a");
    fprintf (pFile, "\n%d 98 ", internalslot+1); //'98' is CACH designation value
    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, "\n%d 10 ", internalslot+1); //0x10 for "voice burst"
    for (i = 6; i < 72; i++) //33 bytes, no CACH
    {
      int dsp_byte = (state->dmr_stereo_payload[i*2] << 2) | state->dmr_stereo_payload[i*2 + 1];
      fprintf (pFile, "%X", dsp_byte);
    }
    fclose (pFile);
  }
  fprintf (stderr,"%s ", getTime());
  char polarity[3];
  char light[18];
@@ -680,14 +640,10 @@ void dmrBSBootstrap (dsd_opts * opts, dsd_state * state)
  if (state->currentslot == 0)
  {
    sprintf (light, "%s", " [SLOT1]  slot2  ");
    //open MBEout file - slot 1
    if ((opts->mbe_out_dir[0] != 0) && (opts->mbe_out_f == NULL)) openMbeOutFile (opts, state);
  } 
  else
  {
    sprintf (light, "%s", "  slot1  [SLOT2] ");
    //open MBEout file - slot 2
    if ((opts->mbe_out_dir[0] != 0) && (opts->mbe_out_fR == NULL)) openMbeOutFileR (opts, state);
  } 
  if (opts->inverted_dmr == 0) sprintf (polarity, "%s", "+");
  else sprintf (polarity, "%s", "-");
@@ -709,10 +665,10 @@ void dmrBSBootstrap (dsd_opts * opts, dsd_state * state)
  processMbeFrame (opts, state, NULL, ambe_fr3, NULL);
  //collect the mi fragment
-  dmr_late_entry_mi_fragment (opts, state, 1, m1, m2, m3);
+  dmr_late_entry_mi_fragment (opts, state, 1, ambe_fr, ambe_fr2, ambe_fr3);
  cach_err = dmr_cach (opts, state, cachdata);
-  if (opts->payload == 0) fprintf (stderr, "\n");
+  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);
@@ -727,17 +683,18 @@ void dmrBSBootstrap (dsd_opts * opts, dsd_state * state)
    fprintf (stderr, "%s", KRED);
    fprintf (stderr, "| VOICE CACH/SYNC 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)
    if (state->payload_algid != 0)
    {
      state->currentslot = 0;
-      dmr_alg_refresh (opts, state);
+      LFSR(state);
      fprintf (stderr, "\n");
    }
-    if (state->payload_algidR != 0) 
+    if (state->payload_algidR >= 0x21) 
    {
      state->currentslot = 1;
-      dmr_alg_refresh (opts, state);
+      LFSR(state);
      fprintf (stderr, "\n");
    }
    //failsafe to reset all data header and blocks when bad tact or emb
--- a/src/dmr_csbk.c
+++ b/src/dmr_csbk.c
--- a/src/dmr_data.c
+++ b/src/dmr_data.c
@@ -56,7 +56,6 @@ dmr_data_sync (dsd_opts * opts, dsd_state * state)
    {
      dibit = (int)state->dmr_stereo_payload[i];
    }
    else state->dmr_stereo_payload[i] = dibit;
    cachdata[cachInterleave[(i*2)]]   = (1 & (dibit >> 1)); // bit 1
    cachdata[cachInterleave[(i*2)+1]] = (1 & dibit);       // bit 0
@@ -75,10 +74,12 @@ dmr_data_sync (dsd_opts * opts, dsd_state * state)
  if ( Hamming_7_4_decode (tact_bits) ) cach_okay = 1;
  else
  {
    cach_okay = -1;
-    SlotTypeOk = 0;
+    if (opts->aggressive_framesync == 1)
-    goto END; 
+    {
      SlotTypeOk = 0;
      goto END;
    }
  }
  state->currentslot = tact_bits[1];
@@ -102,7 +103,6 @@ dmr_data_sync (dsd_opts * opts, dsd_state * state)
    {
      dibit = (int)state->dmr_stereo_payload[i+12];
    }
    else state->dmr_stereo_payload[i+12] = dibit;
    info[2*i]     = (1 & (dibit >> 1));  // bit 1
    info[(2*i)+1] = (1 & dibit);         // bit 0
  }
@@ -118,7 +118,6 @@ dmr_data_sync (dsd_opts * opts, dsd_state * state)
  {
    dibit = (int)state->dmr_stereo_payload[61]; 
  }
  else state->dmr_stereo_payload[61] = dibit;
  SlotType[0] = (1 & (dibit >> 1)); // bit 1
  SlotType[1] = (1 & dibit);        // bit 0
@@ -133,7 +132,6 @@ dmr_data_sync (dsd_opts * opts, dsd_state * state)
  {
    dibit = (int)state->dmr_stereo_payload[62];
  }
  else state->dmr_stereo_payload[62] = dibit;
  SlotType[2] = (1 & (dibit >> 1)); // bit 1
  SlotType[3] = (1 & dibit);        // bit 0
@@ -148,7 +146,6 @@ dmr_data_sync (dsd_opts * opts, dsd_state * state)
  {
    dibit = (int)state->dmr_stereo_payload[63]; 
  }
  else state->dmr_stereo_payload[63] = dibit;
  SlotType[4]  = (1 & (dibit >> 1)); // bit 1
  SlotType[5]  = (1 & dibit);        // bit 0
@@ -163,7 +160,6 @@ dmr_data_sync (dsd_opts * opts, dsd_state * state)
  {
    dibit = (int)state->dmr_stereo_payload[64]; 
  }
  else state->dmr_stereo_payload[64] = dibit;
  SlotType[6]  = (1 & (dibit >> 1)); // bit 1
  SlotType[7]  = (1 & dibit);        // bit 0
@@ -179,8 +175,6 @@ dmr_data_sync (dsd_opts * opts, dsd_state * state)
  {
    dibit = (int)state->dmr_stereo_payload[65];
  }
  else state->dmr_stereo_payload[65] = dibit;
  SlotType[8] = (1 & (dibit >> 1)); // bit 1
  SlotType[9] = (1 & dibit);        // bit 0
@@ -197,8 +191,6 @@ dmr_data_sync (dsd_opts * opts, dsd_state * state)
    {
      dibit = (int)state->dmr_stereo_payload[i+66]; 
    }
    else state->dmr_stereo_payload[i+66] = dibit;
    syncdata[2*i]     = (1 & (dibit >> 1));  // bit 1
    syncdata[(2*i)+1] = (1 & dibit);         // bit 0
    sync[i] = (dibit | 1) + 48;
@@ -244,7 +236,6 @@ dmr_data_sync (dsd_opts * opts, dsd_state * state)
    if (state->dmr_stereo == 0) 
    {
      dibit = getDibit(opts, state);
      state->dmr_stereo_payload[i+90] = dibit;
    }
    if (state->dmr_stereo == 1)
    {
@@ -260,9 +251,12 @@ dmr_data_sync (dsd_opts * opts, dsd_state * state)
  if( Golay_20_8_decode(SlotType) ) SlotTypeOk = 1;
  else
  {
-
+    SlotTypeOk = -1;
-    SlotTypeOk = 0;
+    if (opts->aggressive_framesync == 1)
-    goto END; 
+    {
      SlotTypeOk = 0;
      goto END;
    }
  }
  state->color_code = (SlotType[0] << 3) + (SlotType[1] << 2) +(SlotType[2] << 1) + (SlotType[3] << 0);
@@ -283,7 +277,6 @@ dmr_data_sync (dsd_opts * opts, dsd_state * state)
    if (state->dmr_stereo == 0) 
    {
      dibit = getDibit(opts, state);
      state->dmr_stereo_payload[i+95] = dibit;
    }
    if (state->dmr_stereo == 1)
@@ -295,11 +288,10 @@ dmr_data_sync (dsd_opts * opts, dsd_state * state)
    info[(2*i) + 99] = (1 & dibit);         // bit 0
  }
-  //don't run on MS Reverse Channel Data
+  dmr_data_burst_handler(opts, state, (uint8_t *)info, burst);
  if (state->dmr_ms_rc == 0) dmr_data_burst_handler(opts, state, (uint8_t *)info, burst);
  //don't run cach on simplex or mono
-  if (state->dmr_ms_mode == 0 && opts->dmr_mono == 0)
+  if (state->dmr_ms_mode == 0 || opts->dmr_mono == 0)
  {
    cach_err = dmr_cach (opts, state, cachdata);
  } 
@@ -345,7 +337,6 @@ dmr_data_sync (dsd_opts * opts, dsd_state * state)
      //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
    }
--- a/src/dmr_dburst.c
+++ b/src/dmr_dburst.c
@@ -9,11 +9,9 @@
 * 2022-12 DSD-FME Florida Man Edition
 *-----------------------------------------------------------------------------*/
-//WIP:  Unified Single Block Data - USBD -- TODO: USBD LIP Protocol Handling
+//TODO: CRC9 on confirmed data blocks; CRC32 on completed data sf;
-//WIP:  UDT Header and Blocks (coded - need samples)
+//TODO: Reverse Channel Signalling - RC single burst BPTC/7-bit CRC
-//WIP:  CRC9/CRC32 on Rate 1 Data (need samples)
+//TODO: Single Burst Embedded LC - Non-RC single burst LC - Look for Late Entry Alg/Key
 //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"
@@ -28,12 +26,6 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
  uint8_t slot = state->currentslot;
  uint8_t block = state->data_block_counter[slot];
  //confirmed data 
  uint8_t dbsn = 0; //data block serial number for confirmed data blocks
  uint8_t blockcounter = 0; //local block count
  uint8_t confdatabits[250]; //array to reshuffle conf data block bits into sequence for crc9 check
  memset (confdatabits, 0, sizeof(confdatabits));
  //BPTC 196x96 Specific
  uint8_t  BPTCDeInteleavedData[196];
  uint8_t  BPTCDmrDataBit[96];
@@ -45,31 +37,26 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
  uint8_t  LC_DataBytes[10];
  int Burst = -1;
-  //PDU Bytes and Bits
+  //Unified PDU (is this the best nomenclature) Bytes
-  uint8_t  DMR_PDU[25]; 
+  uint8_t  DMR_PDU[25]; //using 25 bytes as the max for now
-  uint8_t  DMR_PDU_bits[196]; 
+  uint8_t  DMR_PDU_bits[196]; //bitwise version of unified payload, will probably be a lot easier to use this w/ manual
  memset (DMR_PDU, 0, sizeof (DMR_PDU));
  memset (DMR_PDU_bits, 0, sizeof (DMR_PDU_bits));
  uint8_t  R[3];
  uint8_t  BPTCReservedBits = 0;
  uint8_t  is_ras = 0;
  uint8_t  crc_original_validity = 0;
  uint32_t crcmask = 0; 
-  uint8_t  crclen = 0;
+  uint8_t crclen = 0;
  uint8_t is_bptc = 0;
  uint8_t is_trellis = 0; 
  uint8_t is_emb = 0;
  uint8_t is_lc = 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 usbd_st = 0; //usbd service type 
  switch(databurst){
    case 0x00: //PI
      is_bptc = 1;
@@ -121,36 +108,32 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
      pdu_len = 12; //12 bytes
      sprintf(state->fsubtype, " DATA");
      break;
    //TODO - 1/2 0x0F0 - 3/4 0x1FF - Rate 1 0x10F 
    //going to set crclen and mask according to confirmed data here,
    //use block assmebler to carry out completed message crc
    case 0x07: //1/2 Rate Data
      is_bptc = 1;
      crclen = 9; //confirmed data only
      crcmask = 0x0F0; 
      pdu_len = 12; //12 bytes unconfirmed
      sprintf(state->fsubtype, " R12U ");
      if (state->data_conf_data[slot] == 1)
      {
        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 ");
      } 
      sprintf(state->fsubtype, " R12D ");
      break;
    case 0x08: //3/4 Rate Data
      is_trellis = 1;
      crclen = 9; //confirmed data only
      crcmask = 0x1FF;
      pdu_len = 18; //18 bytes unconfirmed
      sprintf(state->fsubtype, " R34U ");
      if (state->data_conf_data[slot] == 1)
      {
        pdu_len = 16; 
        pdu_start = 2; //start at plus two when assembling
        sprintf(state->fsubtype, " R34C ");
      } 
      sprintf(state->fsubtype, " R34D ");
      break;
    case 0x09: //Idle
      //pseudo-random data fill, no need to do anything with this
@@ -158,70 +141,33 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
      break;
    case 0x0A: //1 Rate Data
      crclen = 9; //confirmed data only
-      crcmask = 0x10F; 
+      crcmask = 0x1FF; 
      is_full = 1;
      pdu_len = 25; //196 bits - 24.5 bytes 
-      sprintf(state->fsubtype, " R_1U ");
+      sprintf(state->fsubtype, " R_1D ");
      if (state->data_conf_data[slot] == 1)
      {
        pdu_len = 23; 
        pdu_start = 2; //start at plus two when assembling
        sprintf(state->fsubtype, " R_1C ");
      }  
      break;
-    case 0x0B: //Unified Single Block Data USBD
+    case 0x0B: //Unified Data
      is_bptc = 1;
      crclen = 16;
      crcmask = 0x3333;
      pdu_len = 12; //12 bytes
-      sprintf(state->fsubtype, " USBD ");
+      sprintf(state->fsubtype, " UDAT ");
      break;
    //special types (not real data 'sync' bursts)
    case 0xEB: //Embedded Signalling
      crclen = 5;
      is_emb = 1;
      pdu_len = 9;
      break;
    default:
      //Slot Type FEC should catch this so we never see it,
      //but if it doesn't, then we can still dump the entire 'packet'
      //treat like rate 1 unconfirmed data 
      is_full = 1;
      pdu_len = 25; //196 bits - 24.5 bytes 
      sprintf(state->fsubtype, " _UNK "); 
      break;
  }
  //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);
    fprintf(stderr, "|%s", state->fsubtype);
    //'DSP' output to file
    if (opts->use_dsp_output == 1)
    {
      FILE * pFile; //file pointer
      pFile = fopen (opts->dsp_out_file, "a");
      fprintf (pFile, "\n%d 98 ", slot+1); //'98' is CACH designation value
      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); //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
      {
        int dsp_byte = (state->dmr_stereo_payload[i*2] << 2) | state->dmr_stereo_payload[i*2 + 1];
        fprintf (pFile, "%X", dsp_byte);
      }
      fclose (pFile);
    }
  }
  //Most Data Sync Burst types will use the bptc 196x96
@@ -238,10 +184,7 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
    IrrecoverableErrors = BPTC_196x96_Extract_Data(BPTCDeInteleavedData, BPTCDmrDataBit, R);
    /* Fill the reserved bit (R(0)-R(2) of the BPTC(196,96) block) */
-    BPTCReservedBits = (R[0] & 0x01) | ((R[1] << 1) & 0x02) | ((R[2] << 2) & 0x04);
+    BPTCReservedBits = (R[0] & 0x01) | ((R[1] << 1) & 0x02) | ((R[2] << 2) & 0x08);
    //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;
@@ -270,59 +213,20 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
    /* Check/correct the BPTC data and compute the Reed-Solomon (12,9) CRC */ 
    if (is_lc) CRCCorrect = ComputeAndCorrectFullLinkControlCrc(BPTCDmrDataByte, &CRCComputed, crcmask);
-    //set CRC to correct on unconfirmed 1/2 data blocks (for reporting due to no CRC available on these)
+    //TODO: run CRC9 on confirmed 1/2 data blocks
-    else if (state->data_conf_data[slot] == 0 && databurst == 0x7)
+    else if (state->data_conf_data[slot] == 1)
    {
-      CRCComputed = 0;
+      //run CRC on individual blocks according to type and validate each individual block
      CRCExtracted = 0;
      CRCCorrect = 1;
    } 
    //run CRC9 on intermediate and last 1/2 confirmed data blocks
    else if (state->data_conf_data[slot] == 1 && databurst == 0x7)
    {
      blockcounter = state->data_block_counter[slot]; //current block number according to the counter
      dbsn = (uint32_t)ConvertBitIntoBytes(&BPTCDmrDataBit[0], 7) + 1; //recover data block serial number
      CRCExtracted = (uint32_t)ConvertBitIntoBytes(&BPTCDmrDataBit[7], 9); //extract CRC from data
      CRCExtracted = CRCExtracted ^ crcmask;
      //reorganize the BPTCDmrDataBit array into confdatabits, just for CRC9 check
      //need to find a sample to confirm this
      for(i = 0; i < 80; i++) confdatabits[i] = BPTCDmrDataBit[i + 16];
      for(i = 0; i < 7; i++) confdatabits[i + 80] = BPTCDmrDataBit[i];
      CRCComputed = ComputeCrc9Bit(confdatabits, 87);
      if (CRCExtracted == CRCComputed)
      {
        CRCCorrect = 1;
        state->data_block_crc_valid[slot][blockcounter] = 1;
      } 
      else state->data_block_crc_valid[slot][blockcounter] = 0;
    }
    //run CCITT on other data forms
-    else 
+    else //will still run on unconfirmed data (shouldn't matter other than a possible bogus warning message)
    {
      CRCComputed = ComputeCrcCCITT(BPTCDmrDataBit); 
      if (CRCComputed == CRCExtracted) CRCCorrect = 1;
      else CRCCorrect = 0;
    } 
    //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; 
    //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 are okay
    //if we don't do this, then we can't view some data (CSBKs on RAS enabled systems) 
    if (is_ras == 1)
    {
      crc_original_validity = CRCCorrect;
      CRCCorrect = 1;
    } 
    if (databurst == 0x04 || databurst == 0x06) //MBC Header, Data Header
    {
      if (CRCCorrect)
@@ -345,7 +249,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 DMR_PDU and DMR_PDU_bits
+    //convert to unified DMR_PDU and DMR_PDU_bits
    for (i = 0; i < pdu_len; i++)
    {
      DMR_PDU[i] = BPTCDmrDataByte[i+pdu_start];
@@ -391,7 +295,11 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
    IrrecoverableErrors = BPTC_128x77_Extract_Data(BptcDataMatrix, LC_DataBit);
    /* Reconstitute the 5 bit CRC */
-    CRCExtracted = (uint32_t)ConvertBitIntoBytes(&LC_DataBit[72], 5);
+    CRCExtracted  = (LC_DataBit[72] & 1) << 4;
    CRCExtracted |= (LC_DataBit[73] & 1) << 3;
    CRCExtracted |= (LC_DataBit[74] & 1) << 2;
    CRCExtracted |= (LC_DataBit[75] & 1) << 1;
    CRCExtracted |= (LC_DataBit[76] & 1) << 0;
    /* Compute the 5 bit CRC */
    CRCComputed = ComputeCrc5Bit(LC_DataBit);
@@ -440,50 +348,6 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
      DMR_PDU[i] = (uint8_t)TrellisReturn[i+pdu_start]; 
    }
    for(i = 0, j = 0; i < 18; i++, j+=8)
    {
      DMR_PDU_bits[j + 0] = (TrellisReturn[i] >> 7) & 0x01;
      DMR_PDU_bits[j + 1] = (TrellisReturn[i] >> 6) & 0x01;
      DMR_PDU_bits[j + 2] = (TrellisReturn[i] >> 5) & 0x01;
      DMR_PDU_bits[j + 3] = (TrellisReturn[i] >> 4) & 0x01;
      DMR_PDU_bits[j + 4] = (TrellisReturn[i] >> 3) & 0x01;
      DMR_PDU_bits[j + 5] = (TrellisReturn[i] >> 2) & 0x01;
      DMR_PDU_bits[j + 6] = (TrellisReturn[i] >> 1) & 0x01;
      DMR_PDU_bits[j + 7] = (TrellisReturn[i] >> 0) & 0x01;
    }
    //set CRC to correct on unconfirmed 3/4 data blocks (for reporting due to no CRC available on these)
    if (state->data_conf_data[slot] == 0) CRCCorrect = 1;
    //run CRC9 on intermediate and last 3/4 data blocks
    else if (state->data_conf_data[slot] == 1)
    {
      blockcounter = state->data_block_counter[slot]; //current block number according to the counter
      dbsn = (uint32_t)ConvertBitIntoBytes(&DMR_PDU_bits[0], 7) + 1; //recover data block serial number
      CRCExtracted = (uint32_t)ConvertBitIntoBytes(&DMR_PDU_bits[7], 9); //extract CRC from data
      CRCExtracted = CRCExtracted ^ crcmask;
      //reorganize the DMR_PDU_bits array into confdatabits, just for CRC9 check
      //confirmed working now!
      for(i = 0; i < 128; i++) confdatabits[i] = DMR_PDU_bits[i + 16];
      for(i = 0; i < 7; i++) confdatabits[i + 128] = DMR_PDU_bits[i];
      CRCComputed = ComputeCrc9Bit(confdatabits, 135); 
      if (CRCExtracted == CRCComputed)
      {
        CRCCorrect = 1;
        state->data_block_crc_valid[slot][blockcounter] = 1;
      } 
      else
      {
        // IrrecoverableErrors = 9; //set as a shim since the trellis decoder is a pain to fix
        state->data_block_crc_valid[slot][blockcounter] = 0;
      } 
    }
    //reorganize the DMR_PDU_bits into PDU friendly format (minus the dbsn and crc9)
    memset (DMR_PDU_bits, 0, sizeof(DMR_PDU_bits));
    for(i = 0, j = 0; i < pdu_len; i++, j+=8)
    {
      DMR_PDU_bits[j + 0] = (TrellisReturn[i+pdu_start] >> 7) & 0x01;
@@ -496,13 +360,17 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
      DMR_PDU_bits[j + 7] = (TrellisReturn[i+pdu_start] >> 0) & 0x01;
    }
    //TODO: run CRC9 on confirmed 3/4 data blocks
  }
  if (is_full) //Rate 1 Data
  {
    CRCExtracted = 0;
    CRCComputed = 0;
-    IrrecoverableErrors = 0; //implicit, since there is no encoding
+    IrrecoverableErrors = 0;
    //TODO: run CRC9 on confirmed data
    for (i = 0; i < 24; i++)
    {
@@ -513,32 +381,6 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
    DMR_PDU[25] = (uint8_t)ConvertBitIntoBytes(&info[192], 4);
    DMR_PDU[25] = DMR_PDU[25] << 4;
    //set CRC to correct on unconfirmed 1 rate data blocks (for reporting due to no CRC available on these)
    if (state->data_conf_data[slot] == 0) CRCCorrect = 1;
    //run CRC9 on intermediate and last 1 rate data blocks
    else if (state->data_conf_data[slot] == 1)
    {
      blockcounter = state->data_block_counter[slot]; //current block number according to the counter
      dbsn = (uint32_t)ConvertBitIntoBytes(&info[0], 7) + 1; //recover data block serial number
      CRCExtracted = (uint32_t)ConvertBitIntoBytes(&info[7], 9); //extract CRC from data
      CRCExtracted = CRCExtracted ^ crcmask;
      //reorganize the info bit array into confdatabits, just for CRC9 check
      //unconfirmed, haven't seen any samples with rate 1 data
      for(i = 0; i < 176; i++) confdatabits[i] = info[i + 16];
      for(i = 0; i < 7; i++) confdatabits[i + 176] = info[i];
      CRCComputed = ComputeCrc9Bit(confdatabits, 183); 
      if (CRCExtracted == CRCComputed)
      {
        CRCCorrect = 1;
        state->data_block_crc_valid[slot][blockcounter] = 1;
      } 
      else state->data_block_crc_valid[slot][blockcounter] = 0;
    }
    //copy info to dmr_pdu_bits
    memcpy(DMR_PDU_bits, info, sizeof(DMR_PDU_bits));
@@ -553,75 +395,27 @@ 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, UDT) - type 1
+  //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, DMR_PDU_bits, CRCCorrect, IrrecoverableErrors);
+  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
  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
+  //if (databurst == 0x0A) dmr_block_assembler (opts, state, DMR_PDU, pdu_len, databurst, 1); //Full Rate Data - Disabled until further testing can be done
  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)
+  //is unified data handled like normal data, or control signalling data?
  if (databurst == 0x0B) dmr_block_assembler (opts, state, DMR_PDU, pdu_len, databurst, 1); //Unified Data
  //if (databurst == 0x0B) dmr_cspdu (opts, state, DMR_PDU_bits, DMR_PDU, CRCCorrect, IrrecoverableErrors);
  //control signalling types (CSBK, MBC, UDT)
  if (databurst == 0x03) dmr_cspdu (opts, state, DMR_PDU_bits, DMR_PDU, CRCCorrect, IrrecoverableErrors);
  //both MBC header and MBC continuation will go to the block_assembler - type 2, and then to dmr_cspdu 
  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 (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 && databurst != 0x09) //&& databurst != 0x05
  {
    fprintf (stderr, "%s", KRED);
    fprintf(stderr, " (FEC ERR)");
    fprintf (stderr, "%s", KNRM);
  } 
  //print whether or not the 'RAS Field' bits are set to indicate RAS enabled (to be verified)
  if (is_ras == 1)
  {
    fprintf (stderr, "%s", KRED);
    fprintf (stderr, " -RAS ");
    //the value of this field seems to always, or usually, be 4, or just R[2] bit is set
    if (opts->payload == 1) fprintf (stderr, "%X ", BPTCReservedBits);
    fprintf (stderr, "%s", KNRM);
  }
  if (IrrecoverableErrors == 0 && CRCCorrect == 0 && is_ras == 0 && databurst != 0x09 && databurst != 0x05)
  {
    fprintf (stderr, "%s", KRED);
    fprintf (stderr, " (CRC ERR) ");
    fprintf (stderr, "%s", KNRM);
  }
  //print the unified PDU format here, if not slot idle
  if (opts->payload == 1 && databurst != 0x09)
  {
@@ -633,12 +427,20 @@ void dmr_data_burst_handler(dsd_opts * opts, dsd_state * state, uint8_t info[196
      fprintf (stderr, "[%02X]", DMR_PDU[i]);
    }
    //debug print
    // if (dbsn) fprintf (stderr, " SN %X", dbsn);
    // fprintf (stderr, " CRC - EXT %X CMP %X", CRCExtracted, CRCComputed);
    fprintf (stderr, "%s", KNRM);
    // fprintf (stderr, "%s", KCYN);
    // fprintf (stderr, "\n  Hex to Ascii - ");
    // for (i = 0; i < 12; i++)
    // {
    //   if (DMR_PDU[i] <= 0x7E && DMR_PDU[i] >=0x20)
    //   {
    //     fprintf (stderr, "%c", DMR_PDU[i]);
    //   }
    //   else fprintf (stderr, ".");
    // }
    fprintf (stderr,"%s", KNRM);
  }
 }
--- a/src/dmr_flco.c
+++ b/src/dmr_flco.c
@@ -25,272 +25,73 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
  uint8_t so = 0;
  uint32_t target = 0;
  uint32_t source = 0;
  uint8_t capsite = 0; 
  int restchannel = -1;
  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 -- 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;
+  pf = (uint8_t)(lc_bits[0]); //Protect Flag
  reserved = (uint8_t)(lc_bits[1]); //Reserved 
  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
+  //look for Cap+ on VLC header, then set source and/or rest channel appropriately
-  if (IrrecoverableErrors == 0 && flco == 0x09 && fid == 0x68)
+  if (type == 1 && fid == 0x10 && flco == 0x04)
  {
-    sprintf (state->dmr_branding, "%s", "  Hytera"); 
+    is_cap_plus = 1;
-    sprintf (state->dmr_branding_sub, "XPT ");
+    restchannel = (int)ConvertBitIntoBytes(&lc_bits[48], 8);
    source = (uint32_t)ConvertBitIntoBytes(&lc_bits[56], 16);
    sprintf (state->dmr_branding, "%s", "Motorola");
    sprintf (state->dmr_branding_sub, "%s", "Cap+ ");
  }
  //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)
  {
    if (type == 1) fprintf (stderr, "%s \n", KRED);
    if (type == 2) fprintf (stderr, "%s \n", KRED);
    if (type == 3) fprintf (stderr, "%s", KRED);
    fprintf (stderr, " SLOT %d", state->currentslot+1);
    fprintf (stderr, " Protected LC ");
    goto END_FLCO; 
  } 
  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 || fid == 0x68) && type == 3 && flco == 0x04) 
+    if (type == 3 && flco == 0x04) 
    {
      dmr_embedded_alias_header(opts, state, lc_bits);
    }
    //Embedded Talker Alias Header (continuation) and Blocks
-    if ( (fid == 0 || fid == 0x68) && type == 3 && flco > 0x03 && flco < 0x08) 
+    if (type == 3 && flco > 0x3 && flco < 0x08) 
    {
      is_alias = 1;
      dmr_embedded_alias_blocks(opts, state, lc_bits);
    }
    //Embedded GPS
-    if ( (fid == 0 || fid == 0x68) && fid == 0 && type == 3 && flco == 0x08)
+    if (type == 3 && flco == 0x08)
    {
      is_gps = 1;
-      dmr_embedded_gps(opts, state, lc_bits);
+      if (fid == 0) dmr_embedded_gps(opts, state, lc_bits); //issues with fid 0x10 and flco 0x08
    }
-    //look for Cap+ on VLC header, then set source and/or rest channel appropriately
+      //NOTE: fid 0x10 and flco 0x08 produces a lot of 'zero' lat or lon values, I don't believe this is embedded gps
    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)) 
    {
      //NOTE: fid 0x10 and flco 0x08 (emb) produces a lot of 'zero' bytes
      //this has been observed to happen often on CapMax systems, so I believe it could be some CapMax 'thing'
-      //Unknown Link Control - FLCO=0x08 FID=0x10 SVC=0xC1 or FLCO=0x08 FID=0x10 SVC=0xC0 <- probably no SVC bits in the lc
+      //Unknown Link Control - FLCO=0x08 FID=0x10 SVC=0xC1 or FLCO=0x08 FID=0x10 SVC=0xC0 <-- have the enc bit set on svc, but these calls aren't enc?
-      //flco 0x28 has also been observed lately but the tg and src values don't match
+      //is this an encrypted embedded link control?
-      //another flco 0x10 does seem to match, so is probably capmax group call flco
+      else
      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, " Motorola");
      unk = 1;
      goto END_FLCO;
    }
    //7.1.1.1 Terminator Data Link Control PDU - ETSI TS 102 361-3 V1.2.1 (2013-07)
    if (type == 2 && flco == 0x30)
    {
      fprintf (stderr, "%s \n", KRED);
      fprintf (stderr, " SLOT %d", state->currentslot+1);
      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;
    }
    //Unknown Tait Things
    if (fid == 0x58)
    {
      //NOTE: fid 0x58 (tait) had a single flco 0x06 emb observed, but without the other blocks (4,5,7) for an alias
      //will need to observe this one, or just remove it from the list, going to isolate tait lc for now
      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, " Tait");
      unk = 1;
      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
+        fprintf (stderr, "%s", KGRN);
-        if (target > 248 && target < 255) fprintf (stderr, "Emergency ");
+        fprintf (stderr, " Slot %d Unknown EMB LC - FLCO=0x%02X FID=0x%02X SVC=0x%02X ", slot+1, flco, fid, so);
-        if (target == 255) fprintf (stderr, "All ");
+        fprintf (stderr, "%s", KNRM);
      } 
      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.
    //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);
      if (type == 3) fprintf (stderr, "%s", KYEL);
      fprintf (stderr, " SLOT %d", state->currentslot+1);
      fprintf (stderr, " Unknown LC ");
      unk = 1;
      goto END_FLCO;
    }
  }  
  //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
@@ -330,7 +131,6 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
        // state->lastsrc = 0;
        state->payload_algid = 0;
        state->payload_mi = 0;
        state->payload_keyid = 0;
      }
      if (state->currentslot == 1)
      {
@@ -340,7 +140,6 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
        // state->lastsrcR = 0;
        state->payload_algidR = 0;
        state->payload_miR = 0;
        state->payload_keyidR = 0;
      }
    }
@@ -361,40 +160,16 @@ 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)
+    if (flco == 3) //UU_V_Ch_Usr 
    //0x07 on a VLC seems to indicate a Cap+ Private Call Header
    //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+");
+      sprintf (state->call_string[slot], " Private");
      fprintf (stderr, "Cap+ ");
      if (flco == 0x4)
      {
        strcat (state->call_string[slot], " Grp");
        fprintf (stderr, "Group ");
      }
      else
      {
        strcat (state->call_string[slot], " Pri");
        fprintf (stderr, "Private ");
      } 
    }
    else if (flco == 0x3) //UU_V_Ch_Usr
    {
      sprintf (state->call_string[slot], " Private ");
      fprintf (stderr, "Private "); 
    } 
-    else //Grp_V_Ch_Usr -- still valid on hytera VLC
+    else //Grp_V_Ch_Usr
    {
-      sprintf (state->call_string[slot], "   Group ");
+      sprintf (state->call_string[slot], "   Group");
      fprintf (stderr, "Group "); 
    } 
@@ -416,76 +191,70 @@ 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], "          ");
-    //Motorola FID 0x10 Only
+    /* Check the "Service Option" bits */ 
-    if (fid == 0x10)
+    if(so & 0x30)
    {
-      /* Check the "Service Option" bits */ 
+      /* Experimentally determined with DSD+,
-      if(so & 0x30)
+      * is equal to 0x2, this is a TXI call */
-      {
+      if((so & 0x30) == 0x20)
        /* 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], "-BC   ");
+        // strcat (state->call_string[slot], " TXI");
-        fprintf(stderr, "Broadcast ");
+        fprintf(stderr, "TXI ");
      } 
-      if(so & 0x04)
+      else
      {
        //REMUS! Uncomment Line Below if desired
-        // strcat (state->call_string[slot], "-OVCM ");
+        // strcat (state->call_string[slot], " RES");
-        fprintf(stderr, "OVCM ");
+        fprintf(stderr, "Reserved=%d ", (so & 0x30) >> 4);
      } 
-      if(so & 0x03)
+    }
    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) == 0x01)
+        //REMUS! Uncomment Line Below if desired
-        {
+        // strcat (state->call_string[slot], "-P1");
-          //REMUS! Uncomment Line Below if desired
+        fprintf(stderr, "Priority 1 ");
-          // strcat (state->call_string[slot], "-P1");
+      } 
-          fprintf(stderr, "Priority 1 ");
+      else if((so & 0x03) == 0x02)
-        } 
+      {
-        else if((so & 0x03) == 0x02)
+        //REMUS! Uncomment Line Below if desired
-        {
+        // strcat (state->call_string[slot], "-P2");
-          //REMUS! Uncomment Line Below if desired
+        fprintf(stderr, "Priority 2 ");
-          // strcat (state->call_string[slot], "-P2");
+      } 
-          fprintf(stderr, "Priority 2 ");
+      else if((so & 0x03) == 0x03)
-        } 
+      {
-        else if((so & 0x03) == 0x03)
+        //REMUS! Uncomment Line Below if desired
-        {
+        // strcat (state->call_string[slot], "-P3");
-          //REMUS! Uncomment Line Below if desired
+        fprintf(stderr, "Priority 3 ");
-          // strcat (state->call_string[slot], "-P3");
+      } 
-          fprintf(stderr, "Priority 3 ");
+      else /* We should never go here */
-        } 
+      {
-        else /* We should never go here */
+        //REMUS! Uncomment Line Below if desired
-        {
+        // strcat (state->call_string[slot], "  ");
-          //REMUS! Uncomment Line Below if desired
+        fprintf(stderr, "No Priority "); 
          // 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 ");
    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/RAS)");
    else fprintf(stderr, "(FEC/CRC ERR)");
    //check Cap+ rest channel info if available and good fec
    if (is_cap_plus == 1)
@@ -530,23 +299,6 @@ void dmr_flco (dsd_opts * opts, dsd_state * state, uint8_t lc_bits[], uint32_t C
  }
  END_FLCO:
  if (unk == 1 || pf == 1)
  {
    fprintf(stderr, " FLCO=0x%02X FID=0x%02X ", flco, fid);
    fprintf (stderr, "%s", KNRM);
  }
  if(IrrecoverableErrors != 0)
  {
    if (type != 3) fprintf (stderr, "\n");
    fprintf (stderr, "%s", KRED);
    fprintf (stderr, " SLOT %d", state->currentslot+1);
    fprintf (stderr, " FLCO FEC ERR ");
    fprintf (stderr, "%s", KNRM);
  }
 }
 //externalized dmr cach - tact and slco fragment handling
@@ -800,17 +552,8 @@ 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[22], 3); //Seems more consistent
+  uint8_t restchannel = (uint8_t)ConvertBitIntoBytes(&slco_bits[12], 8);
  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");
@@ -859,12 +602,18 @@ 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)
  {
    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);
@@ -878,24 +627,19 @@ void dmr_slco (dsd_opts * opts, dsd_state * state, uint8_t slco_bits[])
  else if (slco == 0xF)
  {
-    fprintf (stderr, " SLCO Capacity Plus Site: %d - Rest Channel %d - RS: %02X", capsite, restchannel, cap_reserved);
+    state->dmr_mfid = 0x10;
    sprintf (state->dmr_branding, "%s", "Motorola");
    sprintf (state->dmr_branding_sub, "%s", "Cap+ ");
    fprintf (stderr, " SLCO Capacity Plus Rest Channel %d", restchannel);
    state->dmr_rest_channel = restchannel;
    //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)
-  else if (slco == 0x08)
+    sprintf(state->dmr_site_parms, "%s", "");
  {
    //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);
@@ -907,7 +651,6 @@ 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);
@@ -948,10 +691,6 @@ 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
--- a/src/dmr_le.c
+++ b/src/dmr_le.c
@@ -77,12 +77,6 @@ void dmr_late_entry_mi (dsd_opts * opts, dsd_state * state)
        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)
    {
@@ -93,12 +87,6 @@ void dmr_late_entry_mi (dsd_opts * opts, dsd_state * state)
        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");
      } 
    }
  }
@@ -116,13 +104,11 @@ 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)
  {
@@ -133,13 +119,11 @@ 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
  }
 }
@@ -151,166 +135,5 @@ void dmr_alg_reset (dsd_opts * opts, dsd_state * state)
  state->DMRvcL = 0;
  state->DMRvcR = 0; 
  state->payload_miP = 0; 
  state->payload_miN = 0; 
 }
 //handle Single Burst (Voice Burst F) or Reverse Channel Signalling 
 void dmr_sbrc (dsd_opts * opts, dsd_state * state, uint8_t power)
 {
  int i;
  uint8_t slot = state->currentslot;
  uint8_t sbrc_interleaved[32];
  uint8_t sbrc_return[32];
  memset (sbrc_interleaved, 0, sizeof(sbrc_interleaved));
  memset (sbrc_return, 0, sizeof(sbrc_return));
  uint32_t irr_err = 0;
  uint32_t sbrc_hex = 0;
  uint16_t crc_extracted = 7777;
  uint16_t crc_computed = 9999;
  uint8_t crc_okay = 0;
  // 9.3.2 Pre-emption and power control Indicator (PI)
  // 0 - The embedded signalling carries information associated to the same logical channel or the Null embedded message
  // 1 - The embedded signalling carries RC information associated to the other logical channel
  for(i = 0; i < 32; i++) sbrc_interleaved[i] = state->dmr_embedded_signalling[slot][5][i + 8];
  //power == 0 should be single burst
  if (power == 0) irr_err = BPTC_16x2_Extract_Data(sbrc_interleaved, sbrc_return, 0);
  //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;
  //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 and 0x643)
  if (power == 1) //RC
  {
    crc_extracted = 0;
    for (i = 0; i < 7; i++)
    {
      crc_extracted = crc_extracted << 1;
      crc_extracted = crc_extracted | sbrc_return[i+4];
    }
    crc_extracted = crc_extracted ^ 0x7A;
    crc_computed = crc7((uint8_t *) sbrc_return, 11);
    if (crc_extracted == crc_computed) crc_okay = 1;
  }
  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
  {
    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);
    if (crc_okay == 0)
    {
      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);
    }
  }
  //Disabling the lower portion until this can be completely ironed out
  //sbrc_hex value of 0x313 seems to be some Cap+ Thing, 
  //also observed 0x643 on another cap+ system (site id, status? something?)
  // uint8_t sbrc_opcode = sbrc_hex; 
  // uint8_t alg = sbrc_hex & 0x7;
  // uint8_t key = (sbrc_hex >> 3) & 0xFF;
  //this pattern seems to fit the multiple cap+ systems I've observed
  //test on site '7' to make sure (works on 1 and 4)
  // uint8_t cap_site = (sbrc_hex >> 4) & 0x7;
  // if (opts->payload == 1)
  // {
  //   if (irr_err != 0) fprintf (stderr, "%s (FEC ERR) %d %s", KRED, irr_err, KNRM);
  //   if (irr_err == 0)
  //   {
  //     if (sbrc_hex == 0) ; //NULL
  //     else if (strcmp (state->dmr_branding_sub, "Cap+ ") == 0)
  //     {
  //       //Cap+ Site ID seems to fit here on samples I've seen with the alternate SB signalling, but no idea what signals that info and not the emb alg/key info
  //       fprintf (stderr, "%s ", KYEL);
  //       fprintf (stderr, "\n ");
  //       fprintf (stderr, " Capacity Plus Site %d", cap_site);
  //       fprintf (stderr, "%s ", KNRM);
  //     } 
  //     else
  //     {
  //       if (slot == 0)
  //       {
  //         //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)
  //           {
  //             fprintf (stderr, "%s ", KYEL);
  //             fprintf (stderr, "\n Slot 1");
  //             fprintf (stderr, " DMR LE SB ALG ID: %X KEY ID: %0X", alg + 0x20, key);
  //             fprintf (stderr, "%s ", KNRM);
  //           }
  //           //needs more study before assignment
  //           // state->payload_keyid = key;
  //           // state->payload_algid = alg + 0x20; //assuming DMRA approved alg values (moto patent)
  //         }
  //       }
  //       if (slot == 1)
  //       {
  //         if (state->dmr_soR & 0x40 && key != 0 && state->payload_keyidR == 0)
  //         {
  //           if (opts->payload == 1)
  //           {
  //             fprintf (stderr, "%s ", KYEL);
  //             fprintf (stderr, "\n Slot 2");
  //             fprintf (stderr, " DMR LE SB ALG ID: %X KEY ID: %0X", alg + 0x20, key);
  //             fprintf (stderr, "%s ", KNRM);
  //           }
  //           //needs more study before assignment
  //           // state->payload_keyidR = key;
  //           // state->payload_algidR = alg + 0x20; //assuming DMRA approved alg values (moto patent)
  //         }
  //       }
  //     }
  //   }
  // }
  SBRC_END:
  //'DSP' output to file -- only RC, or RC and SB?
  if (power == 1 && opts->use_dsp_output == 1 && sbrc_hex != 0) //if not NULL
  {
    FILE * pFile; //file pointer
    pFile = fopen (opts->dsp_out_file, "a");
    fprintf (pFile, "\n%d 99 ", slot+1); //'99' is RC designation value
    int k = 0;
    for (i = 0; i < 24; i++) //12 bytes, SB or RC
    {
      //check to see if k++ starts at zero, or at 1
      int sbrc_nib = (state->dmr_embedded_signalling[slot][5][k++] << 3) | (state->dmr_embedded_signalling[slot][5][k++] << 2) | (state->dmr_embedded_signalling[slot][5][k++] << 1) | (state->dmr_embedded_signalling[slot][5][k++] << 0);
      fprintf (pFile, "%X", sbrc_nib);
    }
    fclose (pFile);
  } 
 }
--- a/src/dmr_ms.c
+++ b/src/dmr_ms.c
@@ -50,11 +50,6 @@ void dmrMS (dsd_opts * opts, dsd_state * state)
  uint8_t internalslot;
  uint8_t vc;
  //assign as nonsensical numbers
  uint8_t cc = 25;
  uint8_t power = 9; //power and pre-emption indicator
  uint8_t lcss = 9;
  //dummy bits to pass to dburst for link control
  uint8_t dummy_bits[196];
  memset (dummy_bits, 0, sizeof (dummy_bits));
@@ -92,7 +87,7 @@ void dmrMS (dsd_opts * opts, dsd_state * state)
  for(i = 0; i < 12; i++)
  {
    dibit = getDibit(opts, state);
-    if(opts->inverted_dmr == 1) dibit = (dibit ^ 2) & 3;
+    if(opts->inverted_dmr == 1) dibit = (dibit ^ 2);
    cachdata[i] = dibit;
    state->dmr_stereo_payload[i] = dibit;
@@ -124,7 +119,7 @@ void dmrMS (dsd_opts * opts, dsd_state * state)
  for(i = 0; i < 36; i++)
  {
    dibit = getDibit(opts, state);
-    if(opts->inverted_dmr == 1) dibit = (dibit ^ 2) & 3;
+    if(opts->inverted_dmr == 1) dibit = (dibit ^ 2);
    state->dmr_stereo_payload[i+12] = dibit;
@@ -149,7 +144,7 @@ void dmrMS (dsd_opts * opts, dsd_state * state)
  for(i = 0; i < 18; i++)
  {
    dibit = getDibit(opts, state);
-    if(opts->inverted_dmr == 1) dibit = (dibit ^ 2) & 3;
+    if(opts->inverted_dmr == 1) dibit = (dibit ^ 2);
    state->dmr_stereo_payload[i+48] = dibit;
    ambe_fr2[*w][*x] = (1 & (dibit >> 1)); // bit 1
@@ -166,7 +161,7 @@ void dmrMS (dsd_opts * opts, dsd_state * state)
  for(i = 0; i < 24; i++)
  {
    dibit = getDibit(opts, state);
-    if(opts->inverted_dmr == 1) dibit = (dibit ^ 2) & 3;
+    if(opts->inverted_dmr == 1) dibit = (dibit ^ 2);
    state->dmr_stereo_payload[i+66] = dibit;
@@ -176,7 +171,7 @@ void dmrMS (dsd_opts * opts, dsd_state * state)
    sync[i] = (dibit | 1) + 48;
    // load the superframe to do embedded signal processing
-    if(vc > 1) //grab on vc1 values 2-5 B C D and E (F for Single/RC)
+    if(vc > 1 && vc < 6) //grab on vc1 values 2-5 B C D and E
    {
      state->dmr_embedded_signalling[internalslot][vc-1][i*2]   = (1 & (dibit >> 1)); // bit 1
      state->dmr_embedded_signalling[internalslot][vc-1][i*2+1] = (1 & dibit); // bit 0
@@ -185,40 +180,17 @@ void dmrMS (dsd_opts * opts, dsd_state * state)
  }
  sync[24] = 0;
  //test for RC sync pattern in MS sourced audio
  if ( strcmp (sync, DMR_RC_DATA_SYNC) == 0)
  {
    state->dmr_ms_rc = 1;
    fprintf (stderr, "%s ", getTime());
    if (opts->inverted_dmr == 0)
    {
      fprintf (stderr,"Sync: +DMR MS/DM MODE/MONO ");
    }
    else fprintf (stderr,"Sync: -DMR MS/DM MODE/MONO ");
    fprintf (stderr, "| RC ");
    fprintf (stderr, "\n");
  }
  for(i = 0; i < 8; i++) EmbeddedSignalling[i] = syncdata[i];
  for(i = 0; i < 8; i++) EmbeddedSignalling[i + 8] = syncdata[i + 40];
  EmbeddedSignallingOk = -1;
  if(QR_16_7_6_decode(EmbeddedSignalling))
  {
    EmbeddedSignallingOk = 1;
    cc = ((EmbeddedSignalling[0] << 3) + (EmbeddedSignalling[1] << 2) + (EmbeddedSignalling[2] << 1) + EmbeddedSignalling[3]);
    power = EmbeddedSignalling[4];
    lcss = ((EmbeddedSignalling[5] << 1) + EmbeddedSignalling[6]);
  }
  //Continue Second AMBE Frame, 18 after Sync or EmbeddedSignalling
  for(i = 0; i < 18; i++)
  {
    dibit = getDibit(opts, state);
-    if(opts->inverted_dmr == 1) dibit = (dibit ^ 2) & 3;
+    if(opts->inverted_dmr == 1) dibit = (dibit ^ 2);
    state->dmr_stereo_payload[i+90] = dibit;
    ambe_fr2[*w][*x] = (1 & (dibit >> 1)); // bit 1
@@ -242,7 +214,7 @@ void dmrMS (dsd_opts * opts, dsd_state * state)
  for(i = 0; i < 36; i++)
  {
    dibit = getDibit(opts, state);
-    if(opts->inverted_dmr == 1) dibit = (dibit ^ 2) & 3;
+    if(opts->inverted_dmr == 1) dibit = (dibit ^ 2);
    state->dmr_stereo_payload[i+108] = dibit;
    ambe_fr3[*w][*x] = (1 & (dibit >> 1)); // bit 1
@@ -255,20 +227,6 @@ void dmrMS (dsd_opts * opts, dsd_state * state)
  }
  //'DSP' output to file
  if (opts->use_dsp_output == 1)
  {
    FILE * pFile; //file pointer
    pFile = fopen (opts->dsp_out_file, "a");
    fprintf (pFile, "\n%d 10 ", state->currentslot+1); //0x10 for "voice burst", forced to slot 1
    for (i = 6; i < 72; i++) //33 bytes, no CACH
    {
      int dsp_byte = (state->dmr_stereo_payload[i*2] << 2) | state->dmr_stereo_payload[i*2 + 1];
      fprintf (pFile, "%X", dsp_byte);
    }
    fclose (pFile);
  }
  state->dmr_ms_mode = 1;
  memcpy (ambe_fr4, ambe_fr2, sizeof(ambe_fr2));
@@ -280,28 +238,22 @@ void dmrMS (dsd_opts * opts, dsd_state * state)
  memcpy (m2, ambe_fr2, sizeof(m2));
  memcpy (m3, ambe_fr3, sizeof(m3));
-  if (state->dmr_ms_rc == 0)
+  if (state->directmode == 0)
  {
-    if (state->directmode == 0)
+    processMbeFrame (opts, state, NULL, ambe_fr, NULL);
-    {
+    processMbeFrame (opts, state, NULL, ambe_fr2, NULL);
-      processMbeFrame (opts, state, NULL, ambe_fr, NULL);
+    processMbeFrame (opts, state, NULL, ambe_fr3, NULL);
-      processMbeFrame (opts, state, NULL, ambe_fr2, NULL);
+  }
-      processMbeFrame (opts, state, NULL, ambe_fr3, NULL);
+  else
-    }
+  {
-    else
+    processMbeFrame (opts, state, NULL, ambe_fr4, NULL); //play duplicate of 2 here to smooth audio on tdma direct
-    {
+    processMbeFrame (opts, state, NULL, ambe_fr2, NULL);
-      processMbeFrame (opts, state, NULL, ambe_fr4, NULL); //play duplicate of 2 here to smooth audio on tdma direct
+    processMbeFrame (opts, state, NULL, ambe_fr3, NULL);
      processMbeFrame (opts, state, NULL, ambe_fr2, NULL);
      processMbeFrame (opts, state, NULL, ambe_fr3, NULL);
    }
  }
  if (vc == 6)
  {
    dmr_data_burst_handler(opts, state, (uint8_t *)dummy_bits, 0xEB);
    //check the single burst/reverse channel opportunity
    dmr_sbrc (opts, state, power);
    fprintf (stderr, "\n");
    dmr_alg_refresh (opts, state);
  }
@@ -316,12 +268,6 @@ void dmrMS (dsd_opts * opts, dsd_state * state)
  state->last_vc_sync_time = time(NULL);
  vc++;
  //reset emb components
  cc = 25;
  power = 9; //power and pre-emption indicator
  lcss = 9;
  //this is necessary because we need to skip and collect dibits, not just skip them
  if (vc > 6) goto END; 
@@ -346,7 +292,7 @@ void dmrMS (dsd_opts * opts, dsd_state * state)
   dibit = getDibit(opts, state);
   if (opts->inverted_dmr == 1)
   {
-     dibit = (dibit ^ 2) & 3;
+     dibit = (dibit ^ 2);
   }
   state->dmr_stereo_payload[i] = dibit;
@@ -433,7 +379,7 @@ void dmrMSBootstrap (dsd_opts * opts, dsd_state * state)
    dibit = state->dmr_stereo_payload[i];
    if(opts->inverted_dmr == 1)
    {
-      dibit = (dibit ^ 2) & 3;
+      dibit = (dibit ^ 2);
    }
    cachdata[i] = dibit;
  }
@@ -452,7 +398,7 @@ void dmrMSBootstrap (dsd_opts * opts, dsd_state * state)
    dibit = state->dmr_stereo_payload[i+12];
    if(opts->inverted_dmr == 1)
    {
-      dibit = (dibit ^ 2) & 3;
+      dibit = (dibit ^ 2);
    }
    state->dmr_stereo_payload[i+12] = dibit;
    ambe_fr[*w][*x] = (1 & (dibit >> 1)); // bit 1
@@ -479,7 +425,7 @@ void dmrMSBootstrap (dsd_opts * opts, dsd_state * state)
    dibit = state->dmr_stereo_payload[i+48];
    if(opts->inverted_dmr == 1)
    {
-      dibit = (dibit ^ 2) & 3;
+      dibit = (dibit ^ 2);
    }
    ambe_fr2[*w][*x] = (1 & (dibit >> 1)); // bit 1
    ambe_fr2[*y][*z] = (1 & dibit);        // bit 0
@@ -497,9 +443,8 @@ void dmrMSBootstrap (dsd_opts * opts, dsd_state * state)
    dibit = getDibit(opts, state);
    if(opts->inverted_dmr == 1)
    {
-      dibit = (dibit ^ 2) & 3;
+      dibit = (dibit ^ 2);
    }
    state->dmr_stereo_payload[i+90] = dibit;
    ambe_fr2[*w][*x] = (1 & (dibit >> 1)); // bit 1
    ambe_fr2[*y][*z] = (1 & dibit);        // bit 0
@@ -524,9 +469,8 @@ void dmrMSBootstrap (dsd_opts * opts, dsd_state * state)
    dibit = getDibit(opts, state);
    if(opts->inverted_dmr == 1)
    {
-      dibit = (dibit ^ 2) & 3;
+      dibit = (dibit ^ 2);
    }
    state->dmr_stereo_payload[i+108] = dibit;
    ambe_fr3[*w][*x] = (1 & (dibit >> 1)); // bit 1
    ambe_fr3[*y][*z] = (1 & dibit);        // bit 0
@@ -537,20 +481,6 @@ void dmrMSBootstrap (dsd_opts * opts, dsd_state * state)
  }
  //'DSP' output to file
  if (opts->use_dsp_output == 1)
  {
    FILE * pFile; //file pointer
    pFile = fopen (opts->dsp_out_file, "a");
    fprintf (pFile, "\n%d 10 ", state->currentslot+1); //0x10 for "voice burst", force to slot 1
    for (i = 6; i < 72; i++) //33 bytes, no CACH
    {
      int dsp_byte = (state->dmr_stereo_payload[i*2] << 2) | state->dmr_stereo_payload[i*2 + 1];
      fprintf (pFile, "%X", dsp_byte);
    }
    fclose (pFile);
  }
  fprintf (stderr, "%s ", getTime());
  if (opts->inverted_dmr == 0)
  {
@@ -587,7 +517,7 @@ void dmrMSBootstrap (dsd_opts * opts, dsd_state * state)
  }
  //collect the mi fragment
-  dmr_late_entry_mi_fragment (opts, state, 1, m1, m2, m3);
+  dmr_late_entry_mi_fragment (opts, state, 1, ambe_fr, ambe_fr2, ambe_fr3);
  //errors due to skipping other slot
  // cach_err = dmr_cach (opts, state, cachdata);
@@ -628,7 +558,7 @@ void dmrMSData (dsd_opts * opts, dsd_state * state)
  {
    dibit = *dibit_p;
    dibit_p++;
-    if(opts->inverted_dmr == 1) dibit = (dibit ^ 2) & 3;
+    if(opts->inverted_dmr == 1) dibit = (dibit ^ 2);
    state->dmr_stereo_payload[i] = dibit;
  }
@@ -636,7 +566,7 @@ void dmrMSData (dsd_opts * opts, dsd_state * state)
  for (i = 0; i < 54; i++)
  {
    dibit = getDibit(opts, state);
-    if(opts->inverted_dmr == 1) dibit = (dibit ^ 2) & 3;
+    if(opts->inverted_dmr == 1) dibit = (dibit ^ 2);
    state->dmr_stereo_payload[i+90] = dibit;
  }
--- a/src/dmr_pdu.c
+++ b/src/dmr_pdu.c
@@ -44,9 +44,9 @@ 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;
-  //check for more available flag info, etc on these prior to running
+  //consider disabling on prop_head data blocks if bad/false decodes
-  if (DMR_PDU[0] == 0x01) dmr_locn (opts, state, block_len, DMR_PDU);
+  //if (state->data_p_head[slot] == 0)
-  else dmr_lrrp (opts, state, block_len, DMR_PDU);
+   lrrp_conf = 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 
@@ -57,7 +57,7 @@ void dmr_pdu (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR
 //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)
-void dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR_PDU[])
+uint8_t dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DMR_PDU[])
 {
  int i, j;
  uint16_t message_len = 0;
@@ -82,15 +82,12 @@ void dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DM
  //lat-long-radius-alt
  uint32_t lat = 0;
  uint8_t lat_sign = 0;
  uint32_t lon = 0;
-  uint16_t rad = 0; //or Azimuth in Circle 3D?
+  uint16_t rad = 0;
  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;
@@ -101,17 +98,26 @@ void dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DM
  uint8_t degrees = 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 = 0; i < ( (blocks*block_len) - (padding+4) ); i++) 
+  for (i; i < ( (blocks*block_len) - (padding+4) ); i++) 
  {
    switch(DMR_PDU[i]){
@@ -168,22 +174,20 @@ void dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DM
        }
        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 
+      case 0x55: //circle-3d <- false positives on one sample, so either an earlier token occurred (that we don't have) or just random data?
        if (message_len > 0 && lat == 0)
        {
-          // lat = ( ( ((DMR_PDU[i+1] & 0x7F ) <<  24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
+          if (DMR_PDU[i+1] & 0x80) lat_sign = 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] & 0x7F ) <<  24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 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; 
+          i += 10; //double check
          if (lat > 0 && lon > 0) lrrp_confidence++; //would be better to set by absolute boundary (180 and 90?)
          else lat = 0;
        }
@@ -209,11 +213,10 @@ void dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DM
      case 0x66: //point-2d
        if (message_len > 0 && lat == 0)
        {
-          // lat = ( ( ((DMR_PDU[i+1] & 0x7F ) <<  24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
+          if (DMR_PDU[i+1] & 0x80) lat_sign = 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] & 0x7F ) <<  24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 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; 
+          i += 8; //check
          lrrp_confidence++;
        }
        break;
@@ -221,13 +224,12 @@ void dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DM
      case 0x6A: //point-3d
        if (message_len > 0 && lat == 0)
        {
-          // lat = ( ( ((DMR_PDU[i+1] & 0x7F ) <<  24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 1 );
+          if (DMR_PDU[i+1] & 0x80) lat_sign = 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] & 0x7F ) <<  24 ) + (DMR_PDU[i+2] << 16) + (DMR_PDU[i+3] << 8) + DMR_PDU[i+4]) * 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; 
+          i += 9; //check
-          if (lat > 0 && lon > 0) lrrp_confidence++; 
+          if (lat > 0 && lon > 0) lrrp_confidence++; //would be better to set by absolute boundary (180 and 90?)
          else lat = 0;
        }
        break;
@@ -271,7 +273,7 @@ void dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DM
  {
    fprintf (stderr, "%s", KYEL);
    fprintf (stderr, "\n LRRP Confidence: %d - Message Len: %d Octets", lrrp_confidence, message_len);
-    if (lrrp_confidence >= 3) //find the sweet magical number
+    if (lrrp_confidence >= 4) //find the sweet magical number
    {
      //now we can open our lrrp file and write to it as well
      FILE * pFile; //file pointer
@@ -283,10 +285,9 @@ void dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DM
        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 if not available in lrrp data
+        //write data header source (or destination?) 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)
@@ -326,45 +327,31 @@ void dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DM
      if (lat)
      {
        fprintf (stderr, "\n");
-        //need to check these new calcs for accuracy accross the globe, both lat and lon
+        if (lat_sign) //print a '-' in front of the value
-
+          fprintf (stderr, "  LRRP - Lat: -%.5lf", (double)lat * lat_unit);
-        //two's compliment-ish testing on these bytes
+        else fprintf (stderr, "  LRRP - Lat: %.5lf", (double)lat * lat_unit);
-        if (lat & 0x80000000) //8
+        fprintf (stderr, "  Lon: %.5lf", (double)lon * lon_unit);
-        {
+        if (lat_sign)
-          lat = lat & 0x7FFFFFFF;
+          fprintf (stderr, " (-%.5lf, %.5lf)", (double)lat * lat_unit , (double)lon * lon_unit);
-          lat_sign = -1;
+        else fprintf (stderr, " (%.5lf, %.5lf)", (double)lat * lat_unit , (double)lon * lon_unit);
          // 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)
        {
-          fprintf (pFile, "%.5lf\t", lat_fin);
+          if (lat_sign) fprintf (pFile, "-");
-          fprintf (pFile, "%.5lf\t", lon_fin);
+          fprintf (pFile, "%.5lf\t", (double)lat * lat_unit);
          fprintf (pFile, "%.5lf\t", (double)lon * lon_unit);
        }
      }
      if (rad)
      {
        fprintf (stderr, "\n");
-        fprintf (stderr, "  LRRP - Radius: %dm", rad); //unsure of 'units' or calculation for radius (meters?)
+        fprintf (stderr, "  LRRP - Radius: %d", rad); //unsure of 'units' or calculation for radius (meters?)
      }
      if (alt)
      {
        fprintf (stderr, "\n");
-        fprintf (stderr, "  LRRP - Altitude: %dm", alt); //unsure of 'units' or calculation for alt (meters?)
+        fprintf (stderr, "  LRRP - Altitude: %d", alt); //unsure of 'units' or calculation for alt (meters?)
      }
      if (vel_set)
      {
@@ -375,7 +362,7 @@ void dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DM
      if (deg_set)
      {
        fprintf (stderr, "\n");
-        fprintf (stderr, "  LRRP - Track: %d%s", degrees, deg_glyph);
+        fprintf (stderr, "  LRRP - Track: %d Degrees", degrees);
        if (opts->lrrp_file_output == 1) fprintf (pFile, "%d\t",degrees);
      }
@@ -386,17 +373,20 @@ void dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DM
        fclose (pFile);
      }
-      //save to string for ncurses
+      //save to array 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) sprintf (lrrpstr, "LRRP %0d (%lf, %lf)", source, lat_fin, lon_fin);
+      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 (vel_set) sprintf (velstr, " %.4lf km/h", velocity * 3.6);
-      if (deg_set) sprintf (degstr, " %d%s  ", degrees, deg_glyph);
+      if (deg_set) sprintf (degstr, " %d deg", degrees);
      sprintf (state->dmr_lrrp_gps[slot], "%s%s%s", lrrpstr, velstr, degstr);
    }
@@ -409,126 +399,16 @@ void dmr_lrrp (dsd_opts * opts, dsd_state * state, uint8_t block_len, uint8_t DM
    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);
  } 
 }
--- a/src/dmr_pi.c
+++ b/src/dmr_pi.c
@@ -15,62 +15,79 @@ void dmr_pi (dsd_opts * opts, dsd_state * state, uint8_t PI_BYTE[], uint32_t CRC
  if((IrrecoverableErrors == 0)) 
  {
    if (state->currentslot == 0)
    {
-      state->payload_algid = PI_BYTE[0];
+
-      state->payload_keyid = PI_BYTE[2];
+      if (0 == 0) 
      {
        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) 
      {
        fprintf (stderr, "%s ", KYEL);
        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, " DMR PI Header 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)
      {
-        state->payload_algid = 0;
+        if (0 == 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) 
      {
        fprintf (stderr, "%s ", KYEL);
        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, " DMR PI Header 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)
      {
-        state->payload_algidR = 0;
+        if (0== 0) 
-        state->payload_keyidR = 0;
+        {
-        state->payload_miR = 0;
+          state->payload_algidR = 0;
          state->payload_keyidR = 0;
          state->payload_miR = 0;
        }
      }
    }
  }
  if((IrrecoverableErrors == 0) && CRCCorrect)
  {
    //fprintf (stderr, " (PI CRC Okay)");
  }
  else if((IrrecoverableErrors == 0))
  {
    //fprintf (stderr, " (PI FEC Okay)");
  }
  else {
    fprintf (stderr, "%s", KRED);
    fprintf (stderr, (" (PI FEC ERR)"));
    fprintf (stderr, "%s ", KNRM);
  }
 }
 void LFSR(dsd_state * state)
@@ -93,64 +110,27 @@ void LFSR(dsd_state * state)
  if (state->currentslot == 0)
  {
-    fprintf (stderr, "%s", KYEL);
+    if (1 == 1)
-    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, "%s", KYEL);
-    fprintf(stderr, " MI: 0x%08X", lfsr);
+      fprintf (stderr, " Slot 1");
-    fprintf (stderr, "%s", KNRM);
+      fprintf (stderr, " DMR PI Continuation 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);
    }
    state->payload_mi = lfsr;
  }
  if (state->currentslot == 1) 
  {
-
+    if (1 == 1)
-    fprintf (stderr, "%s", KYEL);
+    {
-    fprintf (stderr, " Slot 2");
+      fprintf (stderr, "%s", KYEL);
-    fprintf (stderr, " DMR PI C- ALG ID: 0x%02X KEY ID: 0x%02X", state->payload_algidR, state->payload_keyidR);
+      fprintf (stderr, " Slot 2");
-    fprintf(stderr, " MI: 0x%08X", lfsr);
+      fprintf (stderr, " DMR PI Continuation ALG ID: 0x%02X KEY ID: 0x%02X", state->payload_algidR, state->payload_keyidR);
-    fprintf (stderr, "%s", KNRM);
+      fprintf(stderr, " Next 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, " MI: 0x%016llX", lfsr);
      fprintf (stderr, "%s", KNRM);
 			state->payload_miR = lfsr & 0xFFFFFFFF; //truncate for next repitition and le verification
 		}
 	}
 }
--- a/src/dmr_utils.c
+++ b/src/dmr_utils.c
@@ -4,7 +4,7 @@
 //Original Source - https://github.com/LouisErigHerve/dsd
 //Additional Functions
-//Hamming17123, crc7, crc8, crc8ok functions
+//Hamming17123, crc8, crc8ok functions
 //Original Souce - https://github.com/boatbod/op25
 #include "dsd.h"
@@ -121,31 +121,6 @@ bool crc8_ok(uint8_t bits[], unsigned int len)
 	return (crc == crc8(bits,len));
 }
 uint8_t crc7(uint8_t bits[], unsigned int len)
 {
 	uint8_t crc=0;
 	unsigned int K = 7;
  //G7(x) = x7 + x5 + x2 + x + 1   check poly below for correct (dmr rc crc7)
 	uint8_t poly[8] = {1,0,1,0,0,1,1,1}; // crc7 poly
 	uint8_t buf[256];
 	if (len+K > sizeof(buf)) {
 		// fprintf (stderr, "crc8: buffer length %u exceeds maximum %lu\n", len+K, sizeof(buf));
 		return 0;
 	}
 	memset (buf, 0, sizeof(buf));
 	for (unsigned int i=0; i<len; i++){
 		buf[i] = bits[i];
 	}
 	for (unsigned int i=0; i<len; i++)
 		if (buf[i])
 			for (unsigned int j=0; j<K+1; j++)
 				buf[i+j] ^= poly[j];
 	for (unsigned int i=0; i<K; i++){
 		crc = (crc << 1) + buf[len + i];
 	}
 	return crc;
 }
 /*
 * @brief : This function compute the CRC-CCITT of the DMR data
 *          by using the polynomial x^16 + x^12 + x^5 + 1
@@ -325,15 +300,15 @@ uint8_t ComputeCrc5Bit(uint8_t * DMRData)
  return CRC;
 } /* End ComputeCrc5Bit() */
-uint64_t ConvertBitIntoBytes(uint8_t * BufferIn, uint32_t BitLength)
+uint32_t ConvertBitIntoBytes(uint8_t * BufferIn, uint32_t BitLength)
 {
-   uint64_t Output = 0;
+   uint32_t Output = 0;
   uint32_t i;
   for(i = 0; i < BitLength; i++)
   {
     Output <<= 1;
-     Output |= (uint64_t)(BufferIn[i] & 1);
+     Output |= (uint32_t)(BufferIn[i] & 1);
   }
   return Output;
@@ -355,86 +330,3 @@ uint64_t ConvertBitIntoBytes(uint8_t * BufferIn, uint32_t BitLength)
 *
 * @return The 9 bit CRC
 */
 uint16_t ComputeCrc9Bit(uint8_t * DMRData, uint32_t NbData)
 {
  uint32_t i;
  uint16_t CRC = 0x0000; /* Initialization value = 0x0000 */
  /* Polynomial x^9 + x^6 + x^4 + x^3 + 1
   * Normal     = 0x059
   * Reciprocal = 0x134
   * Reversed reciprocal = 0x12C */
  uint16_t Polynome = 0x059;
  for(i = 0; i < NbData; i++)
  {
    if(((CRC >> 8) & 1) ^ (DMRData[i] & 1))
    {
      CRC = (CRC << 1) ^ Polynome;
    }
    else
    {
      CRC <<= 1;
    }
  }
  /* Conserve only the 9 LSBs */
  CRC &= 0x01FF;
  /* Invert the CRC */
  CRC ^= 0x01FF;
  /* Return the CRC */
  return CRC;
 } /* End ComputeCrc9Bit() */
 /*
 * @brief : This function compute the CRC-32 of the DMR data
 *          by using the polynomial x^32 + x^26 + x^23 + x^22 + x^16 + x^12 + x^11 + x^10 + x^8 + x^7 + x^5 + x^4 + x^2 + x + 1
 *
 * @param Input : A buffer pointer of the DMR data (80 bytes)
 *        Rate 1/2 coded confirmed (10 data octets): 80 bit sequence (80 bytes)
 *        Rate 3/4 coded confirmed (16 data octets): 128 bit sequence (120 bytes)
 *        Rate 1 coded confirmed (22 data octets): 176 bit sequence (176 bytes)
 *
 * @param NbData : The number of bit to compute
 *        Rate 1/2 coded confirmed (10 data octets): 80 bit sequence (80 bytes)
 *        Rate 3/4 coded confirmed (16 data octets): 128 bit sequence (120 bytes)
 *        Rate 1 coded confirmed (22 data octets): 176 bit sequence (176 bytes)
 *
 * @return The 32 bit CRC
 */
 uint32_t ComputeCrc32Bit(uint8_t * DMRData, uint32_t NbData)
 {
  uint32_t i;
  uint32_t CRC = 0x00000000; /* Initialization value = 0x00000000 */
  /* Polynomial x^32 + x^26 + x^23 + x^22 + x^16 + x^12 + x^11 + x^10 + x^8 + x^7 + x^5 + x^4 + x^2 + x + 1
   * Normal     = 0x04C11DB7
   * Reversed   = 0xEDB88320
   * Reciprocal = 0xDB710641
   * Reversed reciprocal = 0x82608EDB */
  uint32_t Polynome = 0x04C11DB7;
  for(i = 0; i < NbData; i++)
  {
    if(((CRC >> 31) & 1) ^ (DMRData[i] & 1))
    {
      CRC = (CRC << 1) ^ Polynome;
    }
    else
    {
      CRC <<= 1;
    }
  }
  //for whatever reason, we get the CRC returned in a reversed byte order (MSO LSO b***s***)
  uint32_t a, b, c, d;
  a = b = c = d = 0;
  a = (CRC & 0xFF) << 24;
  b = (CRC & 0xFF00) >> 8;
  b = b << 16;
  c = (CRC & 0xFF0000) >> 16;
  c = c << 8;
  d = (CRC & 0xFF000000) >> 24;
  CRC = a + b + c + d;
  /* Return the CRC */
  return CRC;
 } /* End ComputeCrc32Bit() */
--- a/src/dpmr_voice.c
+++ b/src/dpmr_voice.c
@@ -428,7 +428,7 @@ void processdPMRvoice (dsd_opts * opts, dsd_state * state)
    if (state->R != 0)
    {
      fprintf (stderr, "%s", KYEL);
-      fprintf (stderr, " Key %05lld ", state->R );
+      fprintf (stderr, " KEY VALUE: [%05lld] ", state->R );
      fprintf (stderr, "%s", KNRM);
    }
  }
--- a/src/dsd_audio.c
+++ b/src/dsd_audio.c
@@ -444,17 +444,18 @@ playSynthesizedVoice (dsd_opts * opts, dsd_state * state)
  if (state->audio_out_idx > opts->delay)
  {
-    // output synthesized speech to sound card
+    if (opts->audio_out_type == 5) //OSS
 		if(opts->audio_out_type == 2)
 		{
      //go F yourself PA
 		}
 		else
    {
-      //Test just sending it straight on since I think I've figured out the STDIN and RTL for Stereo
+      //OSS
-      pa_simple_write(opts->pulse_digi_dev_out, (state->audio_out_buf_p - state->audio_out_idx), (state->audio_out_idx * 2), NULL); //Yay! It works.
+      result = write (opts->audio_out_fd, (state->audio_out_buf_p - state->audio_out_idx), (state->audio_out_idx * 2));
      state->audio_out_idx = 0;
    }
 		else if (opts->audio_out_type == 0)
    {
      pa_simple_write(opts->pulse_digi_dev_out, (state->audio_out_buf_p - state->audio_out_idx), (state->audio_out_idx * 2), NULL); 
      state->audio_out_idx = 0;
    }
    else state->audio_out_idx = 0; //failsafe for audio_out == 0
  }
@@ -478,15 +479,18 @@ playSynthesizedVoiceR (dsd_opts * opts, dsd_state * state)
  if (state->audio_out_idxR > opts->delay)
  {
    // output synthesized speech to sound card
-		if(opts->audio_out_type == 2)
+		if (opts->audio_out_type == 5) //OSS
 		{
      //go F yourself PA
 		}
 		else
    {
-      pa_simple_write(opts->pulse_digi_dev_outR, (state->audio_out_buf_pR - state->audio_out_idxR), (state->audio_out_idxR * 2), NULL); //Yay! It works.
+      //OSS
      result = write (opts->audio_out_fdR, (state->audio_out_buf_pR - state->audio_out_idxR), (state->audio_out_idxR * 2));
      state->audio_out_idxR = 0;
    }
 		else if (opts->audio_out_type == 0)
    {
      pa_simple_write(opts->pulse_digi_dev_outR, (state->audio_out_buf_pR - state->audio_out_idxR), (state->audio_out_idxR * 2), NULL); 
      state->audio_out_idxR = 0;
    }
    else state->audio_out_idxR = 0; //failsafe for audio_out == 0
  }
@@ -541,9 +545,6 @@ 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)
 	{
@@ -561,6 +562,7 @@ openAudioInDevice (dsd_opts * opts)
      exit(1);
    }
 	}
  else if (strncmp(opts->audio_in_dev, "tcp", 3) == 0)
  {
    opts->audio_in_type = 8;
@@ -570,13 +572,13 @@ openAudioInDevice (dsd_opts * opts)
    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 open TCP with libsndfile: %s\n", sf_strerror(NULL));
      exit(1);
    }
  }
  else if (strncmp(opts->audio_in_dev, "udp", 3) == 0)
  {
    opts->audio_in_type = 6;
@@ -601,25 +603,10 @@ openAudioInDevice (dsd_opts * opts)
  {
    opts->audio_in_type = 0;
  }
-
+  else if((strncmp(opts->audio_in_dev, "/dev/dsp", 8) == 0))
  //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_type = 5;
    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;
@@ -667,9 +654,11 @@ openAudioInDevice (dsd_opts * opts)
    }
    //open pulse audio if no bin or wav
-    else
+    else //seems this condition is never met
    {
-      opts->audio_in_type = 0; //not sure if this works or needs to openPulse here
+      //opts->audio_in_type = 5; //not sure if this works or needs to openPulse here
      fprintf(stderr, "Error, couldn't open input file.\n");
      exit(1);
    }
  }
  if (opts->split == 1)
--- a/src/dsd_dibit.c
+++ b/src/dsd_dibit.c
@@ -283,11 +283,12 @@ static int digitize (dsd_opts* opts, dsd_state* state, int symbol)
      valid = 0;
-      //disabling again, causing issues with trunking 
+      //only run estimate_symbol when we aren't trunking, otherwise noise/gain levels on other rf channels may impact performance severely
-      if (state->synctype == 1 && opts->p25_trunk == 1) 
+      //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);
+          //valid = estimate_symbol(state->rf_mod, &(state->inv_p25_heuristics), state->last_dibit, symbol, &dibit);
        }
      if (valid == 0)
@@ -347,11 +348,12 @@ static int digitize (dsd_opts* opts, dsd_state* state, int symbol)
      valid = 0;
-      //disabling again, causing issues with trunking 
+      //only run estimate_symbol when we aren't trunking, otherwise noise/gain levels on other rf channels may impact performance severely
-      if (state->synctype == 0 && opts->p25_trunk == 1) 
+      //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);
+          //valid = estimate_symbol(state->rf_mod, &(state->p25_heuristics), state->last_dibit, symbol, &dibit);
        }
      if (valid == 0)
--- a/src/dsd_file.c
+++ b/src/dsd_file.c
@@ -45,7 +45,8 @@ char * getDateF(void) {
  return curr2;
 }
-void saveImbe4400Data (dsd_opts * opts, dsd_state * state, char *imbe_d)
+void
 saveImbe4400Data (dsd_opts * opts, dsd_state * state, char *imbe_d)
 {
  int i, j, k;
  unsigned char b;
@@ -55,22 +56,36 @@ void saveImbe4400Data (dsd_opts * opts, dsd_state * state, char *imbe_d)
  fputc (err, opts->mbe_out_f);
  k = 0;
-  for (i = 0; i < 11; i++)
+  if (opts->payload == 1) //make opt variable later on to toggle this
  {
-    b = 0;
+    //fprintf(stderr, "\n IMBE ");
    for (j = 0; j < 8; j++)
      {
        b = b << 1;
        b = b + imbe_d[k];
        k++;
      }
    fputc (b, opts->mbe_out_f);
  }
  for (i = 0; i < 11; i++)
    {
      b = 0;
      for (j = 0; j < 8; j++)
        {
          b = b << 1;
          b = b + imbe_d[k];
          k++;
        }
        if (opts->payload == 1) //make opt variable later on to toggle this
        {
          //fprintf (stderr, "%02X", b);
        }
      fputc (b, opts->mbe_out_f);
    }
    if (opts->payload == 1)
    {
      //fprintf(stderr, " err = [%X] [%X] ", state->errs, state->errs2);
    }
  fflush (opts->mbe_out_f);
 }
-void saveAmbe2450Data (dsd_opts * opts, dsd_state * state, char *ambe_d)
+void
 saveAmbe2450Data (dsd_opts * opts, dsd_state * state, char *ambe_d)
 {
  int i, j, k;
  unsigned char b;
@@ -80,49 +95,42 @@ void saveAmbe2450Data (dsd_opts * opts, dsd_state * state, char *ambe_d)
  fputc (err, opts->mbe_out_f);
  k = 0;
-  for (i = 0; i < 6; i++) 
+  if (opts->payload == 1) //make opt variable later on to toggle this
  {
-    b = 0;
+    //fprintf(stderr, "\n AMBE ");
    for (j = 0; j < 8; j++)
    {
      b = b << 1;
      b = b + ambe_d[k];
      k++;
    }
    fputc (b, opts->mbe_out_f);
  }
  //for (i = 0; i < 6; i++)
  for (i = 0; i < 6; i++) //using 7 seems to break older amb files where it was 6, need to test 7 on 7 some more
    {
      b = 0;
      for (j = 0; j < 8; j++)
        {
          b = b << 1;
          b = b + ambe_d[k];
          k++;
        }
        if (opts->payload == 1 && i < 6) //make opt variable later on to toggle this
        {
          //fprintf (stderr, "%02X", b);
        }
        if (opts->payload == 1 && i == 6) //7th octet should only contain 1 bit? value will be either 0x00 or 0x80?
        {
          //fprintf (stderr, "%02X", b & 0x80); //7th octet should only contain 1 bit?
        }
      fputc (b, opts->mbe_out_f);
    }
    if (opts->payload == 1)
    {
      //fprintf(stderr, " err = [%X] [%X] ", state->errs, state->errs2);
    }
  b = ambe_d[48];
  fputc (b, opts->mbe_out_f);
  fflush (opts->mbe_out_f);
 }
-void saveAmbe2450DataR (dsd_opts * opts, dsd_state * state, char *ambe_d)
+void
-{
+PrintIMBEData (dsd_opts * opts, dsd_state * state, char *imbe_d) //for P25P1 and ProVoice
  int i, j, k;
  unsigned char b;
  unsigned char err;
  err = (unsigned char) state->errs2R;
  fputc (err, opts->mbe_out_fR);
  k = 0;
  for (i = 0; i < 6; i++) 
  {
    b = 0;
    for (j = 0; j < 8; j++)
    {
      b = b << 1;
      b = b + ambe_d[k];
      k++;
    }
    fputc (b, opts->mbe_out_fR);
  }
  b = ambe_d[48];
  fputc (b, opts->mbe_out_fR);
  fflush (opts->mbe_out_fR);
 }
 void PrintIMBEData (dsd_opts * opts, dsd_state * state, char *imbe_d) //for P25P1 and ProVoice
 {
  int i, j, k;
  unsigned char b;
@@ -157,7 +165,8 @@ void PrintIMBEData (dsd_opts * opts, dsd_state * state, char *imbe_d) //for P25P
  //fprintf (stderr, "\n");
 }
-void PrintAMBEData (dsd_opts * opts, dsd_state * state, char *ambe_d) 
+void
 PrintAMBEData (dsd_opts * opts, dsd_state * state, char *ambe_d) 
 {
  int i, j, k;
  unsigned char b;
@@ -324,21 +333,14 @@ openMbeInFile (dsd_opts * opts, dsd_state * state)
  cookie[2] = fgetc (opts->mbe_in_f);
  cookie[3] = fgetc (opts->mbe_in_f);
  cookie[4] = 0;
  //ambe+2
  if (strstr (cookie, ".amb") != NULL)
-  {
+    {
-    state->mbe_file_type = 1;
+      state->mbe_file_type = 1;
-  }
+    }
  //p1 and pv
  else if (strstr (cookie, ".imb") != NULL)
-  {
+    {
-    state->mbe_file_type = 0;
+      state->mbe_file_type = 0;
-  }
+    }
  //d-star ambe
  else if (strstr (cookie, ".dmb") != NULL)
  {
    state->mbe_file_type = 2;
  }
  else
    {
      state->mbe_file_type = -1;
@@ -347,7 +349,7 @@ openMbeInFile (dsd_opts * opts, dsd_state * state)
 }
-//slot 1
+//much simpler version
 void closeMbeOutFile (dsd_opts * opts, dsd_state * state)
 {
  if (opts->mbe_out == 1)
@@ -358,67 +360,48 @@ void closeMbeOutFile (dsd_opts * opts, dsd_state * state)
      fclose (opts->mbe_out_f);
      opts->mbe_out_f = NULL;
      opts->mbe_out = 0;
-      fprintf (stderr, "\nClosing MBE out file 1.\n");
+      fprintf (stderr, "\nClosing MBE out file.");
    }
  }
 }
-//slot 2
+void
-void closeMbeOutFileR (dsd_opts * opts, dsd_state * state)
+openMbeOutFile (dsd_opts * opts, dsd_state * state)
 {
  if (opts->mbe_outR == 1)
  {
    if (opts->mbe_out_fR != NULL)
    {
      fflush (opts->mbe_out_fR);
      fclose (opts->mbe_out_fR);
      opts->mbe_out_fR = NULL;
      opts->mbe_outR = 0;
      fprintf (stderr, "\nClosing MBE out file 2.\n");
    }
  }
 }
 void openMbeOutFile (dsd_opts * opts, dsd_state * state)
 {
  int i, j;
  char ext[5];
-  //phase 1 and provoice
+  if ((state->synctype == 0) || (state->synctype == 1) || (state->synctype == 14) || (state->synctype == 15))
  if ( (state->synctype == 0) || (state->synctype == 1) || (state->synctype == 14) || (state->synctype == 15) )
  {
    sprintf (ext, ".imb");
  }
  //d-star
  else if ( (state->synctype == 6) || (state->synctype == 7) || (state->synctype == 18) || (state->synctype == 19) )
  {
    sprintf (ext, ".dmb"); //new dstar file extension to make it read in and process properly
  }
  //dmr, nxdn, phase 2, x2-tdma
  else sprintf (ext, ".amb"); 
  //reset talkgroup id buffer
  for (i = 0; i < 12; i++)
  {
    for (j = 0; j < 25; j++)
    {
-      state->tg[j][i] = 0;
+      sprintf (ext, ".imb");
    }
  else
    {
      sprintf (ext, ".amb");
    }
  //  reset talkgroup id buffer
  for (i = 0; i < 12; i++)
    {
      for (j = 0; j < 25; j++)
        {
          state->tg[j][i] = 0;
        }
    }
  }
  state->tgcount = 0;
-  sprintf (opts->mbe_out_file, "%s %s S1%s", getDateF(), getTimeF(), ext);
+  sprintf (opts->mbe_out_file, "%s %s%s", getDateF(), getTimeF(), ext);
  sprintf (opts->mbe_out_path, "%s%s", opts->mbe_out_dir, opts->mbe_out_file);
  opts->mbe_out_f = fopen (opts->mbe_out_path, "w");
  if (opts->mbe_out_f == NULL)
  {
-    fprintf (stderr,"\nError, couldn't open %s for slot 1\n", opts->mbe_out_path);
+    fprintf (stderr,"Error, couldn't open %s\n", opts->mbe_out_path);
  }
  else opts->mbe_out = 1;
@@ -428,54 +411,8 @@ void openMbeOutFile (dsd_opts * opts, dsd_state * state)
  fflush (opts->mbe_out_f);
 }
-void openMbeOutFileR (dsd_opts * opts, dsd_state * state)
+void
-{
+openWavOutFile (dsd_opts * opts, dsd_state * state)
  int i, j;
  char ext[5];
  //phase 1 and provoice
  if ( (state->synctype == 0) || (state->synctype == 1) || (state->synctype == 14) || (state->synctype == 15) )
  {
    sprintf (ext, ".imb");
  }
  //d-star
  else if ( (state->synctype == 6) || (state->synctype == 7) || (state->synctype == 18) || (state->synctype == 19) )
  {
    sprintf (ext, ".dmb"); //new dstar file extension to make it read in and process properly
  }
  //dmr, nxdn, phase 2, x2-tdma
  else sprintf (ext, ".amb"); 
  //reset talkgroup id buffer
  for (i = 0; i < 12; i++)
  {
    for (j = 0; j < 25; j++)
    {
      state->tg[j][i] = 0;
    }
  }
  state->tgcount = 0;
  sprintf (opts->mbe_out_fileR, "%s %s S2%s", getDateF(), getTimeF(), ext);
  sprintf (opts->mbe_out_path, "%s%s", opts->mbe_out_dir, opts->mbe_out_fileR);
  opts->mbe_out_fR = fopen (opts->mbe_out_path, "w");
  if (opts->mbe_out_fR == NULL)
  {
    fprintf (stderr,"\nError, couldn't open %s for slot 2\n", opts->mbe_out_path);
  }
  else opts->mbe_outR = 1;
  //
  fprintf (opts->mbe_out_fR, "%s", ext);
  fflush (opts->mbe_out_fR);
 }
 void openWavOutFile (dsd_opts * opts, dsd_state * state)
 {
  SF_INFO info;
--- a/src/dsd_frame.c
+++ b/src/dsd_frame.c
@@ -87,8 +87,8 @@ processFrame (dsd_opts * opts, dsd_state * state)
  //NXDN FSW
  if ((state->synctype == 28) || (state->synctype == 29))
  {
    //MBEout restored, is not handled internally by nxdn_frame.c
    nxdn_frame (opts, state);
    //no MBEout...use symbol capture bin instead! 
    return;
  }
  else if ((state->synctype == 6) || (state->synctype == 7))
@@ -107,7 +107,7 @@ processFrame (dsd_opts * opts, dsd_state * state)
      state->nac = 0;
      if ((opts->mbe_out_dir[0] != 0) && (opts->mbe_out_f == NULL))
        {
-          openMbeOutFile (opts, state); //dstar ambe files are read back incorrectly, need to change file extension to differentiate when doing a playback
+          openMbeOutFile (opts, state);
        }
      sprintf (state->fsubtype, " VOICE        ");
      processDSTAR (opts, state);
@@ -128,9 +128,9 @@ processFrame (dsd_opts * opts, dsd_state * state)
        }
      state->nac = 0;
      if ((opts->mbe_out_dir[0] != 0) && (opts->mbe_out_f == NULL))
-      {
+        {
-        openMbeOutFile (opts, state); //dstar ambe files are read back incorrectly, need to change file extension to differentiate when doing a playback
+          openMbeOutFile (opts, state);
-      }
+        }
      sprintf (state->fsubtype, " DATA         ");
      processDSTAR_HD (opts, state);
      return;
@@ -141,9 +141,9 @@ processFrame (dsd_opts * opts, dsd_state * state)
      //print manufacturer strings to branding, disabled 0x10 moto other systems can use that fid set
      //0x06 is trident, but when searching, apparently, they developed con+, but was bought by moto?
-      if (state->dmr_mfid == 0x10) ; //sprintf (state->dmr_branding, "%s",  "Motorola");
+      if (state->dmr_mfid == 0x10) ; //sprintf (state->dmr_branding, "%s", "Motorola");
-      else if (state->dmr_mfid == 0x68) sprintf (state->dmr_branding, "%s", "  Hytera");
+      else if (state->dmr_mfid == 0x68) sprintf (state->dmr_branding, "%s", "Hytera");
-      else if (state->dmr_mfid == 0x58) sprintf (state->dmr_branding, "%s", "    Tait");
+      else if (state->dmr_mfid == 0x58) sprintf (state->dmr_branding, "%s", "Tait");
      //disabling these due to random data decodes setting an odd mfid, could be legit, but only for that one packet?
      //or, its just a decode error somewhere
@@ -164,58 +164,70 @@ processFrame (dsd_opts * opts, dsd_state * state)
      //disable so radio id doesn't blink in and out during ncurses and aggressive_framesync
      state->nac = 0;
-
+      //state->lastsrc = 0;
      //state->lasttg = 0;
      //state->lastsrcR = 0;
      //state->lasttgR = 0;
      if (opts->errorbars == 1)
      {
        if (opts->verbose > 0)
        {
-          level = (int) state->max / 164;
+          if (opts->verbose > 0)
-          //fprintf (stderr,"inlvl: %2i%% ", level);
+            {
              level = (int) state->max / 164;
              //fprintf (stderr,"inlvl: %2i%% ", level);
            }
        }
      }
      if ( (state->synctype == 11) || (state->synctype == 12) || (state->synctype == 32) ) //DMR Voice Modes
      {
        sprintf (state->fsubtype, " VOICE        ");
        if (opts->dmr_stereo == 0 && state->synctype < 32) // -T option for DMR (TDMA) stereo
        {
-          sprintf (state->slot1light, " slot1 ");
+          if ((opts->mbe_out_dir[0] != 0) && (opts->mbe_out_f == NULL) && opts->dmr_stereo == 0)
-          sprintf (state->slot2light, " slot2 ");
+            {
-          //we can safely open MBE on any MS or mono handling
+              openMbeOutFile (opts, state);
-          if ((opts->mbe_out_dir[0] != 0) && (opts->mbe_out_f == NULL)) openMbeOutFile (opts, state); 
+            }
-          dmrMSBootstrap (opts, state); 
+          sprintf (state->fsubtype, " VOICE        ");
-        }
+          if (opts->dmr_stereo == 0 && state->synctype < 32) // -T option for DMR (TDMA) stereo
        if (opts->dmr_mono == 1 && state->synctype == 32)
        {
          //we can safely open MBE on any MS or mono handling
          if ((opts->mbe_out_dir[0] != 0) && (opts->mbe_out_f == NULL)) openMbeOutFile (opts, state);
          dmrMSBootstrap (opts, state); 
        }
        if (opts->dmr_stereo == 1) //opts->dmr_stereo == 1
        {
          state->dmr_stereo = 1; //set the state to 1 when handling pure voice frames
          if (state->synctype > 31 )
          {
-            //we can safely open MBE on any MS or mono handling
+            sprintf (state->slot1light, " slot1 ");
-            if ((opts->mbe_out_dir[0] != 0) && (opts->mbe_out_f == NULL)) openMbeOutFile (opts, state);
+            sprintf (state->slot2light, " slot2 ");
-            dmrMSBootstrap (opts, state); //bootstrap into MS Bootstrap (voice only)
+            dmrMSBootstrap (opts, state); 
          }
          if (opts->dmr_mono == 1 && state->synctype == 32)
          {
            // fprintf (stderr, "%s", KRED);
            // fprintf (stderr, "Please use XDMA or DMR Stereo to decode MS/Simplex \n");
            // fprintf (stderr, "%s", KNRM);
            dmrMSBootstrap (opts, state); 
          }
          if (opts->dmr_stereo == 1) //opts->dmr_stereo == 1
          {
            state->dmr_stereo = 1; //set the state to 1 when handling pure voice frames
            if (state->synctype > 31 )
            {
              dmrMSBootstrap (opts, state); //bootstrap into MS Bootstrap (voice only)
            }
            else dmrBSBootstrap (opts, state); //bootstrap into BS Bootstrap
          }
          else dmrBSBootstrap (opts, state); //bootstrap into BS Bootstrap
        }
      }
      else if ( (state->synctype == 33) || (state->synctype == 34) ) //MS Data and RC data
      {
        if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state);
        if (opts->mbe_out_fR != NULL) closeMbeOutFileR (opts, state);
        dmrMSData (opts, state);
        // if (opts->dmr_stereo == 0)
        // {
        //   closeMbeOutFile (opts, state);
        //   state->err_str[0] = 0;
        //   fprintf (stderr, "%s", KRED);
        //   fprintf (stderr, "Please use XDMA or DMR Stereo to decode MS/Simplex \n");
        //   fprintf (stderr, "%s", KNRM);
        // }
        // if (opts->dmr_stereo == 1)
        // {
        //   dmrMSData (opts, state);
        // }
      }
      else
      {
        if (opts->dmr_stereo == 0)
        {
-          if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state);
+          closeMbeOutFile (opts, state);
          if (opts->mbe_out_fR != NULL) closeMbeOutFileR (opts, state);
          state->err_str[0] = 0;
          sprintf (state->slot1light, " slot1 ");
          sprintf (state->slot2light, " slot2 ");
@@ -225,9 +237,6 @@ processFrame (dsd_opts * opts, dsd_state * state)
        //switch dmr_stereo to 0 when handling BS data frame syncs with processDMRdata
        if (opts->dmr_stereo == 1)
        {
          if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state);
          if (opts->mbe_out_fR != NULL) closeMbeOutFileR (opts, state);
          state->dmr_stereo = 0; //set the state to zero for handling pure data frames
          sprintf (state->slot1light, " slot1 ");
          sprintf (state->slot2light, " slot2 ");
@@ -237,8 +246,7 @@ processFrame (dsd_opts * opts, dsd_state * state)
      }
      return;
    }
-    //X2-TDMA
+  else if ((state->synctype >= 2) && (state->synctype <= 5))
    else if ((state->synctype >= 2) && (state->synctype <= 5))
    {
      state->nac = 0;
      if (opts->errorbars == 1)
@@ -248,15 +256,15 @@ processFrame (dsd_opts * opts, dsd_state * state)
      if ((state->synctype == 3) || (state->synctype == 4))
        {
          if ((opts->mbe_out_dir[0] != 0) && (opts->mbe_out_f == NULL))
-          {
+            {
-            openMbeOutFile (opts, state);
+              openMbeOutFile (opts, state);
-          }
+            }
          sprintf (state->fsubtype, " VOICE        ");
          processX2TDMAvoice (opts, state);
        }
      else
        {
-          if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state);
+          closeMbeOutFile (opts, state);
          state->err_str[0] = 0;
          processX2TDMAdata (opts, state);
        }
@@ -264,18 +272,21 @@ processFrame (dsd_opts * opts, dsd_state * state)
    }
  else if ((state->synctype == 14) || (state->synctype == 15))
    {
      //state->nac = 0;
      //state->lastsrc = 0;
      //state->lasttg = 0;
      if (opts->errorbars == 1)
      {
        if (opts->verbose > 0)
        {
-          level = (int) state->max / 164;
+          if (opts->verbose > 0)
-          //fprintf (stderr,"inlvl: %2i%% ", level);
+            {
              level = (int) state->max / 164;
              //fprintf (stderr,"inlvl: %2i%% ", level);
            }
        }
      }
      if ((opts->mbe_out_dir[0] != 0) && (opts->mbe_out_f == NULL))
-      {
+        {
-        openMbeOutFile (opts, state);
+          openMbeOutFile (opts, state);
-      }
+        }
      sprintf (state->fsubtype, " VOICE        ");
      processProVoice (opts, state);
      return;
@@ -283,7 +294,6 @@ processFrame (dsd_opts * opts, dsd_state * state)
    //edacs
    else if ((state->synctype == 37) || (state->synctype == 38))
    {
      if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state); 
      edacs (opts, state);
      return;
    }
@@ -303,7 +313,13 @@ processFrame (dsd_opts * opts, dsd_state * state)
    //P25 P2
    else if ((state->synctype == 35) || (state->synctype == 36))
    {
-      //relocate MBEout to inside frame handling
+      //Do stuff
      //fprintf(stderr, "YSF Sync! \n");
      if ((opts->mbe_out_dir[0] != 0) && (opts->mbe_out_f == NULL))
      {
        //openMbeOutFile (opts, state);
      }
      //sprintf(state->fsubtype, " VOICE        ");
      processP2(opts, state);
      return;
    }
@@ -312,7 +328,6 @@ processFrame (dsd_opts * opts, dsd_state * state)
    {
      /* dPMR Frame Sync 1 */
      fprintf(stderr, "dPMR Frame Sync 1 ");
      if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state);
    }
    else if ((state->synctype == 21) || (state->synctype == 25))
    {
@@ -331,12 +346,12 @@ processFrame (dsd_opts * opts, dsd_state * state)
        }
        state->nac = 0;
-        if ((opts->mbe_out_dir[0] != 0) && (opts->mbe_out_f == NULL))
+          if ((opts->mbe_out_dir[0] != 0) && (opts->mbe_out_f == NULL))
-        {
+          {
-          openMbeOutFile (opts, state);
+            openMbeOutFile (opts, state);
-        }
+          }
-        sprintf(state->fsubtype, " VOICE        ");
+          sprintf(state->fsubtype, " VOICE        ");
-        processdPMRvoice (opts, state);
+          processdPMRvoice (opts, state);
        return;
@@ -345,13 +360,11 @@ processFrame (dsd_opts * opts, dsd_state * state)
    {
      /* dPMR Frame Sync 3 */
      fprintf(stderr, "dPMR Frame Sync 3 ");
      if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state);
    }
    else if ((state->synctype == 23) || (state->synctype == 27))
    {
      /* dPMR Frame Sync 4 */
      fprintf(stderr, "dPMR Frame Sync 4 ");
      if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state);
    }
    //dPMR
  else //P25
@@ -450,15 +463,15 @@ processFrame (dsd_opts * opts, dsd_state * state)
    {
      // Header Data Unit
      if (opts->errorbars == 1)
-      {
+        {
-        printFrameInfo (opts, state);
+          printFrameInfo (opts, state);
-        fprintf (stderr," HDU\n");
+          fprintf (stderr," HDU\n");
-      }
+        }
      if (opts->mbe_out_dir[0] != 0)
-      {
+        {
-        if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state); 
+          closeMbeOutFile (opts, state);
-        if (opts->mbe_out_f == NULL) openMbeOutFile (opts, state);
+          openMbeOutFile (opts, state);
-      }
+        }
      mbe_initMbeParms (state->cur_mp, state->prev_mp, state->prev_mp_enhanced);
      state->lastp25type = 2;
      state->dmrburstL = 25;
@@ -470,22 +483,26 @@ processFrame (dsd_opts * opts, dsd_state * state)
    {
      // Logical Link Data Unit 1
      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);
+          printFrameInfo (opts, state);
          fprintf (stderr," LDU1  ");
        }
      if (opts->mbe_out_dir[0] != 0)
        {
          if (opts->mbe_out_f == NULL)
            {
              openMbeOutFile (opts, state);
            }
        }
      }
      state->lastp25type = 1;
      state->dmrburstL = 26;
      state->currentslot = 0;
      sprintf (state->fsubtype, " LDU1         ");
      state->numtdulc = 0;
      if (state->payload_algid == 0x81)
      {
        fprintf (stderr, "\n");
      }
      processLDU1 (opts, state);
    }
@@ -497,27 +514,27 @@ processFrame (dsd_opts * opts, dsd_state * state)
      if (state->lastp25type != 1)
        {
          if (opts->errorbars == 1)
-          {
+            {
-            printFrameInfo (opts, state);
+              printFrameInfo (opts, state);
-            fprintf (stderr,"\n Ignoring LDU2 not preceeded by LDU1\n");
+              fprintf (stderr,"\n Ignoring LDU2 not preceeded by LDU1\n");
-          }
+            }
          state->lastp25type = 0;
          sprintf (state->fsubtype, "              ");
        }
      else
        {
          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);
+              printFrameInfo (opts, state);
              fprintf (stderr," LDU2  ");
            }
          if (opts->mbe_out_dir[0] != 0)
            {
              if (opts->mbe_out_f == NULL)
                {
                  openMbeOutFile (opts, state);
                }
            }
          }
          state->lastp25type = 2;
          sprintf (state->fsubtype, " LDU2         ");
          state->numtdulc = 0;
@@ -529,25 +546,25 @@ processFrame (dsd_opts * opts, dsd_state * state)
      // Terminator with subsequent Link Control
      state->dmrburstL = 28;
      if (opts->errorbars == 1)
-      {
+        {
-        printFrameInfo (opts, state);
+          printFrameInfo (opts, state);
-        fprintf (stderr," TDULC\n");
+          fprintf (stderr," TDULC\n");
-      }
+        }
      if (opts->mbe_out_dir[0] != 0)
-      {
+        {
-        if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state);
+          closeMbeOutFile (opts, state);
-      }
+        }
      mbe_initMbeParms (state->cur_mp, state->prev_mp, state->prev_mp_enhanced);
-      // state->lasttg = 0;
+      state->lasttg = 0;
-      // state->lastsrc = 0;
+      state->lastsrc = 0;
      state->lastp25type = 0;
      state->err_str[0] = 0;
      sprintf (state->fsubtype, " TDULC        ");
      state->numtdulc++;
      if ((opts->resume > 0) && (state->numtdulc > opts->resume))
-      {
+        {
-        resumeScan (opts, state);
+          resumeScan (opts, state);
-      }
+        }
      processTDULC (opts, state);
      state->err_str[0] = 0;
    }
@@ -556,14 +573,14 @@ processFrame (dsd_opts * opts, dsd_state * state)
      // Terminator without subsequent Link Control
      state->dmrburstL = 28;
      if (opts->errorbars == 1)
-      {
+        {
-        printFrameInfo (opts, state);
+          printFrameInfo (opts, state);
-        fprintf (stderr," TDU\n");
+          fprintf (stderr," TDU\n");
-      }
+        }
      if (opts->mbe_out_dir[0] != 0)
-      {
+        {
-        if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state);
+          closeMbeOutFile (opts, state);
-      }
+        }
      mbe_initMbeParms (state->cur_mp, state->prev_mp, state->prev_mp_enhanced);
      state->lasttg = 0;
      state->lastsrc = 0;
@@ -577,59 +594,120 @@ processFrame (dsd_opts * opts, dsd_state * state)
    {
      state->dmrburstL = 29;
      if (opts->errorbars == 1)
-      {
+        {
-        printFrameInfo (opts, state);
+          printFrameInfo (opts, state);
-        fprintf (stderr," TSBK");
+          fprintf (stderr," TSBK");
-      }
+        }
      if (opts->mbe_out_dir[0] != 0)
      {
        if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state);
        if (opts->mbe_out_fR != NULL) closeMbeOutFileR (opts, state);
      }
      if (opts->resume > 0)
-      {
+        {
-        resumeScan (opts, state);
+          resumeScan (opts, state);
-      }
+        }
      state->lasttg = 0;
      state->lastsrc = 0;
      state->lastp25type = 3;
      sprintf (state->fsubtype, " TSBK         ");
      // Now processing NID
      processTSBK(opts, state);
    }
  else if (strcmp (duid, "30") == 0)
    {
      state->dmrburstL = 29;
      if (opts->errorbars == 1)
-      {
+        {
-        printFrameInfo (opts, state);
+          printFrameInfo (opts, state);
-        fprintf (stderr," MBF\n"); //multi block format PDU
+          fprintf (stderr," PDU\n");
-      }
+        }
      if (opts->mbe_out_dir[0] != 0)
      {
        if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state);
        if (opts->mbe_out_fR != NULL) closeMbeOutFileR (opts, state);
      }
      if (opts->resume > 0)
-      {
+        {
-        resumeScan (opts, state);
+          resumeScan (opts, state);
-      }
+        }
      if (opts->mbe_out_dir[0] != 0)
        {
          if (opts->mbe_out_f == NULL)
            {
              openMbeOutFile (opts, state);
            }
        }
      state->lastp25type = 4;
-      sprintf (state->fsubtype, " MBF          ");
+      sprintf (state->fsubtype, " PDU          ");
      processMPDU(opts, state);
    }
-
+  // try to guess based on previous frame if unknown type
-  else
+  else if (state->lastp25type == 1)
  {
    state->lastp25type = 0;
    sprintf (state->fsubtype, "              ");
    if (opts->errorbars == 1)
    {
-      printFrameInfo (opts, state);
+      if (opts->errorbars == 1)
-      // fprintf (stderr," duid:%s *Unknown DUID*\n", duid);
+        {
-      fprintf (stderr," duid:%s \n", duid); //DUID ERR
+          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;
      sprintf (state->fsubtype, "              ");
      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
        }
    }
  }
 }
--- a/src/dsd_frame_sync.c
+++ b/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 + 0) ) ) //was 3, go to hangtime value
+  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) ) )
  {
    //test to switch back to 10/4 P1 QPSK for P25 FDMA CC
@@ -163,23 +163,10 @@ 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) //fixed this to skip the extra wait out at the end of the list
+    if (state->lcn_freq_roll > state->lcn_freq_count)
    {
      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) 
    {
@@ -195,7 +182,7 @@ getFrameSync (dsd_opts * opts, dsd_state * state)
        rtl_udp_tune (opts, state, state->trunk_lcn_freq[state->lcn_freq_roll]);
      }
-      fprintf (stderr, "Tuning to Frequency: %.06lf MHz\n", 
+      fprintf (stderr, "Tuning to Control Channel Frequency: %.06lf MHz\n", 
                (double)state->trunk_lcn_freq[state->lcn_freq_roll]/1000000);
    }
@@ -231,10 +218,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 19
+  //if Phase 2 (or YSF in future), then only 20
  else if (state->lastsynctype == 35 || state->lastsynctype == 36) //P2
  {
-    t_max = 19; //Phase 2 S-ISCH is only 19
+    t_max = 20; 
  }
  else t_max = 24; //24 for everything else
@@ -1277,121 +1264,6 @@ getFrameSync (dsd_opts * opts, dsd_state * state)
            }
          #ifdef NXDNTESTSYNC //use experimental sync detection based on multiple factors
          //NXDN FSW sync and handling - testing with more exact syncs patterns
          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
            //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->lastsynctype = 28;
              state->offset = synctest_pos;
              state->max = ((state->max) + lmax) / 2;
              state->min = ((state->min) + lmin) / 2;
              // 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->lastsynctype = 29;
              state->offset = synctest_pos;
              state->max = ((state->max) + lmax) / 2;
              state->min = ((state->min) + lmin) / 2;
              // if (opts->payload == 1)
                // fprintf (stderr, "\n -PANDF ");
              // if (opts->payload == 1)
                // fprintf (stderr, " %s \n", synctest19);
              return (29);
            }
            else if (
                         (strcmp (synctest10, "3131331131") == 0 )
                      || (strcmp (synctest10, "3331331131") == 0 )
                      || (strcmp (synctest10, "3131331111") == 0 )
                      || (strcmp (synctest10, "3331331111") == 0 )
                    )
            {
              // state->carrier = 1;
              state->offset = synctest_pos;
              state->max = ((state->max) + lmax) / 2;
              state->min = ((state->min) + lmin) / 2;
              if (state->lastsynctype == 28) 
              {
                state->lastsynctype = 28;
                // 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 )   
                    )
            {
              // state->carrier = 1;
              state->offset = synctest_pos;
              state->max = ((state->max) + lmax) / 2;
              state->min = ((state->min) + lmin) / 2;
              if (state->lastsynctype == 29) 
              {
                state->lastsynctype = 29;
                // if (opts->payload == 1)
                  // fprintf (stderr, "\n -FSW   ");
                // if (opts->payload == 1)
                  // fprintf (stderr, " %s \n", synctest10);
                return (29);
              }
              state->lastsynctype = 29;              
            }
          }
          #else //use current 'more stable' NXDN Sync pattern detection
          //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))
          {
@@ -1401,33 +1273,30 @@ getFrameSync (dsd_opts * opts, dsd_state * state)
            //Preamble plus FSW, proceed right away
            if ( (strncmperr (synctest19, NXDN_PANDFSW, 19, 1) == 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 = 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;
+              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, "PANDF ");
+              //if (opts->payload == 1) fprintf (stderr, "PANDF ");
              // fprintf (stderr, " %s ", synctest19);
              return (29);
            }
            else if ( (strncmperr (synctest10, NXDN_FSW, 10, 1) == 0) )
            {
-              // state->carrier = 1;
+              state->carrier = 1;
              state->offset = synctest_pos;
              state->max = ((state->max) + lmax) / 2;
              state->min = ((state->min) + lmin) / 2;
@@ -1435,8 +1304,7 @@ 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
@@ -1445,7 +1313,7 @@ getFrameSync (dsd_opts * opts, dsd_state * state)
            else if ( (strncmperr (synctest10, INV_NXDN_FSW, 10, 1) == 0) )
            {
-              // state->carrier = 1;
+              state->carrier = 1;
              state->offset = synctest_pos;
              state->max = ((state->max) + lmax) / 2;
              state->min = ((state->min) + lmin) / 2;
@@ -1453,8 +1321,7 @@ 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
@@ -1462,95 +1329,6 @@ getFrameSync (dsd_opts * opts, dsd_state * state)
            }
          }
          #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
        } // t >= 10
      if (exitflag == 1)
--- a/src/dsd_import.c
+++ b/src/dsd_import.c
@@ -145,68 +145,3 @@ int csvChanImport(dsd_opts * opts, dsd_state * state) //channel map import
  fclose(fp);
  return 0;
 }
 int csvKeyImport(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;
 }
--- a/src/dsd_main.c
+++ b/src/dsd_main.c
--- a/src/dsd_mbe.c
+++ b/src/dsd_mbe.c
@@ -17,42 +17,8 @@
 #include "dsd.h"
-int Pr[256] = {
+void
-0x0000, 0x1F00, 0xE300, 0xFC00, 0x2503, 0x3A03, 0xC603, 0xD903,
+playMbeFiles (dsd_opts * opts, dsd_state * state, int argc, char **argv)
 0x4A05, 0x5505, 0xA905, 0xB605, 0x6F06, 0x7006, 0x8C06, 0x9306,
 0x2618, 0x3918, 0xC518, 0xDA18, 0x031B, 0x1C1B, 0xE01B, 0xFF1B,
 0x6C1D, 0x731D, 0x8F1D, 0x901D, 0x491E, 0x561E, 0xAA1E, 0xB51E, //31
 0x4B28, 0x5428, 0xA828, 0xB728, 0x6E2B, 0x712B, 0x8D2B, 0x922B,
 0x012D, 0x1E2D, 0xE22D, 0xFD2D, 0x242E, 0x3B2E, 0xC72E, 0xD82E,
 0x6D30, 0x7230, 0x8E30, 0x9130, 0x4833, 0x5733, 0xAB33, 0xB433,
 0x2735, 0x3835, 0xC435, 0xDB35, 0x0236, 0x1D36, 0xE136, 0xFE36, //63
 0x2B49, 0x3449, 0xC849, 0xD749, 0x0E4A, 0x114A, 0xED4A, 0xF24A,
 0x614C, 0xAE4C, 0x824C, 0x9D4C, 0x444F, 0x5B4F, 0xA74F, 0xB84F,
 0x0D51, 0x1251, 0xEE51, 0xF151, 0x2852, 0x3752, 0xCB52, 0xD452,
 0x4754, 0x5854, 0xA454, 0xBB54, 0x6257, 0x7D57, 0x8157, 0x9E57, //95
 0x6061, 0x7F61, 0x8361, 0x9C61, 0x4562, 0x5A62, 0xA662, 0xB962,
 0x2A64, 0x3564, 0xC964, 0xD664, 0x0F67, 0x1067, 0xEC67, 0xF367,
 0x4679, 0x5979, 0xA579, 0xBA79, 0x637A, 0x7C7A, 0x807A, 0x9F7A,
 0x0C7C, 0x137C, 0xEF7C, 0xF07C, 0x297F, 0x367F, 0xCA7F, 0xD57F, //127
 0x4D89, 0x5289, 0xAE89, 0xB189, 0x688A, 0x778A, 0x8B8A, 0x948A,
 0x078C, 0x188C, 0xE48C, 0xFB8C, 0x228F, 0x3D8F, 0xC18F, 0xDE8F,
 0x6B91, 0x7491, 0x8891, 0x9791, 0x4E92, 0x5192, 0xAD92, 0xB292,
 0x2194, 0x3E94, 0xC294, 0xDD94, 0x0497, 0x1B97, 0xE797, 0xF897, //159
 0x06A1, 0x19A1, 0xE5A1, 0xFAA1, 0x23A2, 0x3CA2, 0xC0A2, 0xDFA2,
 0x4CA4, 0x53A4, 0xAFA4, 0xB0A4, 0x69A7, 0x76A7, 0x8AA7, 0x95A7,
 0x20B9, 0x3FB9, 0xC3B9, 0xDCB9, 0x05BA, 0x1ABA, 0xE6BA, 0xF9BA,
 0x6ABC, 0x75BC, 0x89BC, 0x96BC, 0x4FBF, 0x50BF, 0xACBF, 0xB3BF, //191
 0x66C0, 0x79C0, 0x85C0, 0x9AC0, 0x43C3, 0x5CC3, 0xA0C3, 0xBFC3,
 0x2CC5, 0x33C5, 0xCFC5, 0xD0C5, 0x09C6, 0x16C6, 0xEAC6, 0xF5C6,
 0x84D0, 0x85DF, 0x8AD3, 0x8BDC, 0xB6D5, 0xB7DA, 0xB8D6, 0xB9D9,
 0xD0DA, 0xD1D5, 0xDED9, 0xDFD6, 0xE2DF, 0xE3D0, 0xECDC, 0xEDD3, //223
 0x2DE8, 0x32E8, 0xCEE8, 0xD1E8, 0x08EB, 0x17EB, 0xEBEB, 0xF4EB,
 0x67ED, 0x78ED, 0x84ED, 0x9BED, 0x42EE, 0x5DEE, 0xA1EE, 0xBEEE,
 0x0BF0, 0x14F0, 0xE8F0, 0xF7F0, 0x2EF3, 0x31F3, 0xCDF3, 0xD2F3,
 0x41F5, 0x5EF5, 0xA2F5, 0xBDF5, 0x64F6, 0x7BF6, 0x87F6, 0x98F6 //255
 };
 void playMbeFiles (dsd_opts * opts, dsd_state * state, int argc, char **argv)
 {
  int i;
@@ -60,79 +26,99 @@ void playMbeFiles (dsd_opts * opts, dsd_state * state, int argc, char **argv)
  char ambe_d[49];
  for (i = state->optind; i < argc; i++)
  {
    sprintf (opts->mbe_in_file, "%s", argv[i]);
    openMbeInFile (opts, state);
    mbe_initMbeParms (state->cur_mp, state->prev_mp, state->prev_mp_enhanced);
    fprintf (stderr, "playing %s\n", opts->mbe_in_file);
    while (feof (opts->mbe_in_f) == 0)
    {
-      if (state->mbe_file_type == 0)
+      sprintf (opts->mbe_in_file, "%s", argv[i]);
-      {
+      openMbeInFile (opts, state);
-        readImbe4400Data (opts, state, imbe_d);
+      mbe_initMbeParms (state->cur_mp, state->prev_mp, state->prev_mp_enhanced);
-        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);
+      fprintf (stderr, "playing %s\n", opts->mbe_in_file);
-        if (opts->audio_out == 1)
+      while (feof (opts->mbe_in_f) == 0)
        {
-          processAudio(opts, state);
+          if (state->mbe_file_type == 0)
-        }
+            {
-        if (opts->wav_out_f != NULL)
+              readImbe4400Data (opts, state, 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);
-            writeSynthesizedVoice (opts, state);
+              if (opts->audio_out == 1)
-          }
+              {
                processAudio(opts, state);
              }
              if (opts->wav_out_f != NULL)
                {
                  writeSynthesizedVoice (opts, state);
                }
-        if (opts->audio_out == 1)
+              if (opts->audio_out == 1)
-          {
+                {
-            playSynthesizedVoice (opts, state);
+                  playSynthesizedVoice (opts, state);
-          }
+                }
-      }
+            }
-      else if (state->mbe_file_type > 0) //ambe files
+          else if (state->mbe_file_type == 1)
-      {
+            {
-        readAmbe2450Data (opts, state, ambe_d);
+              readAmbe2450Data (opts, state, ambe_d);
-        int j, x;
+              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);
-        unsigned long long int k;
+              if (opts->audio_out == 1)
-        if (state->K != 0) //apply Pr key
+              {
-        {
+                processAudio(opts, state);
-          k = Pr[state->K];
+              }
-          k = ( ((k & 0xFF0F) << 32 ) + (k << 16) + k );
+              if (opts->wav_out_f != NULL)
-          for (short int j = 0; j < 48; j++) //49
+                {
-          {
+                  writeSynthesizedVoice (opts, state);
-            x = ( ((k << j) & 0x800000000000) >> 47 );
+                }
-            ambe_d[j] ^= x;
+              if (opts->audio_out == 1)
-          }
+                {
                  playSynthesizedVoice (opts, state);
                }
            }
          if (exitflag == 1)
            {
              cleanupAndExit (opts, state);
            }
        }
        //ambe+2
        if (state->mbe_file_type == 1) 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);
        //dstar ambe
        if (state->mbe_file_type == 2) mbe_processAmbe2400Dataf (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);
        if (opts->audio_out == 1)
        {
          processAudio(opts, state);
        }
        if (opts->wav_out_f != NULL)
        {
          writeSynthesizedVoice (opts, state);
        }
        if (opts->audio_out == 1)
        {
          playSynthesizedVoice (opts, state);
        }
      }
      if (exitflag == 1)
      {
        cleanupAndExit (opts, state);
      }
    }
  }
 }
 void
 processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char ambe_fr[4][24], char imbe7100_fr[7][24])
 {
  //
  int Pr[256] = {
    0x0000, 0x1F00, 0xE300, 0xFC00, 0x2503, 0x3A03, 0xC603, 0xD903,
    0x4A05, 0x5505, 0xA905, 0xB605, 0x6F06, 0x7006, 0x8C06, 0x9306,
    0x2618, 0x3918, 0xC518, 0xDA18, 0x031B, 0x1C1B, 0xE01B, 0xFF1B,
    0x6C1D, 0x731D, 0x8F1D, 0x901D, 0x491E, 0x561E, 0xAA1E, 0xB51E, //31
    0x4B28, 0x5428, 0xA828, 0xB728, 0x6E2B, 0x712B, 0x8D2B, 0x922B,
    0x012D, 0x1E2D, 0xE22D, 0xFD2D, 0x242E, 0x3B2E, 0xC72E, 0xD82E,
    0x6D30, 0x7230, 0x8E30, 0x9130, 0x4833, 0x5733, 0xAB33, 0xB433,
    0x2735, 0x3835, 0xC435, 0xDB35, 0x0236, 0x1D36, 0xE136, 0xFE36, //63
    0x2B49, 0x3449, 0xC849, 0xD749, 0x0E4A, 0x114A, 0xED4A, 0xF24A,
    0x614C, 0xAE4C, 0x824C, 0x9D4C, 0x444F, 0x5B4F, 0xA74F, 0xB84F,
    0x0D51, 0x1251, 0xEE51, 0xF151, 0x2852, 0x3752, 0xCB52, 0xD452,
    0x4754, 0x5854, 0xA454, 0xBB54, 0x6257, 0x7D57, 0x8157, 0x9E57, //95
    0x6061, 0x7F61, 0x8361, 0x9C61, 0x4562, 0x5A62, 0xA662, 0xB962,
    0x2A64, 0x3564, 0xC964, 0xD664, 0x0F67, 0x1067, 0xEC67, 0xF367,
    0x4679, 0x5979, 0xA579, 0xBA79, 0x637A, 0x7C7A, 0x807A, 0x9F7A,
    0x0C7C, 0x137C, 0xEF7C, 0xF07C, 0x297F, 0x367F, 0xCA7F, 0xD57F, //127
    0x4D89, 0x5289, 0xAE89, 0xB189, 0x688A, 0x778A, 0x8B8A, 0x948A,
    0x078C, 0x188C, 0xE48C, 0xFB8C, 0x228F, 0x3D8F, 0xC18F, 0xDE8F,
    0x6B91, 0x7491, 0x8891, 0x9791, 0x4E92, 0x5192, 0xAD92, 0xB292,
    0x2194, 0x3E94, 0xC294, 0xDD94, 0x0497, 0x1B97, 0xE797, 0xF897, //159
    0x06A1, 0x19A1, 0xE5A1, 0xFAA1, 0x23A2, 0x3CA2, 0xC0A2, 0xDFA2,
    0x4CA4, 0x53A4, 0xAFA4, 0xB0A4, 0x69A7, 0x76A7, 0x8AA7, 0x95A7,
    0x20B9, 0x3FB9, 0xC3B9, 0xDCB9, 0x05BA, 0x1ABA, 0xE6BA, 0xF9BA,
    0x6ABC, 0x75BC, 0x89BC, 0x96BC, 0x4FBF, 0x50BF, 0xACBF, 0xB3BF, //191
    0x66C0, 0x79C0, 0x85C0, 0x9AC0, 0x43C3, 0x5CC3, 0xA0C3, 0xBFC3,
    0x2CC5, 0x33C5, 0xCFC5, 0xD0C5, 0x09C6, 0x16C6, 0xEAC6, 0xF5C6,
    0x84D0, 0x85DF, 0x8AD3, 0x8BDC, 0xB6D5, 0xB7DA, 0xB8D6, 0xB9D9,
    0xD0DA, 0xD1D5, 0xDED9, 0xDFD6, 0xE2DF, 0xE3D0, 0xECDC, 0xEDD3, //223
    0x2DE8, 0x32E8, 0xCEE8, 0xD1E8, 0x08EB, 0x17EB, 0xEBEB, 0xF4EB,
    0x67ED, 0x78ED, 0x84ED, 0x9BED, 0x42EE, 0x5DEE, 0xA1EE, 0xBEEE,
    0x0BF0, 0x14F0, 0xE8F0, 0xF7F0, 0x2EF3, 0x31F3, 0xCDF3, 0xD2F3,
    0x41F5, 0x5EF5, 0xA2F5, 0xBDF5, 0x64F6, 0x7BF6, 0x87F6, 0x98F6 //255
  };
  //
 	int i;
  char imbe_d[88];
  char ambe_d[49];
@@ -140,10 +126,8 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
  unsigned long long int k;
  int x;
-  //24-bit TG to 16-bit hash
+  int preempt = 0; //TDMA dual voice slot preemption(when using OSS output)
-  uint32_t hash = 0;
+
  uint8_t hash_bits[24];
  memset (hash_bits, 0, sizeof(hash_bits));
  for (i = 0; i < 88; i++)
  {
@@ -215,16 +199,17 @@ 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);
@@ -294,34 +279,6 @@ 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 (converted to decimal)
        if (state->M == 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) )
        {
@@ -407,13 +364,6 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
        {
          PrintAMBEData (opts, state, ambe_d);
        }
        //restore MBE file save, slot 1 -- consider saving even if enc
        if (opts->mbe_out_f != NULL && (state->dmr_encL == 0 || opts->dmr_mute_encL == 0) )
        {
          saveAmbe2450Data (opts, state, ambe_d);
        }
      }
      //stereo slots and slot 1 (right slot)
      if (state->currentslot == 1) //&& opts->dmr_stereo == 1
@@ -424,34 +374,6 @@ 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 (converted to decimal)
        if (state->M == 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) )
        {
@@ -536,12 +458,6 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
        {
          PrintAMBEData (opts, state, ambe_d);
        }
        //restore MBE file save, slot 2 -- consider saving even if enc
        if (opts->mbe_out_fR != NULL && (state->dmr_encR == 0 || opts->dmr_mute_encR == 0) )
        {
          saveAmbe2450DataR (opts, state, ambe_d);
        }
      }
      //X2-TDMA? Not sure what still makes it this far to run under Framef
@@ -608,6 +524,14 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
    }
    //end reverse mute test
    //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) 
    {
      opts->audio_out = 0;
      preempt = 1;
      if (opts->payload == 0) fprintf (stderr, " *MUTED*"); 
    }
    if (state->dmr_encL == 0 || opts->dmr_mute_encL == 0)
    {
      state->debug_audio_errors += state->errs2;
@@ -664,6 +588,14 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
    }
    //end reverse mute test
    //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) 
    {
      opts->audio_out = 0;
      preempt = 1;
      if (opts->payload == 0) fprintf (stderr, " *MUTED*"); 
    }
    if (state->dmr_encR == 0 || opts->dmr_mute_encR == 0)
    {
      state->debug_audio_errorsR += state->errs2R;
@@ -718,6 +650,12 @@ processMbeFrame (dsd_opts * opts, dsd_state * state, char imbe_fr[8][23], char a
    }
 	}
  if (preempt == 1)
  {
    opts->audio_out = 1;
    preempt = 0; 
  }
  //reset audio out flag for next repitition
  if (strcmp(mode, "B") == 0) opts->audio_out = 1;
  //restore flag for null output type
--- a/src/dsd_ncurses.c
+++ b/src/dsd_ncurses.c
--- a/src/dsd_rigctl.c
+++ b/src/dsd_rigctl.c
@@ -273,9 +273,4 @@ void rtl_udp_tune(dsd_opts * opts, dsd_state * state, long int frequency)
    address.sin_addr.s_addr = inet_addr("127.0.0.1"); //make user configurable later
    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.
 }
--- a/src/dsd_symbol.c
+++ b/src/dsd_symbol.c
@@ -82,35 +82,24 @@ getSymbol (dsd_opts * opts, dsd_state * state, int have_sync)
        }
      // Read the new sample from the input
-      if(opts->audio_in_type == 0) // && state->menuopen == 0 still not quite working
+      if(opts->audio_in_type == 0) //pulse audio
      {
-          pa_simple_read(opts->pulse_digi_dev_in, &sample, 2, NULL );
+        pa_simple_read(opts->pulse_digi_dev_in, &sample, 2, NULL );
          //look into how processAudio handles playback, not sure if latency issues, or garbage sample values crash pulse when written
          // if (opts->monitor_input_audio == 1 && state->lastsynctype == -1 && sample < 32767 && sample > -32767)
          if (opts->monitor_input_audio == 1 && state->lastsynctype == -1 && sample != 0)
          {
            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);
          }
          //playback is wrong, depends on samples_per_symbol, maybe make a buffer and store first?
          //making buffer might also fix raw audio monitoring as well
          if (opts->wav_out_file_raw[0] != 0) //if set for recording sample raw files
          {
            //writeRawSample (opts, state, sample);
          }
      }
      else if (opts->audio_in_type == 5) //OSS
      {
        read (opts->audio_in_fd, &sample, 2);
      }
      //stdin only, wav files moving to new number
-      else if (opts->audio_in_type == 1)
+      else if (opts->audio_in_type == 1) //won't work in windows, needs posix pipe (mintty)
      {
        result = sf_read_short(opts->audio_in_file, &sample, 1);
        if(result == 0)
        {
          //cleanupAndExit (opts, state);
          sf_close(opts->audio_in_file);
-          opts->audio_in_type = 0; //set input type
+          cleanupAndExit (opts, state);
          openPulseInput(opts); //open pulse inpput
          sample = 0; //send zero sample 
        }
      }
      //wav files, same but using seperate value so we can still manipulate ncurses menu
@@ -122,10 +111,15 @@ getSymbol (dsd_opts * opts, dsd_state * state, int have_sync)
        {
          sf_close(opts->audio_in_file);
-          opts->audio_in_type = 0; //set input type
+          fprintf (stderr, "\n\nEnd of .wav file.\n");
-          openPulseInput(opts); //open pulse inpput
+          //open pulse input if we are pulse output AND using ncurses terminal
-          sample = 0; //send zero sample 
+          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);             
        }
      }
      else if (opts->audio_in_type == 3)
@@ -142,62 +136,33 @@ getSymbol (dsd_opts * opts, dsd_state * state, int have_sync)
 #endif
      }
      //tcp socket input from SDR++
      else if (opts->audio_in_type == 8)
      {
        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
+          fprintf (stderr, "Connection to TCP Server Disconnected.\n");
-          opts->tcp_sockfd = 0;  
+          //open pulse input if we are pulse output AND using ncurses terminal
-          opts->tcp_sockfd = Connect(opts->tcp_hostname, opts->tcp_portno);
+          if (opts->audio_out_type == 0 && opts->use_ncurses_terminal == 1)
          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 input
            openPulseInput(opts); //open pulse inpput
            sample = 0; //zero sample on bad result, keep the ball rolling
            fprintf (stderr, "Connection to TCP Server Disconnected.\n");
          } 
          //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)
+      // else if (opts->audio_in_type == 6)
-      {
+      // {
        //I think this doesn't get the entire dgram when we run sf_read_short on the udp dgram
-        result = sf_read_short(opts->udp_file_in, &sample, 1); 
+        // result = sf_read_short(opts->udp_file_in, &sample, 1); 
        // if (sample != 0)
        //   fprintf (stderr, "Result = %d Sample = %d \n", result, sample);
-      }
+      // }
      if (opts->use_cosine_filter)
        {
@@ -416,6 +381,12 @@ getSymbol (dsd_opts * opts, dsd_state * state, int have_sync)
  }
 #endif
  //test throttle on wav input files
 	if (opts->audio_in_type == 2)
 	{
 		if (state->use_throttle == 1) usleep(.003); //very environment specific, tuning to cygwin
 	}
  //read op25/fme symbol bin files
  if (opts->audio_in_type == 4)
  {
@@ -432,14 +403,23 @@ getSymbol (dsd_opts * opts, dsd_state * state, int have_sync)
    useconds_t stime = state->symbol_throttle;
    if (state->use_throttle == 1)
    {
-      usleep(stime);
+      // usleep(stime);
      usleep(.003); //very environment specific, tuning to cygwin
    }
    //fprintf(stderr, "%d", state->symbolc);
    if( feof(opts->symbolfile) )
    {
-      opts->audio_in_type = 0; //switch to pulse after playback, ncurses terminal can initiate replay if wanted
+      // opts->audio_in_type = 0; //switch to pulse after playback, ncurses terminal can initiate replay if wanted
      fclose(opts->symbolfile);
-      openPulseInput(opts);
+      fprintf (stderr, "\n\nEnd of .bin file\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);
    }
    //assign symbol/dibit values based on modulation type
--- a/src/ez.cpp
+++ b/src/ez.cpp
@@ -312,11 +312,11 @@ void map_isch()
 	isch_map["fb063f092"] = 127;
 }
-int isch_lookup (unsigned long long int isch)
+unsigned long long int isch_lookup (unsigned long long int isch)
 {
  map_isch(); //initialize the lookup map
  char s[64];
-  int decoded = -2; //initialize lookup to an invalid number
+  unsigned long long int decoded = -2; //initialize lookup to an invalid number
  sprintf(s, "%llx", isch);
  decoded = isch_map[s];
  return(decoded);
--- a/src/nxdn_convolution.c
+++ b/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;
-//NOTE:
+static uint16_t   m_metrics1[16U] = {0};
-static uint16_t   m_metrics1[16U];
+static uint16_t   m_metrics2[16U] = {0};
-static uint16_t   m_metrics2[16U];
+static uint64_t   m_decisions[300U] = {0};
 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,15 +158,13 @@ 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);
 }
--- a/src/nxdn_deperm.c
+++ b/src/nxdn_deperm.c
@@ -42,8 +42,7 @@ static const int PARITY[] = {
 //decoding functions here
 void nxdn_descramble(uint8_t dibits[], int len)
 {
-	for (int i=0; i<len; i++)
+	for (int i=0; i<sizeof(scramble_t); i++) {
 	{
 		if (scramble_t[i] >= len)
 			break;
 		dibits[scramble_t[i]] ^= 0x2;	// invert sign of scrambled dibits
@@ -52,15 +51,13 @@ 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[200]; //144
+	uint8_t deperm[144];
-	uint8_t depunc[200]; //192
+	uint8_t depunc[192];
-	uint8_t trellis_buf[400]; //96
+	uint8_t trellis_buf[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]; 
@@ -76,7 +73,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[20]; //13
+	uint8_t m_data[13];
 	memset (temp, 0, sizeof(temp));
 	memset (m_data, 0, sizeof(m_data));
 	memset (trellis_buf, 0, sizeof(trellis_buf));
@@ -114,23 +111,17 @@ void nxdn_deperm_facch(dsd_opts * opts, dsd_state * state, uint8_t bits[144])
    trellis_buf[(i*8)+7] = (m_data[i] >> 0) & 1;
  }
-	crc = crc12f (trellis_buf, 84); //80
+	//load tail 16 bits into check variable to compare vs computed crc value
 	for (int i = 0; i < 12; i++)
 	{
 		check = check << 1;
-		check = check | trellis_buf[84+i]; //80
+		check = check + trellis_buf[80+i];
 	}
-	if (crc != check)
+	crc = crc12f (trellis_buf, 80);
 	{
 		fprintf (stderr, " FACCH");
 		fprintf (stderr, "%s", KRED);
 		fprintf (stderr, " (CRC ERR)");
 		fprintf (stderr, "%s", KNRM);
 	}
 	if (crc == check) NXDN_Elements_Content_decode(opts, state, 1, trellis_buf); 
-	else if (opts->aggressive_framesync == 0) NXDN_Elements_Content_decode(opts, state, 0, trellis_buf);
+	//else if (opts->payload == 1) NXDN_Elements_Content_decode(opts, state, 0, trellis_buf);
 	if (opts->payload == 1)
 	{
@@ -140,23 +131,18 @@ void nxdn_deperm_facch(dsd_opts * opts, dsd_state * state, uint8_t bits[144])
 		{
 			fprintf (stderr, "[%02X]", m_data[i]); 
 		}
-		// fprintf (stderr, " - %03X %03X", check, crc);
+		fprintf (stderr, " - %03X %03X", crc, check);
 	}
 }
-//sacch
+//new sacch
 void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
 {
-	//see about initializing these variables
+	uint8_t deperm[60];
-	uint8_t deperm[200]; //60 
+	uint8_t depunc[72];
-	uint8_t depunc[200]; //72
+	uint8_t trellis_buf[32];
-	uint8_t trellis_buf[400]; //32
+	uint8_t answer[26];
 	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
@@ -185,7 +171,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[10]; //5
+	uint8_t m_data[5];
 	memset (temp, 0, sizeof (temp));
 	memset (m_data, 0, sizeof (m_data));
@@ -202,7 +188,7 @@ void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
 	}
 	CNXDNConvolution_start();
-  for (int i = 0U; i < 36U; i++) //40
+  for (int i = 0U; i < 40U; i++) 
  {
    s0 = temp[(2*i)];
    s1 = temp[(2*i)+1];
@@ -211,7 +197,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, 32U); //36
+  CNXDNConvolution_chainback(m_data, 36U); 
 	for(int i = 0; i < 4; i++)
  {
@@ -225,11 +211,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, 26); //32
+	crc = crc6(trellis_buf, 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
@@ -238,44 +224,25 @@ 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[400];
+		uint8_t nsf_sacch[26];
 		memset (nsf_sacch, 0, sizeof(nsf_sacch));
 		for (int i = 0; i < 26; i++)
 		{
 			nsf_sacch[i] = trellis_buf[i+8];
 		}
-		if (crc == check)
+		if (crc == 0) NXDN_Elements_Content_decode(opts, state, 1, nsf_sacch);
 		{
 			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;
 		} 
 		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);
 		if (crc != check)
 		{
 			fprintf (stderr, " SACCH NSF");
 			fprintf (stderr, "%s", KRED);
 			fprintf (stderr, " (CRC ERR)");
 			fprintf (stderr, "%s", KNRM);
 		}
 		if (opts->payload == 1)
 		{ 
 			fprintf (stderr, "\n SACCH NSF ");
-			for (int i = 0; i < 4; i++)
+			for (int i = 0; i < 5; i++)
 			{
 				fprintf (stderr, "[%02X]", m_data[i]);
 			}
-			// if (crc != check) fprintf (stderr, " CRC ERR - %02X %02X", check, crc); 
+			if (crc != 0) fprintf (stderr, " CRC ERR - %02X %02X", crc, check);
 		}
 		//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));
 	}
 	//If part of superframe, collect the fragments and send to NXDN_SACCH_Full_decode instead
@@ -284,7 +251,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;
@@ -296,20 +263,11 @@ void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
 		else fprintf (stderr, "        ");
 		fprintf (stderr, "%s", KNRM);
 		if (crc != check)
 		{
 			fprintf (stderr, " SACCH SF%d", sf);
 			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 == check)
+		if (crc == 0)
 		{
 			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;
@@ -336,27 +294,24 @@ void nxdn_deperm_sacch(dsd_opts * opts, dsd_state * state, uint8_t bits[60])
 		{ 
 			fprintf (stderr, "\n"); 
 			fprintf (stderr, " SACCH SF Segment #%d ", part_of_frame+1);
-			for (int i = 0; i < 4; i++)
+			for (int i = 0; i < 5; i++)
 			{
 				fprintf (stderr, "[%02X]", m_data[i]);
 			}
-			// if (crc != check) fprintf (stderr, " CRC ERR - %02X %02X", crc, check);
+			if (crc != 0) fprintf (stderr, " CRC ERR - %02X %02X", crc, check);
 		}
 	}	
 }
-void nxdn_deperm_facch2_udch(dsd_opts * opts, dsd_state * state, uint8_t bits[348], uint8_t type)
+void nxdn_deperm_facch2_udch(dsd_opts * opts, dsd_state * state, uint8_t bits[348])
 {
-	uint8_t deperm[500]; //348
+
-	uint8_t depunc[500]; //406
+	uint8_t deperm[348];
-	uint8_t trellis_buf[400]; //199
+	uint8_t depunc[406];
 	uint8_t trellis_buf[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];
@@ -379,10 +334,10 @@ void nxdn_deperm_facch2_udch(dsd_opts * opts, dsd_state * state, uint8_t bits[34
 	}
 	//switch to the convolutional decoder
-	uint8_t temp[500]; //220, this one was way too small
+	uint8_t temp[220];
 	uint8_t s0;
  uint8_t s1;
-	uint8_t m_data[52]; //26
+	uint8_t m_data[26];
 	memset (trellis_buf, 0, sizeof(trellis_buf));
 	memset (temp, 0, sizeof (temp));
 	memset (m_data, 0, sizeof (m_data));
@@ -422,23 +377,8 @@ 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];
 	}
-	if (crc != check)
+	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", KRED);
 		fprintf (stderr, " (CRC ERR)");
 		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,
@@ -448,57 +388,35 @@ 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 == check)
+	if (crc == 0)
 	{
-		if (type == 1) NXDN_Elements_Content_decode(opts, state, 1, f2u_message_buffer);
+		fprintf (stderr, " F2/U   "); 
-		if (type == 0) ; //need handling for user data (text messages and AVL)
+		//NXDN_Elements_Content_decode(opts, state, 1, trellis_buf); 
-	} 
+		NXDN_Elements_Content_decode(opts, state, 1, f2u_message_buffer); 
 	else if (opts->aggressive_framesync == 0)
 	{
 		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");
-		if (type == 0) fprintf (stderr, " UDCH");
+		fprintf (stderr, " F2/U Payload\n  ");
 		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 != check) fprintf (stderr, " CRC ERR ");
+		if (crc != 0) 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[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));
+	uint8_t deperm[300];
-	memset (depunc, 0, sizeof(depunc));
+	uint8_t depunc[350];
 	uint8_t trellis_buf[171];
 	int id = 0;
 	uint16_t crc = 0;
 	for (int i=0; i<300; i++) {
 		deperm[PERM_12_25[i]] = bits[i];
@@ -524,7 +442,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[52]; //26
+	uint8_t m_data[26];
 	memset (trellis_buf, 0, sizeof(trellis_buf));
 	memset (temp, 0, sizeof (temp));
 	memset (m_data, 0, sizeof (m_data));
@@ -534,6 +452,11 @@ 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++) 
  {
@@ -559,38 +482,30 @@ void nxdn_deperm_cac(dsd_opts * opts, dsd_state * state, uint8_t bits[300])
 	crc = crc16cac(trellis_buf, 171); 
-	uint8_t cac_message_buffer[400]; //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];
 	memset (cac_message_buffer, 0, sizeof(cac_message_buffer));
-	//shift the cac_message into the appropriate byte arrangement for element_decoder -- skip SR field
+	//shift the cac_message into the appropriate byte arrangement for element_decoder
-	for (int i = 0; i < 160; i++)
+	for (int i = 0; i < 160; i++) //in future, we can use this to send multiple messages to decoder, if present
 	{
 		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)
 	{
-		ran = (trellis_buf[2] << 5) | (trellis_buf[3] << 4) | (trellis_buf[4] << 3) | (trellis_buf[5] << 2) | (trellis_buf[6] << 1) | trellis_buf[7];
+		fprintf (stderr, " CAC    ");
-		state->nxdn_last_ran = ran;
+		NXDN_Elements_Content_decode(opts, state, 1, cac_message_buffer);
 	} 
 	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");
@@ -600,286 +515,7 @@ 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)
 	{
 		fprintf (stderr, "%s", KRED);
 		fprintf (stderr, " (CRC ERR)");
 		fprintf (stderr, "%s", KNRM);
 	}
 	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, " CRC ERR - %02X %02X", check, crc); 
 	}
 	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];
 	}
 	if (crc[0] != check[0] || crc[1] != check[1])
 	{
 		if (type == 0) fprintf (stderr, " UDCH2");
 		if (type == 1) fprintf (stderr, " FACCH3");
 		fprintf (stderr, "%s", KRED);
 		fprintf (stderr, " (CRC ERR)");
 		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]); 
 		}
 		// 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, " ");
 			}
 		}
 	} 
@@ -888,32 +524,23 @@ void nxdn_deperm_facch3_udch2(dsd_opts * opts, dsd_state * state, uint8_t bits[2
 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 == 0x00) fprintf(stderr, " CALL_RESP");
+	else if (MessageType == 0x11) fprintf(stderr, " DISC"); //disconnect
 	else if (MessageType == 0x01) fprintf(stderr, " VCALL");
-	else if (MessageType == 0x02) fprintf(stderr, " VCALL_REC_REQ");
+	else if (MessageType == 0x03) fprintf(stderr, " VCALL IV");
-	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 == 0x04) fprintf(stderr, " VCALL_ASSGN");
-	else if (MessageType == 0x0B) fprintf(stderr, " DCALL_UDATA");
+	else if (MessageType == 0x05) fprintf(stderr, " VCALL_ASSGN_DUP");
 	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 == 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");
@@ -922,23 +549,24 @@ 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 on DISC or TX_REL only (IDLE messaages occur often on NXDN96 VCH, and randomly on Type-C FACCH1 steals for some reason)
+	//zero out stale values so they won't persist after a transmit release
-	if (MessageType == 0x08 || MessageType == 0x11)
+	//disable if random messages wipe out the alias
 	if (MessageType == 0x08 || MessageType == 0x10) //idle, tx_rel
 	{
 		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; //force will reactivate it if needed during voice tx
+		state->nxdn_cipher_type = 0;
 		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, 1, sizeof(state->nxdn_sacch_frame_segment));
+		memset (state->nxdn_sacch_frame_segment, 0, sizeof(state->nxdn_sacch_frame_segment));
 		sprintf (state->nxdn_call_type, "%s", "");
 	} 
 }
 //voice descrambler
@@ -1041,32 +669,13 @@ static uint16_t crc15(const uint8_t buf[], int len)
 static uint16_t crc16cac(const uint8_t buf[], int len)
 {
-	uint32_t crc = 0xc3ee; //not sure why this though
+	int crc = 0xc3ee;
-	uint32_t poly = (1<<12) + (1<<5) + 1; //poly is fine
+        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;
 	}
 	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];
+                crc = ((crc << 1) | buf[i]) & 0x1ffff;
-		s[0] = s[1];
+                if(crc & 0x10000)
-		s[1] = s[2]; 
+                        crc = (crc & 0xffff) ^ poly;
 		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);
+        crc = crc ^ 0xffff;
        return crc & 0xffff;
 }
--- a/src/nxdn_element.c
+++ b/src/nxdn_element.c
--- a/src/nxdn_frame.c
+++ b/src/nxdn_frame.c
@@ -32,74 +32,53 @@ 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 voice=0;
-	int facch = 0;
+	int facch=0;
-	int facch2 = 0;
+	int facch2=0;
-	int udch = 0;
+	int sacch=0;
-	int sacch = 0;
+	int cac=0;
 	int cac = 0;
 	int sr_structure;
 	int sr_ran;
-	//new, and even more confusing NXDN Type-D / "IDAS" acronyms
+	uint8_t lich_dibits[8] = {0}; 
-	int idas = 0;
+	uint8_t sacch_bits[60] = {0};
-	int scch = 0;
+	uint8_t facch_bits_a[144] = {0};
-	int facch3 = 0;
+	uint8_t facch_bits_b[144] = {0};
-	int udch2 = 0;
+	uint8_t cac_bits[300] = {0};
 	uint8_t facch2_bits[348] = {0}; //facch2 or udch, same amount of bits
-	//new breakdown of lich codes
+  //nxdn bit buffer, for easy assignment handling
-	uint8_t lich_rf = 0; //RF Channel Type
+  int nxdn_bit_buffer[364] = {0}; 
-	uint8_t lich_fc = 0; //Functional Channel Type
+	int nxdn_dibit_buffer[182] = {0};
 	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 amoount 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)
-	{
+  {
-		if (opts->payload == 1) fprintf(stderr, "  Lich Parity Error %02X\n", lich);
+    //fprintf(stderr, "NXDN lich parity error, ignoring frame \n");
-		state->lastsynctype = -1; //set to -1 so we don't jump back here too quickly 
+		return;
 		goto END;
 	}
 	voice = 0;
@@ -107,16 +86,6 @@ 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:
@@ -124,20 +93,21 @@ 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:
-		udch = 1;
+	case 0x69:
 	case 0x6f:
 		facch2 = 1;
 		break;
 	case 0x32:  //facch in 1, vch in 2
 	case 0x33:
 	case 0x52:
 	case 0x53:
 	case 0x73:
 		voice = 2;	
 		facch = 1;
 		sacch = 1;
@@ -145,7 +115,8 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
 	case 0x34:  //vch in 1, facch in 2
 	case 0x35:
 	case 0x54:
-	case 0x55: //disabled for testing, IDAS system randomly triggers this one, probably due to poor signal
+	case 0x55:
 	case 0x75:
 		voice = 1;	
 		facch = 2;
 		sacch = 1;
@@ -154,6 +125,7 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
 	case 0x37:
 	case 0x56:
 	case 0x57: 
 	case 0x77:
 		voice = 3;	
 		facch = 0;
 		sacch = 1;
@@ -166,6 +138,8 @@ 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;
@@ -174,63 +148,10 @@ 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, 1, sizeof(state->nxdn_sacch_frame_segment));
+		memset (state->nxdn_sacch_frame_segment, 0, 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;
@@ -238,29 +159,17 @@ 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 (idas)
+	if (voice || facch || sacch || facch2 || cac)
 	{
 		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 || 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)
+		if (opts->payload == 1) fprintf (stderr, "L%02X -", lich);
 			fprintf (stderr, "L%02X - ", lich);
 	}
 	//now that we have a good LICH, we can collect all of our dibits
@@ -279,7 +188,7 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
 		nxdn_bit_buffer[i*2+1] = dbuf[i] & 1;
 	}
-	//sacch or scch bits
+	//sacch
 	for (int i = 0; i < 60; i++)
 	{
 		sacch_bits[i] = nxdn_bit_buffer[i+16];
@@ -304,119 +213,23 @@ 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
-	//Add advanced decoding of LICH (RF, FC, OPT, and Direction
+	if (voice)
 	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
 	//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 if (voice && facch) //voice with facch1 steal
+	else
 	{
 		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) 
+		if (state->nxdn_cipher_type == 0x1 && state->R != 0) //!voice, or voice == 0
 		{
 			char ambe_temp[49] = {0};
 			char ambe_d[49] = {0};
@@ -428,86 +241,14 @@ void nxdn_frame (dsd_opts * opts, dsd_state * state)
 	}  
-	if (voice && facch == 1) //facch steal 1 -- before voice
+	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);
-		//force scrambler here, but with unspecified key (just use what's loaded)
+	if (cac) nxdn_deperm_cac(opts, state, cac_bits); 
-		if (state->M == 1 && state->R != 0) state->nxdn_cipher_type = 0x1; 
+	if (facch2) nxdn_deperm_facch2_udch(opts, state, facch2_bits);
 		//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);
 	if (voice) nxdn_voice (opts, state, voice, dbuf); 
-	if (voice)
+	fprintf (stderr, "\n");
 	{
 		//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 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 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");
 	END: ; //do nothing
 }
--- a/src/p25_frequency.c
+++ b/src/p25_frequency.c
@@ -2,7 +2,7 @@
 * p25_frequency.c
 * P25 Channel to Frequency Calculator
 *
- * NXDN Channel to Frequency Calculator
+ * NXDN Channel to Frequency, Courtesy of IcomIcR20 and EricCottrell (base values)
 * 
 * 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;
-	//reworked to include Direct Frequency Assignment if available
+	//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
-	//first, check channel map for imported value, DFA systems most likely won't need an import,
+	//first, check channel map
 	//unless it has 'system definable' attributes
 	if (state->trunk_chan_map[channel] != 0)
 	{
 		freq = state->trunk_chan_map[channel];
@@ -76,41 +76,33 @@ long int nxdn_channel_to_frequency(dsd_opts * opts, dsd_state * state, uint16_t
 		return (freq);
 	}
-	//then, let's see if its DFA instead -- 6.5.36
+	//if not found, attempt to find it via calculation 
-	else if (state->nxdn_rcn == 1)
+	else
 	{
-		//determine the base frequency in Hz
+		if ((channel > 0) && (channel <= 400))
 		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
 		//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);
+			if (opts->frame_nxdn48 == 1) base = 450000000;
-			fprintf (stderr, "\n  DFA Frequency [%.6lf] MHz", (double)freq/1000000);
+			else base = 451000000;
 			freq = base + (channel - 1) * 12500;
 			fprintf (stderr, "\n  Frequency [%.6lf] MHz", (double)freq/1000000);
 			return (freq);
 		}
 		else if ((channel >= 401) && (channel <= 800))
 		{
 			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    Custom DFA Settings -- Unknown Freq;");
+			fprintf(stderr, "\n  Non-standard frequency or channel not found in import file");
 			return (0);
 		}
 	}
 	else
 	{
 		fprintf(stderr, "\n    Channel not found in import file");
 		return (0);
 	} 
 }
--- a/src/p25_lcw.c
+++ b/src/p25_lcw.c
@@ -1,350 +1,160 @@
 /*-------------------------------------------------------------------------------
 * p25_lcw.c
 * P25p1 Link Control Word Decoding
 *
 * LWVMOBILE
 * 2023-05 DSD-FME Florida Man Edition
 *-----------------------------------------------------------------------------*/
 #include "dsd.h"
-//new p25_lcw function here -- TIA-102.AABF-D LCW Format Messages (if anybody wants to fill the rest out)
+void
-void p25_lcw (dsd_opts * opts, dsd_state * state, uint8_t LCW_bits[], uint8_t irrecoverable_errors)
+processP25lcw (dsd_opts * opts, dsd_state * state, char *lcformat, char *mfid, char *lcinfo)
 {
  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
-  if (lc_pf == 1) //check the protect flag -- if set, its an encrypted lcw
+  char tgid[17], tmpstr[255];
-  {
+  long talkgroup, source;
-    fprintf (stderr, "%s",KRED);
+  int i, j;
    fprintf (stderr, " LCW Protected ");
    fprintf (stderr, "%s",KNRM);
  }
-  if (lc_pf == 0) //not protected/encrypted lcw
+  tgid[16] = 0;
  {
-    if (opts->payload == 1) fprintf (stderr, " LCW"); 
+  if (opts->p25lc == 1)
    //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
    {
-
+      fprintf (stderr, "lcformat: %s mfid: %s lcinfo: %s ", lcformat, mfid, lcinfo);
-      //check the service options on applicable formats
+      if (opts->p25tg == 0)
      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 (lc_svcopt & 0x20) fprintf (stderr, " Duplex");
+          fprintf (stderr, "\n");
          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
        }
      }
      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)
        {
          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 (channel2 && group2 && group1 != group2)
        {
          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/Cancellation");
        if (opts->p25_trunk == 1 && state->p25_cc_freq != 0 && opts->p25_is_tuned == 1)
        {
          //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_udp
          else if (opts->audio_in_type == 3)
          {
            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_udp_tune (opts, state,  state->p25_cc_freq); 
          }
        }
      }
      else fprintf (stderr, " Unknown Format %02X MFID %02X SVC %02X", lc_format, lc_mfid, lc_svcopt);
    }
-    //not a duplicate, this one will print if not MFID 0 or 1
+  if (strcmp (lcformat, "00000100") == 0)
-    else fprintf (stderr, " Unknown Format %02X MFID %02X ", lc_format, lc_mfid);
+    {
  }
-  //ending line break
+      // first tg is the active channel
-  fprintf (stderr, "\n");
+      j = 0;
      for (i = 40; i < 52; 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;
      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);
        }
      if (opts->p25tg == 1)
        {
          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);
        }
    }
  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);
        }
      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");
    }
 }
--- a/src/p25p1_block.cpp
+++ b/src/p25p1_block.cpp
@@ -40,8 +40,7 @@ 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 */
--- a/src/p25p1_hdu.c
+++ b/src/p25p1_hdu.c
@@ -453,40 +453,93 @@ processHDU(dsd_opts* opts, dsd_state* state)
  status = getDibit (opts, state);
  //TODO: Do something useful with the status bits...
-  algidhex = strtol (algid, NULL, 2);
+  //if (state->carrier == 1 && state->errs == 0) //only update when carrier is present, and no errors??
-  kidhex = strtol (kid, NULL, 2);
+  if (state->carrier == 1)
-  mihex1 = (unsigned long long int)ConvertBitIntoBytes(&mi[0], 32);
+  {
-  mihex2 = (unsigned long long int)ConvertBitIntoBytes(&mi[32], 32);
+    algidhex = strtol (algid, NULL, 2);
-  mihex3 = (unsigned long long int)ConvertBitIntoBytes(&mi[64], 8);
+    kidhex = strtol (kid, NULL, 2);
    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);
  }
  //set vc counter to 0
  state->p25vc = 0;
-  if (irrecoverable_errors == 0)
+  if (state->payload_algid != 0x80 && state->payload_algid != 0x0) //print on payload == 1
  {
    fprintf (stderr, "%s", KYEL);
-    fprintf (stderr, " HDU  ALG ID: 0x%02X KEY ID: 0x%02X MI: 0x%08llX%08llX%02llX", algidhex, kidhex, mihex1, mihex2, mihex3);
+    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, "%s", KNRM);
-    state->payload_algid = algidhex;
+  }
    state->payload_keyid = kidhex;
    //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) //print on payload == 1
+  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)
    {
-      fprintf (stderr, "%s", KRED);
+      algidhex = strtol (algid, NULL, 2);
-      fprintf (stderr, " ENC");
+      kidhex = strtol (kid, NULL, 2);
-      fprintf (stderr, "%s", KNRM);
+    }
  if (opts->p25lc == 1)
    {
      fprintf (stderr, "mfid: %s tgid: %s ", mfid, tgid);
      if (opts->p25tg == 0)
        {
          fprintf (stderr, "\n");
        }
    }
-    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
-  {
+    {
-      fprintf (stderr, "%s", KRED);
+      for (i = 0; i < 16; i++)
-      fprintf (stderr, " HDU FEC ERR \n");
+        {
-      fprintf (stderr, "%s", KNRM);
+          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);
    }
 }
--- a/src/p25p1_ldu1.c
+++ b/src/p25p1_ldu1.c
@@ -324,53 +324,15 @@ processLDU1 (dsd_opts* opts, dsd_state* state)
  lcinfo[54]  = hex_data[ 0][4] + '0';
  lcinfo[55]  = hex_data[ 0][5] + '0';
-  int j;
+  unsigned long long int lcinfohex = 0;
-  uint8_t LCW_bytes[9];
+  if (state->carrier == 1 && state->errs == 0) //only update when carrier is present, otherwise, garbage values may be collected
  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)
  {
-    LCW_bits[j + 0] = (LCW_bytes[i] >> 7) & 0x01;
+    state->payload_mfid = strtol (mfid, NULL, 2);
-    LCW_bits[j + 1] = (LCW_bytes[i] >> 6) & 0x01;
+
-    LCW_bits[j + 2] = (LCW_bytes[i] >> 5) & 0x01;
+    //state->payload_mfid = ConvertBitIntoBytes(&mfid[0], 7);
-    LCW_bits[j + 3] = (LCW_bytes[i] >> 4) & 0x01;
+    lcinfohex = ConvertBitIntoBytes(&lcinfo[0], 55);
-    LCW_bits[j + 4] = (LCW_bytes[i] >> 3) & 0x01;
+    //fprintf (stderr, " LDU1 LCINFO %16llX \n", lcinfohex);
    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
+  processP25lcw (opts, state, lcformat, mfid, lcinfo);
  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);
  }
 }
--- a/src/p25p1_ldu2.c
+++ b/src/p25p1_ldu2.c
@@ -357,37 +357,37 @@ 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 (irrecoverable_errors == 0)
+  //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);
    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);
    //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) //print on payload == 1
  {
    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);
    state->payload_algid = algidhex;
    state->payload_keyid = kidhex;
    //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) //print on payload == 1
    {
      fprintf (stderr, "%s", KRED);
      fprintf (stderr, " ENC");
      fprintf (stderr, "%s", KNRM);
    }
    fprintf (stderr, "\n");
  }
-  else
+
  if (state->payload_algid != 0x80 && state->payload_algid != 0x0) //print on payload == 1
  {
-      fprintf (stderr, "%s", KRED);
+    fprintf (stderr, "%s", KRED);
-      fprintf (stderr, " LDU2 FEC ERR \n");
+    fprintf (stderr, " ENC \n");
-      fprintf (stderr, "%s", KNRM);
+    fprintf (stderr, "%s", KNRM);
  }
 }
--- a/src/p25p1_mdpu.c
+++ b/src/p25p1_mdpu.c
@@ -1,506 +0,0 @@
 /*-------------------------------------------------------------------------------
 * 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;
 						}	
 					}
 					//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_udp
 					else if (opts->audio_in_type == 3)
 					{
 						rtl_udp_tune (opts, state, freq1);
 						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq1;
 						opts->p25_is_tuned = 1;
            state->last_vc_sync_time = time(NULL);
 					}
    		}    
  		}
    }
    //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;
 						}	
 					}
 					//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_udp
 					else if (opts->audio_in_type == 3)
 					{
 						rtl_udp_tune (opts, state, freq1);
 						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq1;
 						opts->p25_is_tuned = 1;
            state->last_vc_sync_time = time(NULL);
 					}
    		}    
  		}
    }
    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"); 
 }
--- a/src/p25p1_tdu.c
+++ b/src/p25p1_tdu.c
@@ -33,8 +33,4 @@ 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
 }
--- a/src/p25p1_tdulc.c
+++ b/src/p25p1_tdulc.c
@@ -390,60 +390,11 @@ 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';
-
+  /*
-  int j;
+  if (state->carrier == 1) //only update when carrier is present, otherwise, garbage values may be collected
  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)
  {
-    LCW_bits[j + 0] = (LCW_bytes[i] >> 7) & 0x01;
+    state->payload_mfid = strtol (mfid, NULL, 2); //wonder if this is accurate info or not
    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
+  processP25lcw (opts, state, lcformat, mfid, lcinfo);
  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
 }
--- a/src/p25p1_tsbk.c
+++ b/src/p25p1_tsbk.c
@@ -7,40 +7,16 @@
 *-----------------------------------------------------------------------------*/
 #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
+  int tsbkbit[196] = {0}; //tsbk bit array, 196 trellis encoded bits
-  sprintf (state->call_string[0], "%s", "                     "); //21 spaces
+  int tsbk_dibit[98] = {0};
  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] = {0}; //12 byte return from bd_bridge (block_deinterleave)
-  uint8_t tsbk_byte[12]; //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)
-  memset (tsbk_byte, 0, sizeof(tsbk_byte));
+  int tsbk_decoded_bits[190] = {0}; //decoded bits from tsbk_bytes for sending to crc16_lb_bridge
  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
@@ -48,7 +24,11 @@ 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++)
@@ -69,19 +49,11 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
      if (i+(j*101) == skipdibit) 
      {
-        skipdibit += 36;
+        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 = bd_bridge(tsbkbit, tsbk_byte);
@@ -112,7 +84,7 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
      tsbk_byte[i] = byte;
    }
-    //convert tsbk_byte to vPDU and send to vPDU handler
+    //convert tsbk_byte to PDU and send to vPDU handler
    //...may or may not be entirely compatible,
    MFID   = tsbk_byte[1];
    PDU[0] = 0x07; //P25p1 TSBK Duid 0x07
@@ -134,10 +106,7 @@ 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) (mfid 90)
+    //0x49 is telephone grant, 0x46 Unit to Unit Channel Answer Request (seems bogus)
    // 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);
@@ -146,9 +115,9 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
    }
    //set our WACN and SYSID here now that we have valid ec and crc/checksum
-    else if (protectbit == 0 && err == 0 && ec == 0 && (tsbk_byte[0] & 0x3F) == 0x3B) 
+    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);
@@ -174,43 +143,16 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
      if (opts->payload == 1)
      {
        fprintf (stderr, "%s",KCYN);
-        fprintf (stderr, "\n P25 PDU Payload #%d ", j);
+        fprintf (stderr, "\n P25 PDU Payload ");
        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;
@@ -223,7 +165,5 @@ void processTSBK(dsd_opts * opts, dsd_state * state)
      j = 4; //set j to break the loop early
    }
  }
  fprintf (stderr, "%s ", KNRM);
  fprintf (stderr, "\n"); 
 }
--- a/src/p25p2_frame.c
+++ b/src/p25p2_frame.c
@@ -76,7 +76,7 @@ int vc_counter = 0;
 int framing_counter = 0;
 unsigned long long int isch = 0;
-int isch_decoded = -1;
+unsigned long long int isch_decoded = 0;
 int p2_duid[8] = {0};
 int16_t duid_decoded = 0;
@@ -369,7 +369,7 @@ void process_ISCH (dsd_opts * opts, dsd_state * state)
 	{
 		isch_decoded = isch_lookup(isch);
-		if (isch_decoded > -1)
+		if (isch_decoded > 0)
 		{
 			int uf_count = isch_decoded & 0x3;
 			int free = (isch_decoded >> 2) & 0x1;
@@ -411,7 +411,6 @@ void process_ISCH (dsd_opts * opts, dsd_state * state)
 	}
 	isch_decoded = -1; //reset to bad value after running
 }
@@ -475,6 +474,10 @@ 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;
 	processMbeFrame (opts, state, NULL, ambe_fr1, NULL);
 	processMbeFrame (opts, state, NULL, ambe_fr2, NULL);
 	processMbeFrame (opts, state, NULL, ambe_fr3, NULL);
@@ -626,6 +629,10 @@ 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;
 	processMbeFrame (opts, state, NULL, ambe_fr1, NULL);
 	processMbeFrame (opts, state, NULL, ambe_fr2, NULL);
@@ -686,41 +693,19 @@ void process_P2_DUID (dsd_opts * opts, dsd_state * state)
 		if (state->currentslot == 0 && duid_decoded != 3 && duid_decoded != 12)
 		{
 			fprintf (stderr, "VCH 0 ");
 			//open MBEout file - slot 1 - USE WITH CAUTION on Phase 2! Consider using a symbol capture bin instead!
 			if (duid_decoded == 0 || duid_decoded == 6) //4V or 2V (voice)
 			{
 				if ((opts->mbe_out_dir[0] != 0) && (opts->mbe_out_f == NULL)) openMbeOutFile (opts, state);
 			}
 		}
 		else if (state->currentslot == 1 && duid_decoded != 3 && duid_decoded != 12)
 		{
 			fprintf (stderr, "VCH 1 ");
 			//open MBEout file - slot 2 - USE WITH CAUTION on Phase 2! Consider using a symbol capture bin instead!
 			if (duid_decoded == 0 || duid_decoded == 6) //4V or 2V (voice)
 			{
      	if ((opts->mbe_out_dir[0] != 0) && (opts->mbe_out_fR == NULL)) openMbeOutFileR (opts, 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);
 			}
 		}
@@ -730,7 +715,6 @@ 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);
 			}
 		}
@@ -828,21 +812,22 @@ 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++) 
+	for (framing_counter = 0; framing_counter < 4; framing_counter++) //12
 	{
-		//run ISCH in here so we know when to start descramble offset
+		process_ISCH (opts, state); //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 = 1; 
+		state->currentslot = 0; 
 	}
-	else state->currentslot = 0; 
+	else state->currentslot = 1; 
 	//frame_scramble runs lfsr and creates an array of unscrambled bits to pull from
  process_Frame_Scramble (opts, state);
--- a/src/p25p2_vpdu.c
+++ b/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 <--I bet A4 here was triggering a phantom call when TSBK sent PDUs here
+		//MFID90 Voice Grants, A3, A4, and A5
 		//MFID90 Group Regroup Channel Grant - Implicit
 		if (MAC[1+len_a] == 0xA3 && MAC[2+len_a] == 0x90)
 		{
@@ -96,10 +96,6 @@ 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)
@@ -118,27 +114,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 && 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
+					//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[channel >> 12];
 					// 	if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
 					// 	{
 					// 		state->samplesPerSymbol = 8;
 					// 		state->symbolCenter = 3;
 					// 	}	
 					// }
 					//may be this way independent of whether or not this is QPSK (does C4FM run at 6000 sps?)
 					if (opts->mod_qpsk == 1)
 					{
-						if (state->p25_chan_tdma[channel >> 12] == 1)
+						int spacing = state->p25_chan_spac[channel >> 12];
 						if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
 						{
 							state->samplesPerSymbol = 8;
 							state->symbolCenter = 3;
 						}	
 					}
 					//rigctl
          if (opts->use_rigctl == 1)
 					{
@@ -146,7 +131,6 @@ 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
 					else if (opts->audio_in_type == 3)
@@ -154,7 +138,6 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 						rtl_udp_tune (opts, state, freq);
 						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq;
 						opts->p25_is_tuned = 1;
 						state->last_vc_sync_time = time(NULL);
 					}
    		}    
  		}
@@ -181,10 +164,6 @@ 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)
@@ -204,20 +183,10 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
    		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)
 					// {
 					// 	int spacing = state->p25_chan_spac[channel >> 12];
 					// 	if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
 					// 	{
 					// 		state->samplesPerSymbol = 8;
 					// 		state->symbolCenter = 3;
 					// 	}	
 					// }
 					//may be this way independent of whether or not this is QPSK (does C4FM run at 6000 sps?)
 					if (opts->mod_qpsk == 1)
 					{
-						if (state->p25_chan_tdma[channel >> 12] == 1)
+						int spacing = state->p25_chan_spac[channel >> 12];
 						if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
 						{
 							state->samplesPerSymbol = 8;
 							state->symbolCenter = 3;
@@ -230,7 +199,6 @@ 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
 					else if (opts->audio_in_type == 3)
@@ -238,7 +206,6 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 						rtl_udp_tune (opts, state, freq);
 						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq;
 						opts->p25_is_tuned = 1;
 						state->last_vc_sync_time = time(NULL);
 					}
    		}    
  		}
@@ -272,10 +239,6 @@ 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;
@@ -321,26 +284,15 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 					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) 
 						// {
 						// 	int spacing = state->p25_chan_spac[tunable_chan >> 12];
 						// 	if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
 						// 	{
 						// 		state->samplesPerSymbol = 8;
 						// 		state->symbolCenter = 3;
 						// 	}	
 						// }
 						//may be this way independent of whether or not this is QPSK (does C4FM run at 6000 sps?)
 						if (opts->mod_qpsk == 1) 
 						{
-							if (state->p25_chan_tdma[tunable_chan >> 12] == 1)
+							int spacing = state->p25_chan_spac[tunable_chan >> 12];
 							if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
 							{
 								state->samplesPerSymbol = 8;
 								state->symbolCenter = 3;
 							}	
 						}
 						//rigctl
 						if (opts->use_rigctl == 1)
 						{
@@ -349,7 +301,6 @@ 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
 						}
@@ -359,7 +310,6 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 							rtl_udp_tune (opts, state, 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
 						}
 					}    
@@ -389,27 +339,10 @@ 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");
+			fprintf (stderr, "\n Group Voice Channel Grant Update");
 			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)
@@ -422,9 +355,6 @@ 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))
  		{
@@ -432,26 +362,15 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
    		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)
 					// {
 					// 	int spacing = state->p25_chan_spac[channel >> 12];
 					// 	if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
 					// 	{
 					// 		state->samplesPerSymbol = 8;
 					// 		state->symbolCenter = 3;
 					// 	}	
 					// }
 					//may be this way independent of whether or not this is QPSK (does C4FM run at 6000 sps?)
 					if (opts->mod_qpsk == 1)
 					{
-						if (state->p25_chan_tdma[channel >> 12] == 1)
+						int spacing = state->p25_chan_spac[channel >> 12];
 						if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
 						{
 							state->samplesPerSymbol = 8;
 							state->symbolCenter = 3;
 						}	
 					}
 					//rigctl
          if (opts->use_rigctl == 1)
 					{
@@ -459,7 +378,6 @@ 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
 					else if (opts->audio_in_type == 3)
@@ -467,7 +385,6 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 						rtl_udp_tune (opts, state, freq);
 						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq;
 						opts->p25_is_tuned = 1;
 						state->last_vc_sync_time = time(NULL);
 					}
    		}    
  		}
@@ -486,7 +403,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) //double check these opcodes
+		if (MAC[1+len_a] == 0x44 || MAC[1+len_a] == 0x46)
 		{
 			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];
@@ -498,16 +415,9 @@ 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++)
      {
@@ -525,26 +435,15 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
    		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)
 					// {
 					// 	int spacing = state->p25_chan_spac[channel >> 12];
 					// 	if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
 					// 	{
 					// 		state->samplesPerSymbol = 8;
 					// 		state->symbolCenter = 3;
 					// 	}	
 					// }
 					//may be this way independent of whether or not this is QPSK (does C4FM run at 6000 sps?)
 					if (opts->mod_qpsk == 1)
 					{
-						if (state->p25_chan_tdma[channel >> 12] == 1)
+						int spacing = state->p25_chan_spac[channel >> 12];
 						if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
 						{
 							state->samplesPerSymbol = 8;
 							state->symbolCenter = 3;
 						}	
 					}
 					//rigctl
          if (opts->use_rigctl == 1)
 					{
@@ -552,7 +451,6 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
      			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 
 						state->last_vc_sync_time = time(NULL); 
 					}
 					//rtl_udp
 					else if (opts->audio_in_type == 3)
@@ -560,7 +458,6 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 						rtl_udp_tune (opts, state, 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);
 					}
    		}    
  		}
@@ -592,46 +489,17 @@ 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);
-			if (channelr1 != 0 && channelr1 != 0xFFFF) freq1r = process_channel_to_freq (opts, state, channelr1);
+			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);
-			if (channelr2 != 0 && channelr2 != 0xFFFF) freq1r = process_channel_to_freq (opts, state, channelr2);
+			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;
@@ -642,16 +510,6 @@ 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)
 				{
@@ -681,20 +539,10 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 					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)
 						// {
 						// 	int spacing = state->p25_chan_spac[tunable_chan >> 12];
 						// 	if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
 						// 	{
 						// 		state->samplesPerSymbol = 8;
 						// 		state->symbolCenter = 3;
 						// 	}	
 						// }
 						//may be this way independent of whether or not this is QPSK (does C4FM run at 6000 sps?)
 						if (opts->mod_qpsk == 1)
 						{
-							if (state->p25_chan_tdma[tunable_chan >> 12] == 1)
+							int spacing = state->p25_chan_spac[tunable_chan >> 12];
 							if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
 							{
 								state->samplesPerSymbol = 8;
 								state->symbolCenter = 3;
@@ -707,7 +555,6 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 							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 
 							state->last_vc_sync_time = time(NULL);
 							j = 8; //break loop
 						}
 						//rtl_udp
@@ -716,7 +563,6 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 							rtl_udp_tune (opts, state, 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
 						}
 					}    
@@ -735,7 +581,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)
+		if (MAC[1+len_a] == 0x05) //wonder if this is MAC_SIGNAL only? Too long for a TSBK
 		{
 			int so1 = MAC[2+len_a];
 			int channel1  = (MAC[3+len_a] << 8) | MAC[4+len_a];
@@ -752,54 +598,15 @@ 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;
@@ -808,20 +615,6 @@ 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)
 				{
@@ -858,26 +651,15 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 					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) 
 						// {
 						// 	int spacing = state->p25_chan_spac[tunable_chan >> 12];
 						// 	if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
 						// 	{
 						// 		state->samplesPerSymbol = 8;
 						// 		state->symbolCenter = 3;
 						// 	}	
 						// }
 						//may be this way independent of whether or not this is QPSK (does C4FM run at 6000 sps?)
 						if (opts->mod_qpsk == 1) 
 						{
-							if (state->p25_chan_tdma[tunable_chan >> 12] == 1)
+							int spacing = state->p25_chan_spac[tunable_chan >> 12];
 							if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
 							{
 								state->samplesPerSymbol = 8;
 								state->symbolCenter = 3;
 							}	
 						}
 						//rigctl
 						if (opts->use_rigctl == 1)
 						{
@@ -886,7 +668,6 @@ 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
@@ -896,7 +677,6 @@ 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;
 							state->last_vc_sync_time = time(NULL);
 							j = 8; //break loop
 						}
 					}    
@@ -930,16 +710,9 @@ 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;
@@ -980,26 +753,15 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 					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) 
 						// {
 						// 	int spacing = state->p25_chan_spac[tunable_chan >> 12];
 						// 	if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
 						// 	{
 						// 		state->samplesPerSymbol = 8;
 						// 		state->symbolCenter = 3;
 						// 	}	
 						// }
 						//may be this way independent of whether or not this is QPSK (does C4FM run at 6000 sps?)
 						if (opts->mod_qpsk == 1) 
 						{
-							if (state->p25_chan_tdma[tunable_chan >> 12] == 1)
+							int spacing = state->p25_chan_spac[tunable_chan >> 12];
 							if (spacing == 0x64) //tdma should always be 0x64, and fdma should always be 0x32
 							{
 								state->samplesPerSymbol = 8;
 								state->symbolCenter = 3;
 							}	
 						}
 						//rigctl
 						if (opts->use_rigctl == 1)
 						{
@@ -1008,7 +770,6 @@ 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
@@ -1018,7 +779,6 @@ 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;
 							state->last_vc_sync_time = time(NULL);
 							j = 8; //break loop
 						}
 					}    
@@ -1046,30 +806,15 @@ 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");
+			fprintf (stderr, "\n Group Voice Channel Grant Update - Explicit");
 			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);
-			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
+			freq2 = process_channel_to_freq (opts, state, channelr);
-
+			if (slot == 0)
-			//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;
-			// {
+			}
-			// 	state->lasttg = group;
+			else state->lasttgR = group;
 			// }
 			// else state->lasttgR = group;
 			for (int i = 0; i < state->group_tally; i++)
      {
@@ -1083,9 +828,6 @@ 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))
  		{
@@ -1093,26 +835,15 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
    		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;
 					// 	}	
 					// }
 					//may be this way independent of whether or not this is QPSK (does C4FM run at 6000 sps?)
 					if (opts->mod_qpsk == 1)
 					{
-						if (state->p25_chan_tdma[channelt >> 12] == 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;
 						}	
 					}
 					//rigctl
          if (opts->use_rigctl == 1)
 					{
@@ -1120,7 +851,6 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
      			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_udp
 					else if (opts->audio_in_type == 3)
@@ -1128,7 +858,6 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 						rtl_udp_tune (opts, state, freq1);
 						state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq1;
 						opts->p25_is_tuned = 1;
 						state->last_vc_sync_time = time(NULL);
 					}
    		}    
  		}
@@ -1186,9 +915,6 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			fprintf (stderr, "\n RFSS Status Broadcast - Implicit \n");
 			fprintf (stderr, "  LRA [%02X] SYSID [%03X] RFSS ID [%02X] SITE ID [%02X] CHAN [%04X] SSC [%02X] ", lra, lsysid, rfssid, siteid, channel, sysclass);
 			process_channel_to_freq (opts, state, channel);
 			state->p2_siteid = siteid;
 			state->p2_rfssid = rfssid;
 		}
 		//RFSS Status Broadcast - Explicit
@@ -1205,13 +931,10 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 			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;
 		}
 		//Unit-to-Unit Answer Request (UU_ANS_REQ)
-		if (MAC[1+len_a] == 0x45 && MAC[2+len_a] != 0x90)
+		if (MAC[1+len_a] == 0x45)
 		{
 			int svc     = MAC[2+len_a];
 			int answer  = MAC[3+len_a];
@@ -1223,17 +946,17 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 		}
-		//Telephone Interconnect Voice Channel Grant (TELE_INT_CH_GRANT) //look at PDU for this, see if this is tunable
+		//Telephone Interconnect Voice Channel Grant (TELE_INT_CH_GRANT)
-		// if (MAC[1+len_a] == 0x48 && MAC[2+len_a] != 0x90)
+		if (MAC[1+len_a] == 0x48)
-		// {
+		{
-		// 	fprintf (stderr, "\n Telephone Interconnect Voice Channel Grant ");	
+			fprintf (stderr, "\n Telephone Interconnect Voice Channel Grant ");	
-		// }
+		}
-		// //Telephone Interconnect Voice Channel Grant Update (TELE_INT_CH_GRANT_UPDT)
+		//Telephone Interconnect Voice Channel Grant Update (TELE_INT_CH_GRANT_UPDT)
-		// if (MAC[1+len_a] == 0x49 && MAC[2+len_a] != 0x90)
+		if (MAC[1+len_a] == 0x49)
-		// {
+		{
-		// 	fprintf (stderr, "\n Telephone Interconnect Voice Channel Grant Update ");	
+			fprintf (stderr, "\n Telephone Interconnect Voice Channel Grant Update ");	
-		// }
+		}
 		//Synchronization Broadcast (SYNC_BCST)
 		if (MAC[1+len_a] == 0x70)
@@ -1257,12 +980,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 > 59) seconds = 59; //sanity check for rounding error
+			if (seconds > 60) seconds = 60; //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 ");
 			}
@@ -1275,26 +998,13 @@ 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_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);
@@ -1307,7 +1017,6 @@ 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];
@@ -1323,7 +1032,6 @@ 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];
@@ -1339,7 +1047,6 @@ 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];
@@ -1366,15 +1073,12 @@ 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);
 			}
 			state->p2_siteid = siteid;
 			state->p2_rfssid = rfssid;
 		}
 		//Secondary Control Channel Broadcast, Implicit
@@ -1406,9 +1110,6 @@ void process_MAC_VPDU(dsd_opts * opts, dsd_state * state, int type, unsigned lon
 				state->lcn_freq_count = 3; //increment to three
      } 
 			state->p2_siteid = siteid;
 			state->p2_rfssid = rfssid; 
 		}
 		//MFID90 Group Regroup Voice Channel User - Abbreviated
@@ -1510,25 +1211,7 @@ 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)
 			{
@@ -1549,25 +1232,7 @@ 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)
 			{
@@ -1639,21 +1304,17 @@ 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];
-			fprintf (stderr, "\n Adjacent Status Broadcast - Abbreviated\n");
+			if (1 == 1) //state->p2_is_lcch == 1
-			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");
+				fprintf (stderr, "\n Adjacent Status Broadcast - Abbreviated\n");
-			if (cfva & 0x4) fprintf (stderr, " Failure Condition");
+				fprintf (stderr, "  LRA [%02X] RFSS[%03d] SYSID [%03X] SITE [%03X] CHAN-T [%04X] SSC [%02X]", lra, rfssid, lsysid, siteid, channelt, sysclass);
-			if (cfva & 0x2) fprintf (stderr, " Up to Date (Correct)");
+				process_channel_to_freq (opts, state, channelt);
-			else fprintf (stderr, " Last Known");
+			}
 			if (cfva & 0x1) fprintf (stderr, " Valid RFSS Connection Active");
 			process_channel_to_freq (opts, state, channelt);
 		}
@@ -1661,23 +1322,19 @@ 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[11+len_a];  //need to re-check this 
+			int sysclass = MAC[9+len_a];
-			fprintf (stderr, "\n Adjacent Status Broadcast - Extended\n");
+			if (1 == 1) //state->p2_is_lcch == 1
-			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");
+				fprintf (stderr, "\n Adjacent Status Broadcast - Extended\n");
-			if (cfva & 0x4) fprintf (stderr, " Failure Condition");
+				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);
-			if (cfva & 0x2) fprintf (stderr, " Up to Date (Correct)");
+				process_channel_to_freq (opts, state, channelt);
-			else fprintf (stderr, " Last Known");
+				process_channel_to_freq (opts, state, channelr);
-			if (cfva & 0x1) fprintf (stderr, " Valid RFSS Connection Active");
+			}
 			process_channel_to_freq (opts, state, channelt);
 			process_channel_to_freq (opts, state, channelr);
 		}
--- a/src/p25p2_xcch.c
+++ b/src/p25p2_xcch.c
@@ -13,9 +13,6 @@ 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;
@@ -205,13 +202,6 @@ void process_SACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[180]
 			//print it and then zero out
 			state->lastsrc = 0;
 			state->lasttg = 0;
 			//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)
 		{
@@ -228,9 +218,6 @@ void process_SACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[180]
 			//print it and then zero out
 			state->lastsrcR = 0;
 			state->lasttgR = 0;
 			//close any open MBEout files
 			if (opts->mbe_out_fR != NULL) closeMbeOutFileR (opts, state);
 		}
 		fprintf (stderr, "%s", KNRM);
 	}
@@ -242,9 +229,6 @@ 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)
 	{
@@ -257,18 +241,8 @@ void process_SACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[180]
 	}
 	if (opcode == 0x6 && err == 0)
 	{
-		if (state->currentslot == 1)
+		if (state->currentslot == 1) state->dmrburstL = 22;
-		{
+		else state->dmrburstR = 22;
 			state->dmrburstL = 21;
 			//close any open MBEout files
 			if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state);
 		} 
 		else
 		{
 			state->dmrburstR = 21;
 			//close any open MBEout files
 			if (opts->mbe_out_fR != NULL) closeMbeOutFileR (opts, state);
 		}
 		fprintf (stderr, " MAC_HANGTIME ");
 		fprintf (stderr, "%s", KYEL);
 		process_MAC_VPDU(opts, state, 1, SMAC);
@@ -288,9 +262,6 @@ 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;
@@ -441,13 +412,6 @@ void process_FACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[156]
 			//print it and then zero out
 			state->lastsrc = 0;
 			state->lasttg = 0;
 			//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)
 		{
@@ -464,9 +428,6 @@ void process_FACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[156]
 			//print it and then zero out
 			state->lastsrcR = 0;
 			state->lasttgR = 0;
 			//close any open MBEout files
 			if (opts->mbe_out_fR != NULL) closeMbeOutFileR (opts, state);
 		}
 		fprintf (stderr, "%s", KNRM);
 	}
@@ -498,9 +459,6 @@ 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)
 	{
@@ -513,18 +471,8 @@ void process_FACCH_MAC_PDU (dsd_opts * opts, dsd_state * state, int payload[156]
 	}
 	if (opcode == 0x6 && err == 0)
 	{
-		if (state->currentslot == 0)
+		if (state->currentslot == 0) state->dmrburstL = 22;
-		{
+		else state->dmrburstR = 22;
 			state->dmrburstL = 22;
 			//close any open MBEout files
 			if (opts->mbe_out_f != NULL) closeMbeOutFile (opts, state);
 		} 
 		else
 		{
 			state->dmrburstR = 22;
 			//close any open MBEout files
 			if (opts->mbe_out_fR != NULL) closeMbeOutFileR (opts, state);
 		} 
 		fprintf (stderr, " MAC_HANGTIME ");
 		fprintf (stderr, "%s", KYEL);
 		process_MAC_VPDU(opts, state, 0, FMAC);
--- a/src/provoice.c
+++ b/src/provoice.c
@@ -1,432 +1,582 @@
 #include "dsd.h"
 #include "provoice_const.h"
-// #define PVDEBUG
+void
-
+processProVoice (dsd_opts * opts, dsd_state * state)
 void processProVoice (dsd_opts * opts, dsd_state * state)
 {
-  int i, j, dibit;
+  int i, j, dibit, k;
  uint8_t lid[80];
  uint8_t lidbyte[10];
  uint8_t init[64];
  uint8_t initbyte[8];
  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: %lld Group: %d Source: %d LCN: %d ", 
+    fprintf (stderr, " Site [%02llX][%03lld] Group [%05d] Source [%08d] LCN[%02d] ", 
-              state->edacs_site_id, state->lasttg, state->lastsrc, state->edacs_tuned_lcn);
+              state->edacs_site_id, 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);
  }
-  //load all initial bits before voice into raw_bits array for analysis/handling
+  for (i = 0; i < 64; i++)
-  for (i = 0; i < 64+16+64; i++)
+    {
-    raw_bits[i] = getDibit (opts, state);
+      dibit = getDibit (opts, state);
-
+      init[i] = dibit;
-  //Note: the initial 144-bits seem to be provisioned differently depending on system type
+#ifdef PROVOICE_DUMP
-  initial = (unsigned long long int)ConvertBitIntoBytes(&raw_bits[0], 64);
+      fprintf (stderr,"%i", dibit);
-  lid = (uint16_t)ConvertBitIntoBytes(&raw_bits[64], 16);
+#endif
-  secondary = (unsigned long long int)ConvertBitIntoBytes(&raw_bits[80], 64);
+    }
 #ifdef PROVOICE_DUMP
  fprintf (stderr," ");
 #endif
  //init Bits (64)...MI?
  if (opts->payload == 1)
  {
-    fprintf (stderr, "\n N64: %016llX", initial);
+    k = 0;
-    fprintf (stderr, "\n LID: %04X", lid);
+    //fprintf (stderr, "\nInit 64 ");
-    fprintf (stderr, " %016llX", secondary);
+    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]);
    }
    //fprintf (stderr, "\n");
  }
  // 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]);
    }
    //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++)
+      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++)
    {
      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
-    w -= 6;
+  fprintf (stderr,"_");
-    x -= 6;
+#endif
    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);
+      dibit = getDibit (opts, state);
-    imbe7100_fr2[*w][*x] = dibit;
+#ifdef PROVOICE_DUMP
-    w++;
+      fprintf (stderr,"%i", dibit);
-    x++;
+#endif
-    raw_bits[j+288] = dibit;
+      imbe7100_fr2[*w][*x] = dibit;
-  }
+      w++;
      x++;
    }
 #ifdef PROVOICE_DUMP
  fprintf (stderr," ");
 #endif
  // spacer bits
  dibit = getDibit (opts, state);
-  spacer_bit[0] = dibit;
+#ifdef PROVOICE_DUMP
-  raw_bits[292] = dibit;
+  fprintf (stderr,"%i", dibit);
-
+#endif
  dibit = getDibit (opts, state);
-  spacer_bit[1] = dibit;
+#ifdef PROVOICE_DUMP
-  raw_bits[293] = dibit;
+  fprintf (stderr,"%i", dibit);
  fprintf (stderr," ");
 #endif
  // imbe frames 1,2 second half
  for (j = 0; j < 2; j++)
-  {
+    {
-    dibit = getDibit (opts, state);
+      dibit = getDibit (opts, state);
-    imbe7100_fr2[*w][*x] = dibit;
+#ifdef PROVOICE_DUMP
-    w++;
+      fprintf (stderr,"%i", dibit);
-    x++;
+#endif
-    raw_bits[j+294] = dibit;
+      imbe7100_fr2[*w][*x] = dibit;
-  }
+      w++;
      x++;
    }
 #ifdef PROVOICE_DUMP
  fprintf (stderr,"_");
 #endif
  for (i = 0; i < 3; i++)
-  {
+    {
-    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++;
        }
 #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++)
    {
      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;
    }
-    w -= 6;
+#ifdef PROVOICE_DUMP
-    x -= 6;
+  fprintf (stderr,"_");
-    for (j = 0; j < 6; j++)
+#endif
    {
      dibit = getDibit (opts, state);
      imbe7100_fr2[*w][*x] = dibit;
      w++;
      x++;
      raw_bits[302+j+(i*12)] = dibit;
    }
  }
  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);
+      dibit = getDibit (opts, state);
-    imbe7100_fr2[*w][*x] = dibit;
+#ifdef PROVOICE_DUMP
-    w++;
+      fprintf (stderr,"%i", dibit);
-    x++;
+#endif
-    raw_bits[j+343] = dibit;
+      imbe7100_fr2[*w][*x] = dibit;
-  }
+      w++;
      x++;
    }
 #ifdef PROVOICE_DUMP
  fprintf (stderr,"_");
 #endif
  for (i = 0; i < 7; i++)
-  {
+    {
-    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++;
        }
 #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++)
    {
      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
-    w -= 6;
+  fprintf (stderr,"_");
-    x -= 6;
+#endif
-    for (j = 0; j < 6; j++)
+  w -= 5;
  x -= 5;
  for (j = 0; j < 5; 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);
-  spacer_bit[2] = dibit;
+#ifdef PROVOICE_DUMP
-  raw_bits[448] = dibit;
+  fprintf (stderr,"%i", dibit);
-
+#endif
  dibit = getDibit (opts, state);
-  spacer_bit[3] = dibit; 
+#ifdef PROVOICE_DUMP
-  raw_bits[449] = dibit;
+  fprintf (stderr,"%i", dibit);
-
+  fprintf (stderr," ");
-  //resume raw_bits at +6 current value to round out payload bytes
+#endif
  //easier to visualize patterns
  for (i = 0; i < 16; i++)
-    raw_bits[i+450+6] = getDibit (opts, state); 
+    {
-
+      dibit = getDibit (opts, state); //HERE
-  bf = (uint16_t)ConvertBitIntoBytes(&raw_bits[456], 16);
+      init[i] = dibit; //recycle
-
+#ifdef PROVOICE_DUMP
-  if (opts->payload == 1)
+      fprintf (stderr,"%i", dibit);
-    fprintf (stderr, "\n BF: %04X ", bf);
+#endif
-
+    }
 #ifdef PROVOICE_DUMP
  fprintf (stderr," ");
 #endif
 if (opts->payload == 1)
 {
  k = 0;
  //fprintf (stderr, "16 bits? ");
  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");
 }
  // imbe frames 3,4 first half
  w = pW;
  x = pX;
  for (i = 0; i < 11; i++)
-  {
+    {
-    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++;
        }
 #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++)
    {
      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
-    w -= 6;
+  fprintf (stderr,"_");
-    x -= 6;
+#endif
    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);
+      dibit = getDibit (opts, state);
-    imbe7100_fr2[*w][*x] = dibit;
+#ifdef PROVOICE_DUMP
-    w++;
+      fprintf (stderr,"%i", dibit);
-    x++;
+#endif
-    raw_bits[i+610+6] = dibit; 
+      imbe7100_fr2[*w][*x] = dibit;
-  }
+      w++;
      x++;
    }
 #ifdef PROVOICE_DUMP
  fprintf (stderr," ");
 #endif
  // spacer bits
  dibit = getDibit (opts, state);
-  spacer_bit[4];
+#ifdef PROVOICE_DUMP
-  raw_bits[614+2] = dibit;
+  //fprintf (stderr,"%i", dibit);
-
+#endif
  dibit = getDibit (opts, state);
-  spacer_bit[5];
+#ifdef PROVOICE_DUMP
-  raw_bits[615+2] = dibit;
+  //fprintf (stderr,"%i", dibit);
  //fprintf (stderr,"_");
 #endif
  // imbe frames 3,4 second half
  for (j = 0; j < 2; j++)
  {
    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);
      imbe7100_fr1[*w][*x] = dibit;
      w++;
      x++;
      raw_bits[6+618+j+(i*12)] = dibit;
    }
    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 (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++)
-  {
+    {
-    dibit = getDibit (opts, state);
+      dibit = getDibit (opts, state);
-    imbe7100_fr1[*w][*x] = dibit;
+#ifdef PROVOICE_DUMP
-    w++;
+      //fprintf (stderr,"%i", dibit);
-    x++;
+#endif
-    raw_bits[j+660+6] = dibit;
+      imbe7100_fr1[*w][*x] = dibit;
-  }
+      w++;
      x++;
    }
 #ifdef PROVOICE_DUMP
  //fprintf (stderr,"_");
 #endif
  w -= 5;
  x -= 5;
  for (j = 0; j < 5; j++)
-  {
+    {
-    dibit = getDibit (opts, state);
+      dibit = getDibit (opts, state);
-    imbe7100_fr2[*w][*x] = dibit;
+#ifdef PROVOICE_DUMP
-    w++;
+      //fprintf (stderr,"%i", dibit);
-    x++;
+#endif
-    raw_bits[j+665+6] = dibit;
+      imbe7100_fr2[*w][*x] = dibit;
-  }
+      w++;
      x++;
    }
 #ifdef PROVOICE_DUMP
  //fprintf (stderr," ");
 #endif
  for (i = 0; i < 7; i++)
-  {
+    {
-    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++;
        }
 #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++)
    {
      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;
    }
-    w -= 6;
+#ifdef PROVOICE_DUMP
-    x -= 6;
+  //fprintf (stderr,"_");
-    for (j = 0; j < 6; j++)
+#endif
    {
      dibit = getDibit (opts, state);
      imbe7100_fr2[*w][*x] = dibit;
      w++;
      x++;
      raw_bits[6+676+j+(i*12)] = dibit;
    }
  }
  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);
+      dibit = getDibit (opts, state);
-    imbe7100_fr2[*w][*x] = dibit;
+#ifdef PROVOICE_DUMP
-    w++;
+      //fprintf (stderr,"%i", dibit);
-    x++;
+#endif
-    raw_bits[j+765+6] = dibit;
+      imbe7100_fr2[*w][*x] = dibit;
-  }
+      w++;
      x++;
    }
 #ifdef PROVOICE_DUMP
  //fprintf (stderr," ");
 #endif
  processMbeFrame (opts, state, NULL, NULL, imbe7100_fr1);
  processMbeFrame (opts, state, NULL, NULL, imbe7100_fr2);
  // spacer bits
  dibit = getDibit (opts, state);
-  spacer_bit[6] = dibit;
+#ifdef PROVOICE_DUMP
-  raw_bits[782] = dibit;
+  //fprintf (stderr,"%i", dibit);
-
+#endif
  dibit = getDibit (opts, state);
-  spacer_bit[7] = dibit;
+#ifdef PROVOICE_DUMP
-  raw_bits[783] = dibit;
+  //fprintf (stderr,"%i", dibit);
-
+  //fprintf (stderr," ");
 #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
-  //line break at end of frame
+  if (opts->errorbars == 1)
-  fprintf (stderr,"\n");
+    {
-
+      fprintf (stderr,"\n");
    }
 }
--- a/src/x2tdma_voice.c
+++ b/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)
        {
--- a/tone24.wav
+++ b/tone24.wav
--- a/tone48.wav
+++ b/tone48.wav
--- a/tone8.wav
+++ b/tone8.wav
--- a/virtualsink.sh
+++ b/virtualsink.sh
@@ -1,4 +0,0 @@
 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
Author	SHA1	Message	Date
lwvmobile	b722e43a3a	dPMR Scrambler Key Support;	2023-01-07 18:41:44 -05:00
lwvmobile	2ba9953d33	'Lite' Optimizations and Tweaks for Win32CYG Build	2023-01-05 18:38:12 -05:00
		`@@ -1,4 +0,0 @@`
			`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`