From b86e88413d4c6ec428aaedb147f7675f28882fe4 Mon Sep 17 00:00:00 2001
From: drowe67 <david@rowetel.com>
Date: Fri, 14 Jul 2023 12:36:50 +0930
Subject: clang-format -i applied to src unittest misc

---
 src/interldpc.c | 467 +++++++++++++++++++++++++++++---------------------------
 1 file changed, 244 insertions(+), 223 deletions(-)

(limited to 'src/interldpc.c')

diff --git a/src/interldpc.c b/src/interldpc.c
index b17e9b7..e498807 100644
--- a/src/interldpc.c
+++ b/src/interldpc.c
@@ -25,293 +25,314 @@
   along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "interldpc.h"
+
 #include <assert.h>
+#include <math.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stdint.h>
 #include <string.h>
-#include <math.h>
 
-#include "interldpc.h"
-#include "ofdm_internal.h"
-#include "mpdecode_core.h"
 #include "gp_interleaver.h"
+#include "mpdecode_core.h"
+#include "ofdm_internal.h"
 
 void freedv_pack(unsigned char *bytes, unsigned char *bits, int nbits);
 void freedv_unpack(unsigned char *bits, unsigned char *bytes, int nbits);
 unsigned short freedv_crc16_unpacked(unsigned char *bits, int nbits);
 
-void set_up_ldpc_constants(struct LDPC *ldpc, int code_length, int parity_bits) {
-    /* following provided for convenience and to match Octave variable names */
+void set_up_ldpc_constants(struct LDPC *ldpc, int code_length,
+                           int parity_bits) {
+  /* following provided for convenience and to match Octave variable names */
 
-    /* these remain fixed */
-    ldpc->ldpc_data_bits_per_frame = code_length - parity_bits;
-    ldpc->ldpc_coded_bits_per_frame = code_length;
+  /* these remain fixed */
+  ldpc->ldpc_data_bits_per_frame = code_length - parity_bits;
+  ldpc->ldpc_coded_bits_per_frame = code_length;
 
-    /* in the case there are some unused data bits, these may be
-       modified to be less that ldpc->ldpc_xxx versions above. We
-       place known bits in the unused data bit positions, which make
-       the code stronger, and allow us to mess with different speech
-       codec bit allocations without designing new LDPC codes. */
+  /* in the case there are some unused data bits, these may be
+     modified to be less that ldpc->ldpc_xxx versions above. We
+     place known bits in the unused data bit positions, which make
+     the code stronger, and allow us to mess with different speech
+     codec bit allocations without designing new LDPC codes. */
 
-    ldpc->data_bits_per_frame = ldpc->ldpc_data_bits_per_frame;
-    ldpc->coded_bits_per_frame = ldpc->ldpc_coded_bits_per_frame;
-    ldpc->protection_mode = LDPC_PROT_2020;
+  ldpc->data_bits_per_frame = ldpc->ldpc_data_bits_per_frame;
+  ldpc->coded_bits_per_frame = ldpc->ldpc_coded_bits_per_frame;
+  ldpc->protection_mode = LDPC_PROT_2020;
 }
 
 void set_data_bits_per_frame(struct LDPC *ldpc, int new_data_bits_per_frame) {
-    ldpc->data_bits_per_frame = new_data_bits_per_frame;
-    ldpc->coded_bits_per_frame = ldpc->data_bits_per_frame + ldpc->NumberParityBits;
+  ldpc->data_bits_per_frame = new_data_bits_per_frame;
+  ldpc->coded_bits_per_frame =
+      ldpc->data_bits_per_frame + ldpc->NumberParityBits;
 }
 
-/* 1' stuffing (code rate reduction) - tweak LDPC code setup for selected modes */
+/* 1' stuffing (code rate reduction) - tweak LDPC code setup for selected modes
+ */
 void ldpc_mode_specific_setup(struct OFDM *ofdm, struct LDPC *ldpc) {
-    /* mode specific set up */
-    if (!strcmp(ofdm->mode,"2020")) set_data_bits_per_frame(ldpc, 312);
-    if (!strcmp(ofdm->mode,"2020B")) {
-        set_data_bits_per_frame(ldpc, 156);
-        ldpc->protection_mode = LDPC_PROT_2020B;
-    }
-    if (!strcmp(ofdm->mode,"2020C")) set_data_bits_per_frame(ldpc, 156);
-    if (!strcmp(ofdm->mode,"datac4")) set_data_bits_per_frame(ldpc, 448);
-    if (!strcmp(ofdm->mode,"datac13")) set_data_bits_per_frame(ldpc, 128);
+  /* mode specific set up */
+  if (!strcmp(ofdm->mode, "2020")) set_data_bits_per_frame(ldpc, 312);
+  if (!strcmp(ofdm->mode, "2020B")) {
+    set_data_bits_per_frame(ldpc, 156);
+    ldpc->protection_mode = LDPC_PROT_2020B;
+  }
+  if (!strcmp(ofdm->mode, "2020C")) set_data_bits_per_frame(ldpc, 156);
+  if (!strcmp(ofdm->mode, "datac4")) set_data_bits_per_frame(ldpc, 448);
+  if (!strcmp(ofdm->mode, "datac13")) set_data_bits_per_frame(ldpc, 128);
 }
 
-/* LDPC encode frame - generate parity bits and a codeword, applying the selected
-   FEC protection scheme */ 
-void ldpc_encode_frame(struct LDPC *ldpc, int codeword[], unsigned char tx_bits_char[]) {
-    unsigned char pbits[ldpc->NumberParityBits];
-    int codec_frame;
-    int i, j;
+/* LDPC encode frame - generate parity bits and a codeword, applying the
+   selected FEC protection scheme */
+void ldpc_encode_frame(struct LDPC *ldpc, int codeword[],
+                       unsigned char tx_bits_char[]) {
+  unsigned char pbits[ldpc->NumberParityBits];
+  int codec_frame;
+  int i, j;
 
-    unsigned char tx_bits_char_padded[ldpc->ldpc_data_bits_per_frame];
+  unsigned char tx_bits_char_padded[ldpc->ldpc_data_bits_per_frame];
 
-    switch (ldpc->protection_mode) {
+  switch (ldpc->protection_mode) {
     case LDPC_PROT_EQUAL:
-        assert(ldpc->data_bits_per_frame == ldpc->ldpc_data_bits_per_frame);
-        /* we have enough data bits to fill the codeword */
-        encode(ldpc, tx_bits_char, pbits);
-        break;
-        
+      assert(ldpc->data_bits_per_frame == ldpc->ldpc_data_bits_per_frame);
+      /* we have enough data bits to fill the codeword */
+      encode(ldpc, tx_bits_char, pbits);
+      break;
+
     case LDPC_PROT_2020:
-        /* not all data bits in codeword used, so set them to known values */
-        memcpy(tx_bits_char_padded, tx_bits_char, ldpc->data_bits_per_frame);
-        for (i = ldpc->data_bits_per_frame; i < ldpc->ldpc_data_bits_per_frame; i++)
-            tx_bits_char_padded[i] = 1;
-        encode(ldpc, tx_bits_char_padded, pbits);
-        break;
-        
+      /* not all data bits in codeword used, so set them to known values */
+      memcpy(tx_bits_char_padded, tx_bits_char, ldpc->data_bits_per_frame);
+      for (i = ldpc->data_bits_per_frame; i < ldpc->ldpc_data_bits_per_frame;
+           i++)
+        tx_bits_char_padded[i] = 1;
+      encode(ldpc, tx_bits_char_padded, pbits);
+      break;
+
     case LDPC_PROT_2020B:
-        /* We only want to protect the stage 1 VQ data bits, 0..10 in
-           each 52 bit codec frame. There are 3 codec frames 3x52=156
-           bits, and 56 parity bits.  We only use 11*3 = 33 bits of
-           the LDPC codeword data bits, the rest are set to known
-           values.
-         */
-        for(j=0,codec_frame=0; codec_frame<3; codec_frame++) 
-            for(i=0; i<11; i++,j++)
-                tx_bits_char_padded[j] = tx_bits_char[codec_frame*52+i];
-        assert(j == 33);
-        for (i = 33; i < ldpc->ldpc_data_bits_per_frame; i++)
-            tx_bits_char_padded[i] = 1;
-        encode(ldpc, tx_bits_char_padded, pbits);
- 
-        break;
+      /* We only want to protect the stage 1 VQ data bits, 0..10 in
+         each 52 bit codec frame. There are 3 codec frames 3x52=156
+         bits, and 56 parity bits.  We only use 11*3 = 33 bits of
+         the LDPC codeword data bits, the rest are set to known
+         values.
+       */
+      for (j = 0, codec_frame = 0; codec_frame < 3; codec_frame++)
+        for (i = 0; i < 11; i++, j++)
+          tx_bits_char_padded[j] = tx_bits_char[codec_frame * 52 + i];
+      assert(j == 33);
+      for (i = 33; i < ldpc->ldpc_data_bits_per_frame; i++)
+        tx_bits_char_padded[i] = 1;
+      encode(ldpc, tx_bits_char_padded, pbits);
+
+      break;
 
     default:
-        assert(0);            
-    }
+      assert(0);
+  }
 
-    /* output codeword is concatenation of (used) data bits and parity
-       bits, we don't bother sending unused (known) data bits */
-    for (i = 0; i < ldpc->data_bits_per_frame; i++) codeword[i] = tx_bits_char[i];
-    for (j = 0; j < ldpc->NumberParityBits; i++, j++) codeword[i] = pbits[j];
+  /* output codeword is concatenation of (used) data bits and parity
+     bits, we don't bother sending unused (known) data bits */
+  for (i = 0; i < ldpc->data_bits_per_frame; i++) codeword[i] = tx_bits_char[i];
+  for (j = 0; j < ldpc->NumberParityBits; i++, j++) codeword[i] = pbits[j];
 }
 
 void qpsk_modulate_frame(COMP tx_symbols[], int codeword[], int n) {
-    int s, i;
-    int dibit[2];
-    complex float qpsk_symb;
-
-    for (s = 0, i = 0; i < n; s += 2, i++) {
-        dibit[0] = codeword[s + 1] & 0x1;
-        dibit[1] = codeword[s] & 0x1;
-        qpsk_symb = qpsk_mod(dibit);
-        tx_symbols[i].real = crealf(qpsk_symb);
-        tx_symbols[i].imag = cimagf(qpsk_symb);
-    }
+  int s, i;
+  int dibit[2];
+  complex float qpsk_symb;
+
+  for (s = 0, i = 0; i < n; s += 2, i++) {
+    dibit[0] = codeword[s + 1] & 0x1;
+    dibit[1] = codeword[s] & 0x1;
+    qpsk_symb = qpsk_mod(dibit);
+    tx_symbols[i].real = crealf(qpsk_symb);
+    tx_symbols[i].imag = cimagf(qpsk_symb);
+  }
 }
 
 /* run LDPC decoder, taking into account the FEC protection scheme */
-void ldpc_decode_frame(struct LDPC *ldpc, int *parityCheckCount, int *iter, uint8_t out_char[], float llr[]) {
-    float llr_full_codeword[ldpc->ldpc_coded_bits_per_frame];
-    int unused_data_bits = ldpc->ldpc_data_bits_per_frame - ldpc->data_bits_per_frame;
-    uint8_t out_char_ldpc[ldpc->coded_bits_per_frame];
-    int i,j;
-    int codec_frame;
-    
-    switch (ldpc->protection_mode) {
+void ldpc_decode_frame(struct LDPC *ldpc, int *parityCheckCount, int *iter,
+                       uint8_t out_char[], float llr[]) {
+  float llr_full_codeword[ldpc->ldpc_coded_bits_per_frame];
+  int unused_data_bits =
+      ldpc->ldpc_data_bits_per_frame - ldpc->data_bits_per_frame;
+  uint8_t out_char_ldpc[ldpc->coded_bits_per_frame];
+  int i, j;
+  int codec_frame;
+
+  switch (ldpc->protection_mode) {
     case LDPC_PROT_EQUAL:
-        /* Equal protection all data bits in codeword
-           (e.g. 700D/700E), works well with rate 0.5 codes */
-        assert(ldpc->data_bits_per_frame == ldpc->ldpc_data_bits_per_frame);
-        *iter = run_ldpc_decoder(ldpc, out_char, llr, parityCheckCount);
-        break;
+      /* Equal protection all data bits in codeword
+         (e.g. 700D/700E), works well with rate 0.5 codes */
+      assert(ldpc->data_bits_per_frame == ldpc->ldpc_data_bits_per_frame);
+      *iter = run_ldpc_decoder(ldpc, out_char, llr, parityCheckCount);
+      break;
     case LDPC_PROT_2020:
-        /* some data bits in codeword unused, effectively
-           decreasing code rate and making FEC more powerful
-           (without having to design a new code) */
-        for (i = 0; i < ldpc->data_bits_per_frame; i++)
-            llr_full_codeword[i] = llr[i];
-        // known bits ... so really likely
-        for (i = ldpc->data_bits_per_frame; i < ldpc->ldpc_data_bits_per_frame; i++)
-            llr_full_codeword[i] = -100.0f;
-        // parity bits at end
-        for (i = ldpc->ldpc_data_bits_per_frame; i < ldpc->ldpc_coded_bits_per_frame; i++)
-            llr_full_codeword[i] = llr[i - unused_data_bits];
-        *iter = run_ldpc_decoder(ldpc, out_char, llr_full_codeword, parityCheckCount);
-        break;
+      /* some data bits in codeword unused, effectively
+         decreasing code rate and making FEC more powerful
+         (without having to design a new code) */
+      for (i = 0; i < ldpc->data_bits_per_frame; i++)
+        llr_full_codeword[i] = llr[i];
+      // known bits ... so really likely
+      for (i = ldpc->data_bits_per_frame; i < ldpc->ldpc_data_bits_per_frame;
+           i++)
+        llr_full_codeword[i] = -100.0f;
+      // parity bits at end
+      for (i = ldpc->ldpc_data_bits_per_frame;
+           i < ldpc->ldpc_coded_bits_per_frame; i++)
+        llr_full_codeword[i] = llr[i - unused_data_bits];
+      *iter =
+          run_ldpc_decoder(ldpc, out_char, llr_full_codeword, parityCheckCount);
+      break;
     case LDPC_PROT_2020B:
-        /* 2020B waveform, with unequal error protection.  Only the
-           stage1 VQ index of each LPCNet vocoder frames is
-           protected. In this case the FEC codeword is much smaller
-           than the payload data. */
-
-        // set up LDPC codeword
-        for(j=0,codec_frame=0; codec_frame<3; codec_frame++) 
-            for(i=0; i<11; i++,j++)
-                llr_full_codeword[j] = llr[codec_frame*52+i];
-        // set known LDPC codeword data bits
-        for (i = 33; i < ldpc->ldpc_data_bits_per_frame; i++)
-            llr_full_codeword[i] = -100;
-        // parity bits at end
-        for (i=0; i<ldpc->NumberParityBits; i++)
-            llr_full_codeword[ldpc->ldpc_data_bits_per_frame+i] = llr[ldpc->data_bits_per_frame+i];
-        *iter = run_ldpc_decoder(ldpc, out_char_ldpc, llr_full_codeword, parityCheckCount);
-        
-        // pass through received data bits, replacing only decoded bits
-        for (i = 0; i < ldpc->data_bits_per_frame; i++) {
-            out_char[i] = llr[i] < 0;
-        }
-        for(j=0,codec_frame=0; codec_frame<3; codec_frame++) 
-            for(i=0; i<11; i++,j++)
-                out_char[codec_frame*52+i] = out_char_ldpc[j];
-        
-        break;
+      /* 2020B waveform, with unequal error protection.  Only the
+         stage1 VQ index of each LPCNet vocoder frames is
+         protected. In this case the FEC codeword is much smaller
+         than the payload data. */
+
+      // set up LDPC codeword
+      for (j = 0, codec_frame = 0; codec_frame < 3; codec_frame++)
+        for (i = 0; i < 11; i++, j++)
+          llr_full_codeword[j] = llr[codec_frame * 52 + i];
+      // set known LDPC codeword data bits
+      for (i = 33; i < ldpc->ldpc_data_bits_per_frame; i++)
+        llr_full_codeword[i] = -100;
+      // parity bits at end
+      for (i = 0; i < ldpc->NumberParityBits; i++)
+        llr_full_codeword[ldpc->ldpc_data_bits_per_frame + i] =
+            llr[ldpc->data_bits_per_frame + i];
+      *iter = run_ldpc_decoder(ldpc, out_char_ldpc, llr_full_codeword,
+                               parityCheckCount);
+
+      // pass through received data bits, replacing only decoded bits
+      for (i = 0; i < ldpc->data_bits_per_frame; i++) {
+        out_char[i] = llr[i] < 0;
+      }
+      for (j = 0, codec_frame = 0; codec_frame < 3; codec_frame++)
+        for (i = 0; i < 11; i++, j++)
+          out_char[codec_frame * 52 + i] = out_char_ldpc[j];
+
+      break;
     default:
-        assert(0);
-    }
+      assert(0);
+  }
 }
 
-
 /* Count uncoded (raw) bit errors over frame, note we don't include UW
    of txt bits as this is done after we dissassemmble the frame */
 
-int count_uncoded_errors(struct LDPC *ldpc, struct OFDM_CONFIG *config, COMP codeword_symbols_de[], int crc16) {
-    int i, Nerrs;
-
-    int coded_syms_per_frame = ldpc->coded_bits_per_frame/config->bps;
-    int coded_bits_per_frame = ldpc->coded_bits_per_frame;
-    int data_bits_per_frame = ldpc->data_bits_per_frame;
-    int rx_bits_raw[coded_bits_per_frame];
-
-    /* generate test codeword from known payload data bits */
-
-    int test_codeword[coded_bits_per_frame];
-    uint16_t r[data_bits_per_frame];
-    uint8_t tx_bits[data_bits_per_frame];
-
-    ofdm_rand(r, data_bits_per_frame);
-
-    for (i = 0; i < data_bits_per_frame; i++) {
-        tx_bits[i] = r[i] > 16384;
-    }
-    if (crc16) {
-      uint16_t tx_crc16 = freedv_crc16_unpacked(tx_bits, data_bits_per_frame - 16);
-      uint8_t tx_crc16_bytes[] = { tx_crc16 >> 8, tx_crc16 & 0xff };
-      freedv_unpack(tx_bits + data_bits_per_frame - 16, tx_crc16_bytes, 16);
-    }
-    ldpc_encode_frame(ldpc, test_codeword, tx_bits);
-
-    for (i = 0; i < coded_syms_per_frame; i++) {
-        int bits[2];
-        complex float s = codeword_symbols_de[i].real + I * codeword_symbols_de[i].imag;
-        qpsk_demod(s, bits);
-        rx_bits_raw[config->bps * i] = bits[1];
-        rx_bits_raw[config->bps * i + 1] = bits[0];
-    }
-
-    Nerrs = 0;
-
-    for (i = 0; i < coded_bits_per_frame; i++) {
-        if (test_codeword[i] != rx_bits_raw[i]) Nerrs++;
-    }
-
-    return Nerrs;
+int count_uncoded_errors(struct LDPC *ldpc, struct OFDM_CONFIG *config,
+                         COMP codeword_symbols_de[], int crc16) {
+  int i, Nerrs;
+
+  int coded_syms_per_frame = ldpc->coded_bits_per_frame / config->bps;
+  int coded_bits_per_frame = ldpc->coded_bits_per_frame;
+  int data_bits_per_frame = ldpc->data_bits_per_frame;
+  int rx_bits_raw[coded_bits_per_frame];
+
+  /* generate test codeword from known payload data bits */
+
+  int test_codeword[coded_bits_per_frame];
+  uint16_t r[data_bits_per_frame];
+  uint8_t tx_bits[data_bits_per_frame];
+
+  ofdm_rand(r, data_bits_per_frame);
+
+  for (i = 0; i < data_bits_per_frame; i++) {
+    tx_bits[i] = r[i] > 16384;
+  }
+  if (crc16) {
+    uint16_t tx_crc16 =
+        freedv_crc16_unpacked(tx_bits, data_bits_per_frame - 16);
+    uint8_t tx_crc16_bytes[] = {tx_crc16 >> 8, tx_crc16 & 0xff};
+    freedv_unpack(tx_bits + data_bits_per_frame - 16, tx_crc16_bytes, 16);
+  }
+  ldpc_encode_frame(ldpc, test_codeword, tx_bits);
+
+  for (i = 0; i < coded_syms_per_frame; i++) {
+    int bits[2];
+    complex float s =
+        codeword_symbols_de[i].real + I * codeword_symbols_de[i].imag;
+    qpsk_demod(s, bits);
+    rx_bits_raw[config->bps * i] = bits[1];
+    rx_bits_raw[config->bps * i + 1] = bits[0];
+  }
+
+  Nerrs = 0;
+
+  for (i = 0; i < coded_bits_per_frame; i++) {
+    if (test_codeword[i] != rx_bits_raw[i]) Nerrs++;
+  }
+
+  return Nerrs;
 }
 
 int count_errors(uint8_t tx_bits[], uint8_t rx_bits[], int n) {
-    int i;
-    int Nerrs = 0;
+  int i;
+  int Nerrs = 0;
 
-    for (i = 0; i < n; i++)
-        if (tx_bits[i] != rx_bits[i]) Nerrs++;
+  for (i = 0; i < n; i++)
+    if (tx_bits[i] != rx_bits[i]) Nerrs++;
 
-    return Nerrs;
+  return Nerrs;
 }
 
-
-/* for unequal protection modes, count coded errors only in those bits that have been protected */
-void count_errors_protection_mode(int protection_mode, int *pNerrs, int *pNcoded, uint8_t tx_bits[],
+/* for unequal protection modes, count coded errors only in those bits that have
+ * been protected */
+void count_errors_protection_mode(int protection_mode, int *pNerrs,
+                                  int *pNcoded, uint8_t tx_bits[],
                                   uint8_t rx_bits[], int n) {
-    int i;
-    int Nerrs = 0;
-    int Ncoded = 0;
+  int i;
+  int Nerrs = 0;
+  int Ncoded = 0;
 
-    switch (protection_mode) {
+  switch (protection_mode) {
     case LDPC_PROT_EQUAL:
     case LDPC_PROT_2020:
-        for (i = 0; i < n; i++) {
-            if (tx_bits[i] != rx_bits[i]) Nerrs++;
-            Ncoded++;
-        }
-        break;
+      for (i = 0; i < n; i++) {
+        if (tx_bits[i] != rx_bits[i]) Nerrs++;
+        Ncoded++;
+      }
+      break;
     case LDPC_PROT_2020B:
-       /* We only protect bits 0..10 in each 52 bit LPCNet codec
-           frame. There are 3 codec frames 3x52=156 data bits, of
-           which only 11*3 = 33 bits are protected.
-         */
-        for(int codec_frame=0; codec_frame<3; codec_frame++) {
-            for(i=0; i<11; i++) {
-                if (tx_bits[codec_frame*52+i] != rx_bits[codec_frame*52+i]) Nerrs++;
-                Ncoded++;
-            }
+      /* We only protect bits 0..10 in each 52 bit LPCNet codec
+          frame. There are 3 codec frames 3x52=156 data bits, of
+          which only 11*3 = 33 bits are protected.
+        */
+      for (int codec_frame = 0; codec_frame < 3; codec_frame++) {
+        for (i = 0; i < 11; i++) {
+          if (tx_bits[codec_frame * 52 + i] != rx_bits[codec_frame * 52 + i])
+            Nerrs++;
+          Ncoded++;
         }
-        break;
+      }
+      break;
     default:
-        assert(0);            
-    }
+      assert(0);
+  }
 
-    *pNerrs = Nerrs;
-    *pNcoded = Ncoded;
+  *pNerrs = Nerrs;
+  *pNcoded = Ncoded;
 }
 
 /*
    Given an array of tx_bits, LDPC encodes, interleaves, and OFDM modulates
  */
 
-void ofdm_ldpc_interleave_tx(struct OFDM *ofdm, struct LDPC *ldpc, complex float tx_sams[], uint8_t tx_bits[], uint8_t txt_bits[]) {
-    int Npayloadsymsperpacket = ldpc->coded_bits_per_frame/ofdm->bps;
-    int Npayloadbitsperpacket = ldpc->coded_bits_per_frame;
-    int Nbitsperpacket = ofdm_get_bits_per_packet(ofdm);
-    int codeword[Npayloadbitsperpacket];
-    COMP payload_symbols[Npayloadsymsperpacket];
-    COMP payload_symbols_inter[Npayloadsymsperpacket];
-    complex float tx_symbols[Nbitsperpacket/ ofdm->bps];
-
-    ldpc_encode_frame(ldpc, codeword, tx_bits);
-    qpsk_modulate_frame(payload_symbols, codeword, Npayloadsymsperpacket);
-    gp_interleave_comp(payload_symbols_inter, payload_symbols, Npayloadsymsperpacket);
-    ofdm_assemble_qpsk_modem_packet_symbols(ofdm, tx_symbols, payload_symbols_inter, txt_bits);
-    ofdm_txframe(ofdm, tx_sams, tx_symbols);
+void ofdm_ldpc_interleave_tx(struct OFDM *ofdm, struct LDPC *ldpc,
+                             complex float tx_sams[], uint8_t tx_bits[],
+                             uint8_t txt_bits[]) {
+  int Npayloadsymsperpacket = ldpc->coded_bits_per_frame / ofdm->bps;
+  int Npayloadbitsperpacket = ldpc->coded_bits_per_frame;
+  int Nbitsperpacket = ofdm_get_bits_per_packet(ofdm);
+  int codeword[Npayloadbitsperpacket];
+  COMP payload_symbols[Npayloadsymsperpacket];
+  COMP payload_symbols_inter[Npayloadsymsperpacket];
+  complex float tx_symbols[Nbitsperpacket / ofdm->bps];
+
+  ldpc_encode_frame(ldpc, codeword, tx_bits);
+  qpsk_modulate_frame(payload_symbols, codeword, Npayloadsymsperpacket);
+  gp_interleave_comp(payload_symbols_inter, payload_symbols,
+                     Npayloadsymsperpacket);
+  ofdm_assemble_qpsk_modem_packet_symbols(ofdm, tx_symbols,
+                                          payload_symbols_inter, txt_bits);
+  ofdm_txframe(ofdm, tx_sams, tx_symbols);
 }
-- 
cgit v1.2.3


From 4d6c143c0abec15e1d6ed1fd95d36f80e6cb7df8 Mon Sep 17 00:00:00 2001
From: drowe67 <david@rowetel.com>
Date: Sun, 16 Jul 2023 11:01:38 +0930
Subject: rm FreeDV 2020C

---
 CMakeLists.txt         | 16 +---------------
 src/freedv_2020.c      |  7 -------
 src/freedv_api.c       | 32 ++++++++++----------------------
 src/freedv_api.h       |  4 ----
 src/freedv_rx.c        |  6 ++----
 src/freedv_tx.c        |  3 +--
 src/interldpc.c        |  1 -
 src/ldpc_codes.c       |  3 ++-
 src/ofdm.c             |  2 +-
 src/ofdm_mode.c        | 16 ----------------
 unittest/check_peak.sh |  1 -
 11 files changed, 17 insertions(+), 74 deletions(-)

(limited to 'src/interldpc.c')

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d296efe..d96667f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -589,14 +589,7 @@ endif()
                             ./ofdm_mod --in /dev/zero --testframes 10 --mode 2020B --ldpc --clip --txbpf |
                             ./ch - - --No -19 |
                             ./ofdm_demod --mode 2020B --testframes --ldpc -v 2 > /dev/null")
-           
-    # 2020C AWGN test 
-    add_test(NAME test_OFDM_modem_2020C_AWGN
-             COMMAND sh -c "cd ${CMAKE_CURRENT_BINARY_DIR}/src;
-                            ./ofdm_mod --in /dev/zero --testframes 10 --mode 2020C --ldpc --clip --txbpf |
-                            ./ch - - --No -21 |
-                            ./ofdm_demod --mode 2020C --testframes --ldpc -v 2 > /dev/null")
-           
+                      
     # -------------------------------------------------------------------------
     #                                OFDM Data modes
     # -------------------------------------------------------------------------
@@ -865,13 +858,6 @@ if(LPCNET)
                             ./freedv_rx 2020B - /dev/null --testframes"
              )
 
-     add_test(NAME test_freedv_api_2020C_mpd
-              COMMAND sh -c "cd ${CMAKE_CURRENT_BINARY_DIR}/src;
-                            dd bs=32000 count=60 if=/dev/zero |
-                            ./freedv_tx 2020C - - --testframes --clip 1 |
-                            ./ch - - --No -32 --mpd --fading_dir ../unittest |
-                            ./freedv_rx 2020C - /dev/null --testframes"
-             )
 endif()
 
      add_test(NAME test_freedv_api_2400A
diff --git a/src/freedv_2020.c b/src/freedv_2020.c
index 879ea54..f1dee28 100644
--- a/src/freedv_2020.c
+++ b/src/freedv_2020.c
@@ -48,9 +48,6 @@ void freedv_2020x_open(struct freedv *f) {
     case FREEDV_MODE_2020B:
       ofdm_init_mode("2020B", &ofdm_config);
       break;
-    case FREEDV_MODE_2020C:
-      ofdm_init_mode("2020C", &ofdm_config);
-      break;
     default:
       assert(0);
   }
@@ -71,10 +68,6 @@ void freedv_2020x_open(struct freedv *f) {
       vq_type = 2; /* index optimised VQ for increased robustness to single bit
                       errors */
       break;
-    case FREEDV_MODE_2020C:
-      vq_type = 2; /* index optimised VQ for increased robustness to single bit
-                      errors */
-      break;
     default:
       assert(0);
   }
diff --git a/src/freedv_api.c b/src/freedv_api.c
index b56d6a0..5172959 100644
--- a/src/freedv_api.c
+++ b/src/freedv_api.c
@@ -120,7 +120,6 @@ struct freedv *freedv_open_advanced(int mode, struct freedv_advanced *adv) {
        FDV_MODE_ACTIVE(FREEDV_MODE_800XA, mode) ||
        FDV_MODE_ACTIVE(FREEDV_MODE_2020, mode) ||
        FDV_MODE_ACTIVE(FREEDV_MODE_2020B, mode) ||
-       FDV_MODE_ACTIVE(FREEDV_MODE_2020C, mode) ||
        FDV_MODE_ACTIVE(FREEDV_MODE_FSK_LDPC, mode) ||
        FDV_MODE_ACTIVE(FREEDV_MODE_DATAC0, mode) ||
        FDV_MODE_ACTIVE(FREEDV_MODE_DATAC1, mode) ||
@@ -143,8 +142,7 @@ struct freedv *freedv_open_advanced(int mode, struct freedv_advanced *adv) {
     freedv_ofdm_voice_open(f, "700E");
 #ifdef __LPCNET__
   if (FDV_MODE_ACTIVE(FREEDV_MODE_2020, mode) ||
-      FDV_MODE_ACTIVE(FREEDV_MODE_2020B, mode) ||
-      FDV_MODE_ACTIVE(FREEDV_MODE_2020C, mode))
+      FDV_MODE_ACTIVE(FREEDV_MODE_2020B, mode))
     freedv_2020x_open(f);
 #endif
   if (FDV_MODE_ACTIVE(FREEDV_MODE_2400A, mode)) freedv_2400a_open(f);
@@ -203,8 +201,7 @@ void freedv_close(struct freedv *freedv) {
   }
 
   if (FDV_MODE_ACTIVE(FREEDV_MODE_2020, freedv->mode) ||
-      FDV_MODE_ACTIVE(FREEDV_MODE_2020B, freedv->mode) ||
-      FDV_MODE_ACTIVE(FREEDV_MODE_2020C, freedv->mode)) {
+      FDV_MODE_ACTIVE(FREEDV_MODE_2020B, freedv->mode)) {
     FREE(freedv->codeword_symbols);
     FREE(freedv->codeword_amps);
     FREE(freedv->ldpc);
@@ -263,7 +260,6 @@ static void codec2_encode_upacked(struct freedv *f, uint8_t unpacked_bits[],
 static int is_ofdm_mode(struct freedv *f) {
   return FDV_MODE_ACTIVE(FREEDV_MODE_2020, f->mode) ||
          FDV_MODE_ACTIVE(FREEDV_MODE_2020B, f->mode) ||
-         FDV_MODE_ACTIVE(FREEDV_MODE_2020C, f->mode) ||
          FDV_MODE_ACTIVE(FREEDV_MODE_700D, f->mode) ||
          FDV_MODE_ACTIVE(FREEDV_MODE_700E, f->mode) ||
          FDV_MODE_ACTIVE(FREEDV_MODE_DATAC0, f->mode) ||
@@ -347,8 +343,7 @@ void freedv_comptx(struct freedv *f, COMP mod_out[], short speech_in[]) {
          FDV_MODE_ACTIVE(FREEDV_MODE_700D, f->mode) ||
          FDV_MODE_ACTIVE(FREEDV_MODE_700E, f->mode) ||
          FDV_MODE_ACTIVE(FREEDV_MODE_2020, f->mode) ||
-         FDV_MODE_ACTIVE(FREEDV_MODE_2020B, f->mode) ||
-         FDV_MODE_ACTIVE(FREEDV_MODE_2020C, f->mode));
+         FDV_MODE_ACTIVE(FREEDV_MODE_2020B, f->mode));
 
   if (FDV_MODE_ACTIVE(FREEDV_MODE_1600, f->mode)) {
     codec2_encode_upacked(f, f->tx_payload_bits, speech_in);
@@ -382,8 +377,7 @@ void freedv_comptx(struct freedv *f, COMP mod_out[], short speech_in[]) {
 
 #ifdef __LPCNET__
   if (FDV_MODE_ACTIVE(FREEDV_MODE_2020, f->mode) ||
-      FDV_MODE_ACTIVE(FREEDV_MODE_2020B, f->mode) ||
-      FDV_MODE_ACTIVE(FREEDV_MODE_2020C, f->mode)) {
+      FDV_MODE_ACTIVE(FREEDV_MODE_2020B, f->mode)) {
     /* buffer up bits until we get enough encoded bits for interleaver */
 
     for (int j = 0; j < f->n_codec_frames; j++) {
@@ -764,8 +758,7 @@ int freedv_rx(struct freedv *f, short speech_out[], short demod_in[]) {
   if (FDV_MODE_ACTIVE(FREEDV_MODE_1600, f->mode) ||
       FDV_MODE_ACTIVE(FREEDV_MODE_700C, f->mode) ||
       FDV_MODE_ACTIVE(FREEDV_MODE_2020, f->mode) ||
-      FDV_MODE_ACTIVE(FREEDV_MODE_2020B, f->mode) ||
-      FDV_MODE_ACTIVE(FREEDV_MODE_2020C, f->mode)) {
+      FDV_MODE_ACTIVE(FREEDV_MODE_2020B, f->mode)) {
     float gain = 1.0f;
 
     assert(nin <= f->n_max_modem_samples);
@@ -818,8 +811,7 @@ int freedv_comprx(struct freedv *f, short speech_out[], COMP demod_in[]) {
   }
 
   if (FDV_MODE_ACTIVE(FREEDV_MODE_2020, f->mode) ||
-      FDV_MODE_ACTIVE(FREEDV_MODE_2020B, f->mode) ||
-      FDV_MODE_ACTIVE(FREEDV_MODE_2020C, f->mode)) {
+      FDV_MODE_ACTIVE(FREEDV_MODE_2020B, f->mode)) {
 #ifdef __LPCNET__
     rx_status = freedv_comprx_2020(f, demod_in);
 #endif
@@ -906,8 +898,7 @@ int freedv_bits_to_speech(struct freedv *f, short speech_out[],
       /* pass through received samples so we can hear what's going on, e.g.
        * during tuning */
 
-      if ((f->mode == FREEDV_MODE_2020) || (f->mode == FREEDV_MODE_2020B) ||
-          (f->mode == FREEDV_MODE_2020C)) {
+      if ((f->mode == FREEDV_MODE_2020) || (f->mode == FREEDV_MODE_2020B)) {
         /* 8kHz modem sample rate but 16 kHz speech sample
            rate, so we need to resample */
         nout = 2 * f->nin_prev;
@@ -953,8 +944,7 @@ int freedv_bits_to_speech(struct freedv *f, short speech_out[],
 
   if (decode_speech) {
     if (FDV_MODE_ACTIVE(FREEDV_MODE_2020, f->mode) ||
-        FDV_MODE_ACTIVE(FREEDV_MODE_2020B, f->mode) ||
-        FDV_MODE_ACTIVE(FREEDV_MODE_2020C, f->mode)) {
+        FDV_MODE_ACTIVE(FREEDV_MODE_2020B, f->mode)) {
 #ifdef __LPCNET__
       /* LPCNet decoder */
 
@@ -1170,8 +1160,7 @@ void freedv_set_callback_txt_sym(struct freedv *f, freedv_callback_rx_sym rx,
   if (FDV_MODE_ACTIVE(FREEDV_MODE_700D, f->mode) ||
       FDV_MODE_ACTIVE(FREEDV_MODE_700E, f->mode) ||
       FDV_MODE_ACTIVE(FREEDV_MODE_2020, f->mode) ||
-      FDV_MODE_ACTIVE(FREEDV_MODE_2020B, f->mode) ||
-      FDV_MODE_ACTIVE(FREEDV_MODE_2020C, f->mode)) {
+      FDV_MODE_ACTIVE(FREEDV_MODE_2020B, f->mode)) {
     f->freedv_put_next_rx_symbol = rx;
     f->callback_state_sym = state;
   }
@@ -1516,8 +1505,7 @@ int freedv_get_n_max_speech_samples(struct freedv *f) {
      array */
   int max_output_passthrough_samples;
   if (FDV_MODE_ACTIVE(FREEDV_MODE_2020, f->mode) ||
-      FDV_MODE_ACTIVE(FREEDV_MODE_2020B, f->mode) ||
-      FDV_MODE_ACTIVE(FREEDV_MODE_2020C, f->mode))
+      FDV_MODE_ACTIVE(FREEDV_MODE_2020B, f->mode))
     // In 2020 we oversample the input modem samples from 8->16 kHz
     max_output_passthrough_samples = 2 * freedv_get_n_max_modem_samples(f);
   else
diff --git a/src/freedv_api.h b/src/freedv_api.h
index eda0777..ce95a55 100644
--- a/src/freedv_api.h
+++ b/src/freedv_api.h
@@ -53,7 +53,6 @@ extern "C" {
 #define FREEDV_MODE_700E 13
 #define FREEDV_MODE_2020 8
 #define FREEDV_MODE_2020B 16
-#define FREEDV_MODE_2020C 17
 
 // available data modes
 #define FREEDV_MODE_FSK_LDPC 9
@@ -123,9 +122,6 @@ extern "C" {
 #if !defined(FREEDV_MODE_2020B_EN)
 #define FREEDV_MODE_2020B_EN FREEDV_MODE_EN_DEFAULT
 #endif
-#if !defined(FREEDV_MODE_2020C_EN)
-#define FREEDV_MODE_2020C_EN FREEDV_MODE_EN_DEFAULT
-#endif
 #if !defined(FREEDV_MODE_FSK_LDPC_EN)
 #define FREEDV_MODE_FSK_LDPC_EN FREEDV_MODE_EN_DEFAULT
 #endif
diff --git a/src/freedv_rx.c b/src/freedv_rx.c
index 18045a9..c4df02c 100644
--- a/src/freedv_rx.c
+++ b/src/freedv_rx.c
@@ -76,7 +76,7 @@ int main(int argc, char *argv[]) {
 
   char f2020[80] = {0};
 #ifdef __LPCNET__
-  sprintf(f2020, "|2020|2020B|2020C");
+  sprintf(f2020, "|2020|2020B");
 #endif
 
   if (argc < 4) {
@@ -181,7 +181,6 @@ int main(int argc, char *argv[]) {
 #ifdef __LPCNET__
   if (!strcmp(argv[dx], "2020")) mode = FREEDV_MODE_2020;
   if (!strcmp(argv[dx], "2020B")) mode = FREEDV_MODE_2020B;
-  if (!strcmp(argv[dx], "2020C")) mode = FREEDV_MODE_2020C;
 #endif
   if (mode == -1) {
     fprintf(stderr, "Error in mode: %s\n", argv[dx]);
@@ -314,8 +313,7 @@ int main(int argc, char *argv[]) {
     fprintf(stderr, "BER......: %5.4f  Tbits: %8d  Terrs: %8d\n",
             (double)uncoded_ber, Tbits, Terrs);
     if ((mode == FREEDV_MODE_700D) || (mode == FREEDV_MODE_700E) ||
-        (mode == FREEDV_MODE_2020) || (mode == FREEDV_MODE_2020B) ||
-        (mode == FREEDV_MODE_2020C)) {
+        (mode == FREEDV_MODE_2020) || (mode == FREEDV_MODE_2020B)) {
       int Tbits_coded = freedv_get_total_bits_coded(freedv);
       int Terrs_coded = freedv_get_total_bit_errors_coded(freedv);
       float coded_ber = (float)Terrs_coded / Tbits_coded;
diff --git a/src/freedv_tx.c b/src/freedv_tx.c
index 83d2847..4f1325b 100644
--- a/src/freedv_tx.c
+++ b/src/freedv_tx.c
@@ -65,7 +65,7 @@ int main(int argc, char *argv[]) {
   reliable_text_t reliable_text_obj;
   char f2020[80] = {0};
 #ifdef __LPCNET__
-  sprintf(f2020, "|2020|2020B|2020C");
+  sprintf(f2020, "|2020|2020B");
 #endif
 
   if (argc < 4) {
@@ -144,7 +144,6 @@ int main(int argc, char *argv[]) {
 #ifdef __LPCNET__
   if (!strcmp(argv[dx], "2020")) mode = FREEDV_MODE_2020;
   if (!strcmp(argv[dx], "2020B")) mode = FREEDV_MODE_2020B;
-  if (!strcmp(argv[dx], "2020C")) mode = FREEDV_MODE_2020C;
 #endif
   if (mode == -1) {
     fprintf(stderr, "Error in mode: %s\n", argv[dx]);
diff --git a/src/interldpc.c b/src/interldpc.c
index e498807..24f4b2a 100644
--- a/src/interldpc.c
+++ b/src/interldpc.c
@@ -76,7 +76,6 @@ void ldpc_mode_specific_setup(struct OFDM *ofdm, struct LDPC *ldpc) {
     set_data_bits_per_frame(ldpc, 156);
     ldpc->protection_mode = LDPC_PROT_2020B;
   }
-  if (!strcmp(ofdm->mode, "2020C")) set_data_bits_per_frame(ldpc, 156);
   if (!strcmp(ofdm->mode, "datac4")) set_data_bits_per_frame(ldpc, 448);
   if (!strcmp(ofdm->mode, "datac13")) set_data_bits_per_frame(ldpc, 128);
 }
diff --git a/src/ldpc_codes.c b/src/ldpc_codes.c
index 4289db1..d01bd69 100644
--- a/src/ldpc_codes.c
+++ b/src/ldpc_codes.c
@@ -51,7 +51,8 @@ struct LDPC ldpc_codes[] = {
      HRAb_396_504_MAX_ROW_WEIGHT, HRAb_396_504_MAX_COL_WEIGHT,
      (uint16_t *)HRAb_396_504_H_rows, (uint16_t *)HRAb_396_504_H_cols},
 
-    /* Rate 0.745 code for mopping up errors on 2020C from Bill VK5DSP */
+    /* Rate 0.745 code for mopping up errors on 2020C from Bill
+       VK5DSP. 2020C has been removed but code might be useful in future */
     {"H_212_158", H_212_158_MAX_ITER, 0, 1, 1, H_212_158_CODELENGTH,
      H_212_158_NUMBERPARITYBITS, H_212_158_NUMBERROWSHCOLS,
      H_212_158_MAX_ROW_WEIGHT, H_212_158_MAX_COL_WEIGHT,
diff --git a/src/ofdm.c b/src/ofdm.c
index 5348ef7..28d6dba 100644
--- a/src/ofdm.c
+++ b/src/ofdm.c
@@ -551,7 +551,7 @@ static void allocate_tx_bpf(struct OFDM *ofdm) {
     quisk_filt_cfInit(ofdm->tx_bpf, filtP900S1100,
                       sizeof(filtP900S1100) / sizeof(float));
     quisk_cfTune(ofdm->tx_bpf, ofdm->tx_centre / ofdm->fs);
-  } else if (!strcmp(ofdm->mode, "2020B") || !strcmp(ofdm->mode, "2020C")) {
+  } else if (!strcmp(ofdm->mode, "2020B")) {
     quisk_filt_cfInit(ofdm->tx_bpf, filtP1100S1300,
                       sizeof(filtP1100S1300) / sizeof(float));
     quisk_cfTune(ofdm->tx_bpf, ofdm->tx_centre / ofdm->fs);
diff --git a/src/ofdm_mode.c b/src/ofdm_mode.c
index 6c1df32..1aabb1a 100644
--- a/src/ofdm_mode.c
+++ b/src/ofdm_mode.c
@@ -92,22 +92,6 @@ void ofdm_init_mode(char mode[], struct OFDM_CONFIG *config) {
     config->state_machine = "voice2";
     config->ftwindowwidth = 64;
     config->foff_limiter = true;
-  } else if (strcmp(mode, "2020C") == 0) {
-    config->ts = 0.014;
-    config->tcp = 0.004;
-    config->nc = 29;
-    config->ns = 5;
-    config->codename = "H_212_158";
-    config->txtbits = 4;
-    config->nuwbits = 8 * 2;
-    config->bad_uw_errors = 5;
-    config->amp_scale = 130E3;
-    config->clip_gain1 = 2.5;
-    config->clip_gain2 = 0.8;
-    config->edge_pilots = 0;
-    config->state_machine = "voice2";
-    config->ftwindowwidth = 64;
-    config->foff_limiter = true;
   } else if (strcmp(mode, "qam16") == 0) {
     /* not in use yet */
     config->ns = 5;
diff --git a/unittest/check_peak.sh b/unittest/check_peak.sh
index 6462d04..8f41c2a 100755
--- a/unittest/check_peak.sh
+++ b/unittest/check_peak.sh
@@ -38,7 +38,6 @@ if [ "$1" == "LPCNet" ]; then
     # these don't get run unless we build with LPCNet
     voice_test "2020"
     voice_test "2020B"
-    voice_test "2020C"
   else
     voice_test "1600"
     voice_test "700C"
-- 
cgit v1.2.3