Improved IMBE decoder for p25p2 (#1044)

* Implement fixed-point IMBE decoder for p25p2 with "softVocoder" config option

* Implement softVocoder option for DMR

* Update docs to specify softVocoder applies to P25 and DMR

* Software decoder outputs samples directly to PCM buffer

Author: staticinvocation

docs/CONFIGURE.md

@@ -148,7 +148,7 @@ There is a list of available Plugins [here](./Plugins.md).
 | debugRecorderAddress         |          | "127.0.0.1"                                      | string                                                       | The network address of the computer that will be monitoring the Debug Recorders. UDP packets will be sent from Trunk Recorder to this computer. The default is *"127.0.0.1"* which is the address used for monitoring on the same computer as Trunk Recorder. |
 | audioStreaming               |          | false                                            | **true** / **false**                                         | Whether or not to enable the audio streaming callbacks for plugins. |
 | newCallFromUpdate            |          | true                                             | **true** / **false**                                         | Allow for UPDATE trunking messages to start a new Call, in addition to GRANT messages. This may result in more Calls with no transmisions, and use more Recorders. The flipside is that it may catch parts of a Call that would have otherwise been missed. Turn this off if you are running out of Recorders. |
-| softVocoder                  |          | false                                            | **true** / **false**                                         | Use the Software Decode vocoder from OP25 for Phase 1 audio. Give it a try if you are hearing weird tones in your audio. Whether it makes your audio sound better or worse is a matter of preference. |
+| softVocoder                  |          | false                                            | **true** / **false**                                         | Use the Software Decode vocoder from OP25 for P25 and DMR. Give it a try if you are hearing weird tones in your audio. Whether it makes your audio sound better or worse is a matter of preference. |
 | recordUUVCalls               |          | true                                             | **true** / **false**                                         | *P25 only* Record Unit to Unit Voice calls.        |
 
 

lib/op25_repeater/include/op25_repeater/frame_assembler.h

@@ -50,7 +50,7 @@ namespace gr {
                  * class. op25_repeater::frame_assembler::make is the public interface for
                  * creating new instances.
                  */
-                static sptr make(const char* options, int debug, int msgq_id, gr::msg_queue::sptr queue);
+                static sptr make(const char* options, int debug, int msgq_id, gr::msg_queue::sptr queue, bool d_soft_vocoder);
                 virtual void set_xormask(const char*p) {}
                 virtual void set_nac(int nac) {}
                 virtual void set_slotid(int slotid) {}

lib/op25_repeater/lib/frame_assembler_impl.cc

@@ -86,10 +86,10 @@ namespace gr {
         }
 
         frame_assembler::sptr
-            frame_assembler::make(const char* options, int debug, int msgq_id, gr::msg_queue::sptr queue)
+            frame_assembler::make(const char* options, int debug, int msgq_id, gr::msg_queue::sptr queue, bool d_soft_vocoder)
             {
                 return gnuradio::get_initial_sptr
-                    (new frame_assembler_impl(options, debug, msgq_id, queue));
+                    (new frame_assembler_impl(options, debug, msgq_id, queue, d_soft_vocoder));
             }
 
         /*
@@ -107,7 +107,7 @@ namespace gr {
         /*
          * The private constructor
          */
-        frame_assembler_impl::frame_assembler_impl(const char* options, int debug, int msgq_id, gr::msg_queue::sptr queue)
+        frame_assembler_impl::frame_assembler_impl(const char* options, int debug, int msgq_id, gr::msg_queue::sptr queue, bool d_soft_vocoder)
             : gr::block("frame_assembler",
                     gr::io_signature::make (MIN_IN, MAX_IN, sizeof (char)),
 	                gr::io_signature::make ( 2, 2, sizeof(int16_t))),
@@ -122,7 +122,7 @@ namespace gr {
             else if (strcasecmp(options, "subchannel") == 0)
                 d_sync = new rx_subchannel(options, logts, debug, msgq_id, queue);
             else
-                d_sync = new rx_sync(options, logts, debug, msgq_id, queue, output_queue);
+                d_sync = new rx_sync(options, logts, debug, msgq_id, queue, output_queue, d_soft_vocoder);
         }
 
         int 

lib/op25_repeater/lib/frame_assembler_impl.h

@@ -63,7 +63,7 @@ namespace gr {
                 log_ts logts;
 
             public:
-                frame_assembler_impl(const char* options, int debug, int msgq_id, gr::msg_queue::sptr queue);
+                frame_assembler_impl(const char* options, int debug, int msgq_id, gr::msg_queue::sptr queue, bool d_soft_vocoder);
                 ~frame_assembler_impl();
 
                 // Where all the action really happens

lib/op25_repeater/lib/imbe_decoder.cc

@@ -4,13 +4,7 @@ imbe_decoder::~imbe_decoder()
 {
 }
 
-imbe_decoder::imbe_decoder() :
-   d_audio()
+imbe_decoder::imbe_decoder() 
 {
 }
 
-audio_samples*
-imbe_decoder::audio()
-{
-   return &d_audio;
-}

lib/op25_repeater/lib/imbe_decoder.h

@@ -26,10 +26,8 @@
 
 #include <boost/noncopyable.hpp>
 #include <boost/shared_ptr.hpp>
-#include <deque>
 #include <vector>
 
-typedef std::deque<float> audio_samples;
 typedef std::vector<bool> voice_codeword;
 
 
@@ -39,6 +37,7 @@ typedef std::vector<bool> voice_codeword;
    typedef std::shared_ptr<class imbe_decoder> imbe_decoder_sptr;
 	#endif
 
+#define IMBE_SAMPLES_PER_FRAME 160 
 /**
  * imbe_decoder is the interface to the various mechanisms for
  * translating P25 voice codewords into audio samples.
@@ -64,15 +63,7 @@ class imbe_decoder : public boost::noncopyable {
     *
     * \param cw IMBE codeword (including parity check bits).
     */
-   virtual void decode(const voice_codeword& cw) = 0;
-
-   /**
-    * Returns the audio_samples samples. These are mono samples at
-    * 8KS/s represented as a float in the range -1.0 .. +1.0.
-    *
-    * \return A non-null pointer to a deque<float> of audio samples.
-    */
-   audio_samples *audio();
+   virtual void decode(int16_t samples[IMBE_SAMPLES_PER_FRAME], const voice_codeword& cw) = 0;
 
 protected:
 
@@ -81,15 +72,7 @@ class imbe_decoder : public boost::noncopyable {
     * because this is an abstract class and users should call
     * make_imbe_decoder to construct  concrete instances.
     */
-   imbe_decoder();
-
-private:
-
-   /**
-    * The audio samples produced by the IMBE decoder.
-    */
-   audio_samples d_audio;
-   
+   imbe_decoder();   
 };
 
 #endif /* INCLUDED_IMBE_DECODER_H */

lib/op25_repeater/lib/imbe_vocoder/decode.cc

@@ -33,7 +33,9 @@
 #include "dsp_sub.h"
 #include "imbe_vocoder.h"
 
+
 #include <string.h>
+#include <math.h>
 
 
 
@@ -67,3 +69,61 @@ void imbe_vocoder::decode(IMBE_PARAM *imbe_param, Word16 *frame_vector, Word16 *
 	for(j = 0; j < FRAME; j++)
 		snd[j] = add(snd[j], snd_tmp[j]);
 }
+
+
+void imbe_vocoder::decode_tap(Word16 *snd, int L, float w0, const int *Vl, const float *Ml)
+{
+	Word16 snd_v[FRAME];
+    Word16 snd_uv[FRAME];
+    int i;
+
+	//
+	// Convert floating-point parameters into fixed-point IMBE_PARAM struct
+	//
+
+	// Number of Harmonics (L) -> num_harms
+	my_imbe_param.num_harms = L;
+
+	// Fundamental Frequency (w0) -> fund_freq
+	// w0 is float angular frequency, convert to frequency
+	float fund_freq_f = w0 / M_PI;
+	// Convert fundamental frequency to fixed-point Q1.31 format
+	my_imbe_param.fund_freq = (Word32)(fund_freq_f * (UWord32)(1LL << 31));
+
+	// Zero out harmonic vectors so only used harmonics have values
+	memset(my_imbe_param.v_uv_dsn, 0, sizeof(my_imbe_param.v_uv_dsn));
+	memset(my_imbe_param.sa, 0, sizeof(my_imbe_param.sa));
+
+	// Voicing Vector (Vl) -> v_uv_dsn
+    for (i = 0; i < L; i++) {
+        my_imbe_param.v_uv_dsn[i] = (Word16)Vl[i];
+    }
+
+	// Spectral Amplitudes (Ml) -> sa
+    for (int i = 0; i < L; i++) {
+        my_imbe_param.sa[i] = (Word16)Ml[i];
+    }
+
+	//
+	// Pre-calculate values needed by synthesis that is typically done during sa decode
+	//
+	
+	my_imbe_param.div_one_by_num_harm_sh = norm_s(my_imbe_param.num_harms);
+	my_imbe_param.div_one_by_num_harm = div_s(0x4000, my_imbe_param.num_harms << my_imbe_param.div_one_by_num_harm_sh);
+    my_imbe_param.l_uv = 0;
+    for (i = 0; i < my_imbe_param.num_harms; i++) {
+        if (my_imbe_param.v_uv_dsn[i] == 0)
+			my_imbe_param.l_uv++;
+    }
+
+	//
+	// Perform fixed-point synthesis
+	//
+
+    sa_enh(&my_imbe_param);
+    v_synt(&my_imbe_param, snd_v);
+    uv_synt(&my_imbe_param, snd_uv);
+
+    for(i = 0; i < FRAME; i++)
+		snd[i] = add(snd_v[i], snd_uv[i]);
+}

lib/op25_repeater/lib/imbe_vocoder/imbe_vocoder.h

@@ -36,6 +36,8 @@ class imbe_vocoder
 	// hack to enable ambe encoder read access to speech parameters
 	const IMBE_PARAM* param(void) {return &my_imbe_param;}
 	void set_gain_adjust(float gain_adjust) {d_gain_adjust = gain_adjust;}
+	// decodes IMBE codec parameters in float format into 160 audio samples (snd)	
+	void decode_tap(Word16 *snd, int L, float w0, const int *Vl, const float *Ml);
 private:
 	IMBE_PARAM my_imbe_param;
 

lib/op25_repeater/lib/p25_frame_assembler_impl.cc

@@ -104,7 +104,7 @@ static const int MAX_IN = 1;	// maximum number of input streams
   p1fdma(op25audio, logts, debug, do_imbe, do_output, do_msgq, queue, output_queue, do_audio_output, soft_vocoder),
 	d_do_audio_output(do_audio_output),
 	d_do_phase2_tdma(do_phase2_tdma),
-	p2tdma(op25audio, logts,  0, debug, do_msgq, queue, output_queue, do_audio_output),
+	p2tdma(op25audio, logts,  0, debug, do_msgq, queue, output_queue, do_audio_output, soft_vocoder),
 	d_do_msgq(do_msgq),
 	d_msg_queue(queue),
 	output_queue(),

lib/op25_repeater/lib/p25p1_fdma.cc

@@ -728,16 +728,7 @@ namespace gr {
 
                             if (d_soft_vocoder) {
                                 // This is vocoder that is for half-rate
-                                software_decoder.decode_fullrate(u[0], u[1], u[2], u[3], u[4], u[5], u[6], u[7], E0, ET);
-                                audio_samples *samples = software_decoder.audio();
-                                for (int i=0; i < SND_FRAME; i++) {
-                                    if (samples->size() > 0) {
-                                        snd[i] = (int16_t)(samples->front());
-                                        samples->pop_front();
-                                    } else {
-                                        snd[i] = 0;
-                                    }
-                                }
+                                software_decoder.decode_fullrate(snd, u[0], u[1], u[2], u[3], u[4], u[5], u[6], u[7], E0, ET);
                             } else {
 
                                 // This is the older, fullrate vocoder