/*---------------------------------------------------------------------------*\ FILE........: freedv_api.c AUTHOR......: David Rowe DATE CREATED: August 2014 Library of API functions that implement FreeDV "modes", useful for embedding FreeDV in other programs. \*---------------------------------------------------------------------------*/ /* Copyright (C) 2014 David Rowe All rights reserved. This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License version 2.1, as published by the Free Software Foundation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, see . */ #include #include #include #include #include #include #include #ifdef TT #if defined(__APPLE__) #include #elif defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD__) #include #else #include #endif /* __APPLE__ */ #endif #include "fsk.h" #include "fmfsk.h" #include "codec2/codec2.h" #include "codec2_fdmdv.h" #include "fdmdv_internal.h" #include "codec2/golay23.h" #include "codec2/varicode.h" #include "libfreedv.h" #include "freedv_api_internal.h" #include "freedv_vhf_framing.h" #include "comp_prim.h" #include "freedv_filter.h" #include "codec2_ofdm.h" #include "ofdm_internal.h" #include "mpdecode_core.h" #include "gp_interleaver.h" #include "interldpc.h" #define VERSION 12 /* The API version number. The first version is 10. Increment if the API changes in a way that would require changes by the API user. */ /* * Version 10 Initial version August 2, 2015. * Version 11 September 2015 * Added: freedv_zero_total_bit_errors(), freedv_get_sync() * Changed all input and output sample rates to 8000 sps. Rates for FREEDV_MODE_700 and 700B were 7500. * Version 12 August 2018 * Added OFDM configuration switch structure */ /* experimentally derived fudge factors to normalise power across modes */ #define NORM_PWR_COHPSK 1.74 #define NORM_PWR_FSK 0.193 #define NORM_PWR_OFDM 1.00 namespace FreeDV { static struct OFDM_CONFIG *ofdm_config; static int ofdm_bitsperframe; static int ofdm_nuwbits; static int ofdm_ntxtbits; static const char *statemode[] = { "search", "trial", "synced" }; /*---------------------------------------------------------------------------*\ FUNCTION....: freedv_open AUTHOR......: David Rowe DATE CREATED: 3 August 2014 Call this first to initialise. Returns NULL if initialisation fails (e.g. out of memory or mode not supported). \*---------------------------------------------------------------------------*/ struct freedv *freedv_open(int mode) { return freedv_open_advanced(mode, NULL); } struct freedv *freedv_open_advanced(int mode, struct freedv_advanced *adv) { struct freedv *f; int Nc, codec2_mode, nbit, nbyte; if ((mode != FREEDV_MODE_1600) && (mode != FREEDV_MODE_700) && (mode != FREEDV_MODE_700B) && (mode != FREEDV_MODE_2400A) && (mode != FREEDV_MODE_2400B) && (mode != FREEDV_MODE_800XA) && (mode != FREEDV_MODE_700C) && (mode != FREEDV_MODE_700D) ) return NULL; f = (struct freedv*) malloc(sizeof(struct freedv)); if (f == NULL) return NULL; f->mode = mode; f->verbose = 0; f->test_frames = f->smooth_symbols = 0; f->freedv_put_error_pattern = NULL; f->error_pattern_callback_state = NULL; f->n_protocol_bits = 0; f->frames = 0; /* Init states for this mode, and set up samples in/out -----------------------------------------*/ if (mode == FREEDV_MODE_1600) { f->snr_squelch_thresh = 2.0; f->squelch_en = 1; Nc = 16; f->tx_sync_bit = 0; codec2_mode = CODEC2_MODE_1300; f->fdmdv = fdmdv_create(Nc); if (f->fdmdv == NULL) return NULL; golay23_init(); f->nin = FDMDV_NOM_SAMPLES_PER_FRAME; f->n_nom_modem_samples = 2*FDMDV_NOM_SAMPLES_PER_FRAME; f->n_nat_modem_samples = f->n_nom_modem_samples; f->n_max_modem_samples = FDMDV_NOM_SAMPLES_PER_FRAME+FDMDV_MAX_SAMPLES_PER_FRAME; f->modem_sample_rate = FS; nbit = fdmdv_bits_per_frame(f->fdmdv); f->fdmdv_bits = (int*) malloc(nbit*sizeof(int)); if (f->fdmdv_bits == NULL) return NULL; nbit = 2*fdmdv_bits_per_frame(f->fdmdv); f->tx_bits = (int*) malloc(nbit*sizeof(int)); f->rx_bits = (int*) malloc(nbit*sizeof(int)); if ((f->tx_bits == NULL) || (f->rx_bits == NULL)) { if (f->tx_bits != NULL) { free(f->tx_bits); f->tx_bits = NULL; } if (f->rx_bits != NULL) { free(f->rx_bits); f->rx_bits = NULL; } return NULL; } f->evenframe = 0; f->sz_error_pattern = fdmdv_error_pattern_size(f->fdmdv); } if ((mode == FREEDV_MODE_700) || (mode == FREEDV_MODE_700B) || (mode == FREEDV_MODE_700C)) { f->snr_squelch_thresh = 0.0; f->squelch_en = 0; switch(mode) { case FREEDV_MODE_700: codec2_mode = CODEC2_MODE_700; break; case FREEDV_MODE_700B: codec2_mode = CODEC2_MODE_700B; break; case FREEDV_MODE_700C: codec2_mode = CODEC2_MODE_700C; break; default: codec2_mode = CODEC2_MODE_700C; fprintf(stderr, "FreeDV::freedv_open_advanced: unknown mode default to FREEDV_MODE_700C"); } f->cohpsk = cohpsk_create(); f->nin = COHPSK_NOM_SAMPLES_PER_FRAME; f->n_nat_modem_samples = COHPSK_NOM_SAMPLES_PER_FRAME; // native modem samples as used by the modem f->n_nom_modem_samples = f->n_nat_modem_samples * FS / COHPSK_FS; // number of samples after native samples are interpolated to 8000 sps f->n_max_modem_samples = COHPSK_MAX_SAMPLES_PER_FRAME * FS / COHPSK_FS + 1; f->modem_sample_rate = FS; /* note wierd sample rate tamed by interpolator */ f->clip = 1; nbit = COHPSK_BITS_PER_FRAME; f->tx_bits = (int*) malloc(nbit*sizeof(int)); if (f->tx_bits == NULL) return NULL; f->sz_error_pattern = cohpsk_error_pattern_size(); } if (mode == FREEDV_MODE_700D) { /* TODO: [ ] how to set up interleaver, prob init time option best, as many arrays depend on it [ ] clip option? Haven't tried clipping OFDM waveform yet [ ] support for uncoded and coded error patterns */ f->snr_squelch_thresh = 0.0; f->squelch_en = 0; codec2_mode = CODEC2_MODE_700C; if ((ofdm_config = (struct OFDM_CONFIG *) calloc(1, sizeof (struct OFDM_CONFIG))) == NULL) { if (f->tx_bits != NULL) { free(f->tx_bits); f->tx_bits = NULL; } if (f->rx_bits != NULL) { free(f->rx_bits); f->rx_bits = NULL; } return NULL; } f->ofdm = ofdm_create(ofdm_config); free(ofdm_config); /* Get a copy of the actual modem config */ ofdm_config = ofdm_get_config_param(); ofdm_bitsperframe = ofdm_get_bits_per_frame(); ofdm_nuwbits = (ofdm_config->ns - 1) * ofdm_config->bps - ofdm_config->txtbits; ofdm_ntxtbits = ofdm_config->txtbits; f->ldpc = (struct LDPC*) malloc(sizeof(struct LDPC)); if (f->ldpc == NULL) { return NULL; } set_up_hra_112_112(f->ldpc, ofdm_config); int coded_syms_per_frame = f->ldpc->coded_syms_per_frame; if (adv == NULL) { f->interleave_frames = 1; } else { assert((adv->interleave_frames >= 0) && (adv->interleave_frames <= 16)); f->interleave_frames = adv->interleave_frames; } f->modem_frame_count_tx = f->modem_frame_count_rx = 0; f->codeword_symbols = (COMP*) malloc(sizeof(COMP)*f->interleave_frames*coded_syms_per_frame); if (f->codeword_symbols == NULL) {return NULL;} f->codeword_amps = (float*) malloc(sizeof(float)*f->interleave_frames*coded_syms_per_frame); if (f->codeword_amps == NULL) {free(f->codeword_symbols); return NULL;} for (int i=0; iinterleave_frames*coded_syms_per_frame; i++) { f->codeword_symbols[i].real = 0.0; f->codeword_symbols[i].imag = 0.0; f->codeword_amps[i] = 0.0; } f->nin = ofdm_get_samples_per_frame(); f->n_nat_modem_samples = ofdm_get_samples_per_frame(); f->n_nom_modem_samples = ofdm_get_samples_per_frame(); f->n_max_modem_samples = ofdm_get_max_samples_per_frame(); f->modem_sample_rate = ofdm_config->fs; f->clip = 0; nbit = f->sz_error_pattern = ofdm_bitsperframe; f->tx_bits = NULL; /* not used for 700D */ if (f->interleave_frames > 1) { /* only allocate this array for interleaver sizes > 1 to save memory on SM1000 port */ f->mod_out = (COMP*) malloc(sizeof(COMP)*f->interleave_frames*f->n_nat_modem_samples); if (f->mod_out == NULL) { if (f->codeword_symbols != NULL) { free(f->codeword_symbols); } return NULL; } for (int i=0; iinterleave_frames*f->n_nat_modem_samples; i++) { f->mod_out[i].real = 0.0; f->mod_out[i].imag = 0.0; } } #ifndef __EMBEDDED__ /* tx BPF on by default, can't see any reason we'd want this off */ ofdm_set_tx_bpf(f->ofdm, 1); #endif } if ((mode == FREEDV_MODE_2400A) || (mode == FREEDV_MODE_2400B)) { /* Set up the C2 mode */ codec2_mode = CODEC2_MODE_1300; /* Set the number of protocol bits */ f->n_protocol_bits = 20; f->sz_error_pattern = 0; f->ext_vco = 0; } if (mode == FREEDV_MODE_2400A) { /* Create the framer|deframer */ f->deframer = fvhff_create_deframer(FREEDV_VHF_FRAME_A,0); if(f->deframer == NULL) return NULL; f->fsk = fsk_create_hbr(48000,1200,10,4,1200,1200); /* Note: fsk expects tx/rx bits as an array of uint8_ts, not ints */ f->tx_bits = (int*) malloc(f->fsk->Nbits*sizeof(uint8_t)); if(f->fsk == NULL){ fvhff_destroy_deframer(f->deframer); return NULL; } f->n_nom_modem_samples = f->fsk->N; f->n_max_modem_samples = f->fsk->N + (f->fsk->Ts); f->n_nat_modem_samples = f->fsk->N; f->nin = fsk_nin(f->fsk); f->modem_sample_rate = 48000; f->modem_symbol_rate = 1200; /* Malloc something to appease freedv_init and freedv_destroy */ f->codec_bits = (int*) malloc(1); } if (mode == FREEDV_MODE_2400B) { /* Create the framer|deframer */ f->deframer = fvhff_create_deframer(FREEDV_VHF_FRAME_A,1); if(f->deframer == NULL) { if (f->codec_bits != NULL) { free(f->codec_bits); } return NULL; } f->fmfsk = fmfsk_create(48000,2400); if(f->fmfsk == NULL){ fvhff_destroy_deframer(f->deframer); return NULL; } /* Note: fsk expects tx/rx bits as an array of uint8_ts, not ints */ f->tx_bits = (int*) malloc(f->fmfsk->nbit*sizeof(uint8_t)); f->n_nom_modem_samples = f->fmfsk->N; f->n_max_modem_samples = f->fmfsk->N + (f->fmfsk->Ts); f->n_nat_modem_samples = f->fmfsk->N; f->nin = fmfsk_nin(f->fmfsk); f->modem_sample_rate = 48000; /* Malloc something to appease freedv_init and freedv_destroy */ f->codec_bits = (int*) malloc(1); } if (mode == FREEDV_MODE_800XA) { /* Create the framer|deframer */ f->deframer = fvhff_create_deframer(FREEDV_HF_FRAME_B,0); if(f->deframer == NULL) return NULL; f->fsk = fsk_create_hbr(8000,400,10,4,800,400); fsk_set_nsym(f->fsk,32); /* Note: fsk expects tx/rx bits as an array of uint8_ts, not ints */ f->tx_bits = (int*) malloc(f->fsk->Nbits*sizeof(uint8_t)); if(f->fsk == NULL){ fvhff_destroy_deframer(f->deframer); return NULL; } f->n_nom_modem_samples = f->fsk->N; f->n_max_modem_samples = f->fsk->N + (f->fsk->Ts); f->n_nat_modem_samples = f->fsk->N; f->nin = fsk_nin(f->fsk); f->modem_sample_rate = 8000; f->modem_symbol_rate = 400; /* Malloc something to appease freedv_init and freedv_destroy */ f->codec_bits = (int*) malloc(1); f->n_protocol_bits = 0; codec2_mode = CODEC2_MODE_700C; fsk_stats_normalise_eye(f->fsk, 0); f->sz_error_pattern = 0; } /* Init test frame states */ f->test_frames_diversity = 1; f->test_frame_sync_state = 0; f->test_frame_sync_state_upper = 0; f->total_bits = 0; f->total_bit_errors = 0; f->total_bits_coded = 0; f->total_bit_errors_coded = 0; /* Init Codec 2 for this FreeDV mode ----------------------------------------------------*/ f->codec2 = codec2_create(codec2_mode); if (f->codec2 == NULL) return NULL; /* work out how many codec 2 frames per mode frame, and number of bytes of storage for packed and unpacket bits. TODO: do we really need to work in packed bits at all? It's messy, chars would probably be OK.... */ if ((mode == FREEDV_MODE_1600) || (mode == FREEDV_MODE_2400A) || (mode == FREEDV_MODE_2400B)) { f->n_speech_samples = codec2_samples_per_frame(f->codec2); f->n_codec_bits = codec2_bits_per_frame(f->codec2); nbit = f->n_codec_bits; nbyte = (nbit + 7) / 8; } else if (mode == FREEDV_MODE_800XA) { f->n_speech_samples = 2*codec2_samples_per_frame(f->codec2); f->n_codec_bits = codec2_bits_per_frame(f->codec2); nbit = f->n_codec_bits; nbyte = (nbit + 7) / 8; nbyte = nbyte*2; nbit = 8*nbyte; f->n_codec_bits = nbit; } else if ((mode == FREEDV_MODE_700) || (mode == FREEDV_MODE_700B) || (mode == FREEDV_MODE_700C)) { f->n_speech_samples = 2*codec2_samples_per_frame(f->codec2); f->n_codec_bits = 2*codec2_bits_per_frame(f->codec2); nbit = f->n_codec_bits; nbyte = 2*((codec2_bits_per_frame(f->codec2) + 7) / 8); } else /* mode == FREEDV_MODE_700D */ { /* should be exactly an integer number ofCodec 2 frames in a OFDM modem frame */ assert((f->ldpc->data_bits_per_frame % codec2_bits_per_frame(f->codec2)) == 0); int Ncodec2frames = f->ldpc->data_bits_per_frame/codec2_bits_per_frame(f->codec2); f->n_speech_samples = Ncodec2frames*codec2_samples_per_frame(f->codec2); f->n_codec_bits = f->interleave_frames*Ncodec2frames*codec2_bits_per_frame(f->codec2); nbit = codec2_bits_per_frame(f->codec2); nbyte = (nbit + 7) / 8; nbyte = nbyte*Ncodec2frames*f->interleave_frames; f->nbyte_packed_codec_bits = nbyte; //fprintf(stderr, "Ncodec2frames: %d n_speech_samples: %d n_codec_bits: %d nbit: %d nbyte: %d\n", // Ncodec2frames, f->n_speech_samples, f->n_codec_bits, nbit, nbyte); f->packed_codec_bits_tx = (unsigned char*) malloc(nbyte*sizeof(char)); if (f->packed_codec_bits_tx == NULL) return(NULL); f->codec_bits = NULL; } f->packed_codec_bits = (unsigned char*) malloc(nbyte*sizeof(char)); if (f->packed_codec_bits == NULL) return(NULL); if (mode == FREEDV_MODE_1600) f->codec_bits = (int*) malloc(nbit*sizeof(int)); if ((mode == FREEDV_MODE_700) || (mode == FREEDV_MODE_700B) || (mode == FREEDV_MODE_700C)) f->codec_bits = (int*) malloc(COHPSK_BITS_PER_FRAME*sizeof(int)); /* Note: VHF Framer/deframer goes directly from packed codec/vc/proto bits to filled frame */ if (f->packed_codec_bits == NULL) { if (f->codec_bits != NULL) {free(f->codec_bits); f->codec_bits = NULL; } return NULL; } /* Sample rate conversion for modes using COHPSK */ if ((mode == FREEDV_MODE_700) || (mode == FREEDV_MODE_700B) || (mode == FREEDV_MODE_700C) ) { f->ptFilter7500to8000 = (struct quisk_cfFilter *) malloc(sizeof(struct quisk_cfFilter)); f->ptFilter8000to7500 = (struct quisk_cfFilter *) malloc(sizeof(struct quisk_cfFilter)); quisk_filt_cfInit(f->ptFilter8000to7500, quiskFilt120t480, sizeof(quiskFilt120t480)/sizeof(float)); quisk_filt_cfInit(f->ptFilter7500to8000, quiskFilt120t480, sizeof(quiskFilt120t480)/sizeof(float)); } else { f->ptFilter7500to8000 = NULL; f->ptFilter8000to7500 = NULL; } /* Varicode low bit rate text states */ varicode_decode_init(&f->varicode_dec_states, 1); f->nvaricode_bits = 0; f->varicode_bit_index = 0; f->freedv_get_next_tx_char = NULL; f->freedv_put_next_rx_char = NULL; f->freedv_put_next_proto = NULL; f->freedv_get_next_proto = NULL; f->total_bit_errors = 0; return f; } /*---------------------------------------------------------------------------*\ FUNCTION....: freedv_close AUTHOR......: David Rowe DATE CREATED: 3 August 2014 Frees up memory. \*---------------------------------------------------------------------------*/ void freedv_close(struct freedv *freedv) { assert(freedv != NULL); free(freedv->packed_codec_bits); free(freedv->codec_bits); free(freedv->tx_bits); if (freedv->mode == FREEDV_MODE_1600) fdmdv_destroy(freedv->fdmdv); if ((freedv->mode == FREEDV_MODE_700) || (freedv->mode == FREEDV_MODE_700B) || (freedv->mode == FREEDV_MODE_700C)) cohpsk_destroy(freedv->cohpsk); if (freedv->mode == FREEDV_MODE_700D) { free(freedv->packed_codec_bits_tx); if (freedv->interleave_frames > 1) free(freedv->mod_out); free(freedv->codeword_symbols); free(freedv->codeword_amps); free(freedv->ldpc); ofdm_destroy(freedv->ofdm); } if ((freedv->mode == FREEDV_MODE_2400A) || (freedv->mode == FREEDV_MODE_800XA)){ fsk_destroy(freedv->fsk); fvhff_destroy_deframer(freedv->deframer); } if (freedv->mode == FREEDV_MODE_2400B){ fmfsk_destroy(freedv->fmfsk); fvhff_destroy_deframer(freedv->deframer); } codec2_destroy(freedv->codec2); if (freedv->ptFilter8000to7500) { quisk_filt_destroy(freedv->ptFilter8000to7500); free(freedv->ptFilter8000to7500); freedv->ptFilter8000to7500 = NULL; } if (freedv->ptFilter7500to8000) { quisk_filt_destroy(freedv->ptFilter7500to8000); free(freedv->ptFilter7500to8000); freedv->ptFilter7500to8000 = NULL; } free(freedv); } /*---------------------------------------------------------------------------*\ FUNCTION....: freedv_tx AUTHOR......: David Rowe DATE CREATED: 3 August 2014 Takes a frame of input speech samples, encodes and modulates them to produce a frame of modem samples that can be sent to the transmitter. See freedv_tx.c for an example. speech_in[] is sampled at 8000 Hz, and the user must supply a block of exactly freedv_get_n_speech_samples(). The speech_in[] level should be such that the peak speech level is between +/- 16384 and +/- 32767. The FDM modem signal mod_out[] is sampled at 8000 Hz and is freedv_get_n_nom_modem_samples() long. mod_out[] will be scaled such that the peak level is just less than +/-32767. The complex-valued output can directly drive an I/Q modulator to produce a single sideband signal. To generate the other sideband, take the complex conjugate of mod_out[]. The FreeDV 1600 modem has a high crest factor (around 12dB), however the energy and duration of the peaks is small. FreeDV 1600 is usually operated at a "backoff" of 8dB. Adjust the power amplifier drive so that the average power is 8dB less than the peak power of the PA. For example, on a radio rated at 100W PEP for SSB, the average FreeDV power is typically 20W. The FreeDV 700 modem has a crest factor of about 8dB (with f->clip=1, the default), so if your PA can handle it, it can be driven harder than FreeDV 1600. Caution - some PAs cannot handle a high continuous power. A conservative level is 20W average for a 100W PEP rated PA. \*---------------------------------------------------------------------------*/ /* real-valued short sample output, useful for going straight to DAC */ /* TX routines for 2400 FSK modes, after codec2 encoding */ static void freedv_tx_fsk_voice(struct freedv *f, short mod_out[]) { int i; float *tx_float; /* To hold on to modulated samps from fsk/fmfsk */ uint8_t vc_bits[2]; /* Varicode bits for 2400 framing */ uint8_t proto_bits[3]; /* Prococol bits for 2400 framing */ /* Frame for 2400A/B */ if(f->mode == FREEDV_MODE_2400A || f->mode == FREEDV_MODE_2400B){ /* Get varicode bits for TX and possibly ask for a new char */ /* 2 bits per 2400A/B frame, so this has to be done twice */ for(i=0;i<2;i++){ if (f->nvaricode_bits) { vc_bits[i] = f->tx_varicode_bits[f->varicode_bit_index++]; f->nvaricode_bits--; } if (f->nvaricode_bits == 0) { /* get new char and encode */ char s[2]; if (f->freedv_get_next_tx_char != NULL) { s[0] = (*f->freedv_get_next_tx_char)(f->callback_state); f->nvaricode_bits = varicode_encode(f->tx_varicode_bits, s, VARICODE_MAX_BITS, 1, 1); f->varicode_bit_index = 0; } } } /* If the API user hasn't set up message callbacks, don't bother with varicode bits */ if(f->freedv_get_next_proto != NULL){ (*f->freedv_get_next_proto)(f->proto_callback_state,(char*)proto_bits); fvhff_frame_bits(FREEDV_VHF_FRAME_A,(uint8_t*)(f->tx_bits),(uint8_t*)(f->packed_codec_bits),proto_bits,vc_bits); }else if(f->freedv_get_next_tx_char != NULL){ fvhff_frame_bits(FREEDV_VHF_FRAME_A,(uint8_t*)(f->tx_bits),(uint8_t*)(f->packed_codec_bits),NULL,vc_bits); }else { fvhff_frame_bits(FREEDV_VHF_FRAME_A,(uint8_t*)(f->tx_bits),(uint8_t*)(f->packed_codec_bits),NULL,NULL); } /* Frame for 800XA */ }else if(f->mode == FREEDV_MODE_800XA){ fvhff_frame_bits(FREEDV_HF_FRAME_B,(uint8_t*)(f->tx_bits),(uint8_t*)(f->packed_codec_bits),NULL,NULL); } /* Allocate floating point buffer for FSK mod */ tx_float = (float*) malloc(sizeof(float)*f->n_nom_modem_samples); /* do 4fsk mod */ if(f->mode == FREEDV_MODE_2400A || f->mode == FREEDV_MODE_800XA){ if (f->ext_vco) { fsk_mod_ext_vco(f->fsk,tx_float,(uint8_t*)(f->tx_bits)); for(i=0; in_nom_modem_samples; i++){ mod_out[i] = (short)tx_float[i]; } } else { fsk_mod(f->fsk,tx_float,(uint8_t*)(f->tx_bits)); /* Convert float samps to short */ for(i=0; in_nom_modem_samples; i++){ mod_out[i] = (short)(tx_float[i]*FSK_SCALE*NORM_PWR_FSK); } } /* do me-fsk mod */ }else if(f->mode == FREEDV_MODE_2400B){ fmfsk_mod(f->fmfsk,tx_float,(uint8_t*)(f->tx_bits)); /* Convert float samps to short */ for(i=0; in_nom_modem_samples; i++){ mod_out[i] = (short)(tx_float[i]*FMFSK_SCALE); } } free(tx_float); } /* TX routines for 2400 FSK modes, after codec2 encoding */ static void freedv_comptx_fsk_voice(struct freedv *f, COMP mod_out[]) { int i; float *tx_float; /* To hold on to modulated samps from fsk/fmfsk */ uint8_t vc_bits[2]; /* Varicode bits for 2400 framing */ uint8_t proto_bits[3]; /* Prococol bits for 2400 framing */ /* Frame for 2400A/B */ if(f->mode == FREEDV_MODE_2400A || f->mode == FREEDV_MODE_2400B){ /* Get varicode bits for TX and possibly ask for a new char */ /* 2 bits per 2400A/B frame, so this has to be done twice */ for(i=0;i<2;i++){ if (f->nvaricode_bits) { vc_bits[i] = f->tx_varicode_bits[f->varicode_bit_index++]; f->nvaricode_bits--; } if (f->nvaricode_bits == 0) { /* get new char and encode */ char s[2]; if (f->freedv_get_next_tx_char != NULL) { s[0] = (*f->freedv_get_next_tx_char)(f->callback_state); f->nvaricode_bits = varicode_encode(f->tx_varicode_bits, s, VARICODE_MAX_BITS, 1, 1); f->varicode_bit_index = 0; } } } /* If the API user hasn't set up message callbacks, don't bother with varicode bits */ if(f->freedv_get_next_proto != NULL){ (*f->freedv_get_next_proto)(f->proto_callback_state,(char*)proto_bits); fvhff_frame_bits(FREEDV_VHF_FRAME_A,(uint8_t*)(f->tx_bits),(uint8_t*)(f->packed_codec_bits),proto_bits,vc_bits); }else if(f->freedv_get_next_tx_char != NULL){ fvhff_frame_bits(FREEDV_VHF_FRAME_A,(uint8_t*)(f->tx_bits),(uint8_t*)(f->packed_codec_bits),NULL,vc_bits); }else { fvhff_frame_bits(FREEDV_VHF_FRAME_A,(uint8_t*)(f->tx_bits),(uint8_t*)(f->packed_codec_bits),NULL,NULL); } /* Frame for 800XA */ }else if(f->mode == FREEDV_MODE_800XA){ fvhff_frame_bits(FREEDV_HF_FRAME_B,(uint8_t*)(f->tx_bits),(uint8_t*)(f->packed_codec_bits),NULL,NULL); } /* Allocate floating point buffer for FSK mod */ tx_float = (float*) malloc(sizeof(float)*f->n_nom_modem_samples); /* do 4fsk mod */ if(f->mode == FREEDV_MODE_2400A || f->mode == FREEDV_MODE_800XA){ fsk_mod_c(f->fsk,mod_out,(uint8_t*)(f->tx_bits)); /* Convert float samps to short */ for(i=0; in_nom_modem_samples; i++){ mod_out[i] = fcmult(NORM_PWR_FSK,mod_out[i]); } /* do me-fsk mod */ }else if(f->mode == FREEDV_MODE_2400B){ fmfsk_mod(f->fmfsk,tx_float,(uint8_t*)(f->tx_bits)); /* Convert float samps to short */ for(i=0; in_nom_modem_samples; i++){ mod_out[i].real = (tx_float[i]); } } free(tx_float); } /* TX routines for 2400 FSK modes, data channel */ static void freedv_tx_fsk_data(struct freedv *f, short mod_out[]) { int i; float *tx_float; /* To hold on to modulated samps from fsk/fmfsk */ if (f->mode != FREEDV_MODE_800XA) fvhff_frame_data_bits(f->deframer, FREEDV_VHF_FRAME_A,(uint8_t*)(f->tx_bits)); else fvhff_frame_data_bits(f->deframer, FREEDV_HF_FRAME_B,(uint8_t*)(f->tx_bits)); /* Allocate floating point buffer for FSK mod */ tx_float = (float*) malloc(sizeof(float)*f->n_nom_modem_samples); /* do 4fsk mod */ if(f->mode == FREEDV_MODE_2400A || f->mode == FREEDV_MODE_800XA){ fsk_mod(f->fsk,tx_float,(uint8_t*)(f->tx_bits)); /* Convert float samps to short */ for(i=0; in_nom_modem_samples; i++){ mod_out[i] = (short)(tx_float[i]*FSK_SCALE); } /* do me-fsk mod */ }else if(f->mode == FREEDV_MODE_2400B){ fmfsk_mod(f->fmfsk,tx_float,(uint8_t*)(f->tx_bits)); /* Convert float samps to short */ for(i=0; in_nom_modem_samples; i++){ mod_out[i] = (short)(tx_float[i]*FMFSK_SCALE); } } free(tx_float); } void freedv_tx(struct freedv *f, short mod_out[], short speech_in[]) { assert(f != NULL); COMP *tx_fdm = new COMP[f->n_nom_modem_samples]; int i; assert((f->mode == FREEDV_MODE_1600) || (f->mode == FREEDV_MODE_700) || (f->mode == FREEDV_MODE_700B) || (f->mode == FREEDV_MODE_700C) || (f->mode == FREEDV_MODE_700D) || (f->mode == FREEDV_MODE_2400A) || (f->mode == FREEDV_MODE_2400B) || (f->mode == FREEDV_MODE_800XA)); /* FSK and MEFSK/FMFSK modems work only on real samples. It's simpler to just * stick them in the real sample tx/rx functions than to add a comp->real converter * to comptx */ if ((f->mode == FREEDV_MODE_2400A) || (f->mode == FREEDV_MODE_2400B) || (f->mode == FREEDV_MODE_800XA)){ /* 800XA has two codec frames per modem frame */ if(f->mode == FREEDV_MODE_800XA){ codec2_encode(f->codec2, &f->packed_codec_bits[0], &speech_in[ 0]); codec2_encode(f->codec2, &f->packed_codec_bits[4], &speech_in[320]); }else{ codec2_encode(f->codec2, f->packed_codec_bits, speech_in); } freedv_tx_fsk_voice(f, mod_out); } else{ freedv_comptx(f, tx_fdm, speech_in); for(i=0; in_nom_modem_samples; i++) mod_out[i] = tx_fdm[i].real; } delete[] tx_fdm; } /* complex valued output, useful for suitable for single sided freq shifting */ static void freedv_comptx_fdmdv_1600(struct freedv *f, COMP mod_out[]) { int bit, byte, i, j; int bits_per_codec_frame, bits_per_modem_frame; int data, codeword1, data_flag_index; COMP *tx_fdm = new COMP[f->n_nat_modem_samples]; bits_per_codec_frame = codec2_bits_per_frame(f->codec2); bits_per_modem_frame = fdmdv_bits_per_frame(f->fdmdv); /* unpack bits, MSB first */ bit = 7; byte = 0; for(i=0; icodec_bits[i] = (f->packed_codec_bits[byte] >> bit) & 0x1; bit--; if (bit < 0) { bit = 7; byte++; } } // spare bit in frame that codec defines. Use this 1 // bit/frame to send txt messages data_flag_index = codec2_get_spare_bit_index(f->codec2); if (f->nvaricode_bits) { f->codec_bits[data_flag_index] = f->tx_varicode_bits[f->varicode_bit_index++]; f->nvaricode_bits--; } if (f->nvaricode_bits == 0) { /* get new char and encode */ char s[2]; if (f->freedv_get_next_tx_char != NULL) { s[0] = (*f->freedv_get_next_tx_char)(f->callback_state); f->nvaricode_bits = varicode_encode(f->tx_varicode_bits, s, VARICODE_MAX_BITS, 1, 1); f->varicode_bit_index = 0; } } /* Protect first 12 out of first 16 excitation bits with (23,12) Golay Code: 0,1,2,3: v[0]..v[1] 4,5,6,7: MSB of pitch 11,12,13,14: MSB of energy */ data = 0; for(i=0; i<8; i++) { data <<= 1; data |= f->codec_bits[i]; } for(i=11; i<15; i++) { data <<= 1; data |= f->codec_bits[i]; } codeword1 = golay23_encode(data); /* now pack output frame with parity bits at end to make them as far apart as possible from the data they protect. Parity bits are LSB of the Golay codeword */ for(i=0; itx_bits[i] = f->codec_bits[i]; for(j=0; itx_bits[i] = (codeword1 >> (10-j)) & 0x1; } f->tx_bits[i] = 0; /* spare bit */ /* optionally overwrite with test frames */ if (f->test_frames) { fdmdv_get_test_bits(f->fdmdv, f->tx_bits); fdmdv_get_test_bits(f->fdmdv, &f->tx_bits[bits_per_modem_frame]); //fprintf(stderr, "test frames on tx\n"); } /* modulate even and odd frames */ fdmdv_mod(f->fdmdv, tx_fdm, f->tx_bits, &f->tx_sync_bit); assert(f->tx_sync_bit == 1); fdmdv_mod(f->fdmdv, &tx_fdm[FDMDV_NOM_SAMPLES_PER_FRAME], &f->tx_bits[bits_per_modem_frame], &f->tx_sync_bit); assert(f->tx_sync_bit == 0); assert(2*FDMDV_NOM_SAMPLES_PER_FRAME == f->n_nom_modem_samples); for(i=0; in_nom_modem_samples; i++) mod_out[i] = fcmult(FDMDV_SCALE, tx_fdm[i]); delete[] tx_fdm; } static void freedv_comptx_700(struct freedv *f, COMP mod_out[]) { int bit, byte, i, j, k; int bits_per_codec_frame, bits_per_modem_frame; int data_flag_index, nspare; COMP *tx_fdm = new COMP[f->n_nat_modem_samples]; bits_per_codec_frame = codec2_bits_per_frame(f->codec2); bits_per_modem_frame = COHPSK_BITS_PER_FRAME; byte = 0; for (j=0; jcodec_bits[j+i] = (f->packed_codec_bits[byte] >> bit) & 0x1; bit--; if (bit < 0) { bit = 7; byte++; } } if (bit != 7) byte++; // spare bits in frame that codec defines. Use these spare // bits/frame to send txt messages switch(f->mode) { case FREEDV_MODE_700: nspare = 2; break; case FREEDV_MODE_700B: nspare = 1; // Just one spare bit for FREEDV_MODE_700B break; case FREEDV_MODE_700C: nspare = 0; // and no spare bits for 700C atm break; default: nspare = 0; fprintf(stderr, "FreeDV::freedv_comptx_700: unknown mode default to nspare = 0"); } data_flag_index = codec2_get_spare_bit_index(f->codec2); for(k=0; knvaricode_bits) { f->codec_bits[j+data_flag_index+k] = f->tx_varicode_bits[f->varicode_bit_index++]; //fprintf(stderr, "%d %d\n", j+data_flag_index+k, f->codec_bits[j+data_flag_index+k]); f->nvaricode_bits--; } if (f->nvaricode_bits == 0) { /* get new char and encode */ char s[2]; if (f->freedv_get_next_tx_char != NULL) { s[0] = (*f->freedv_get_next_tx_char)(f->callback_state); f->nvaricode_bits = varicode_encode(f->tx_varicode_bits, s, VARICODE_MAX_BITS, 1, 1); f->varicode_bit_index = 0; } } } } /* optionally ovwerwrite the codec bits with test frames */ if (f->test_frames) { cohpsk_get_test_bits(f->cohpsk, f->codec_bits); } /* cohpsk modulator */ cohpsk_mod(f->cohpsk, tx_fdm, f->codec_bits, COHPSK_BITS_PER_FRAME); if (f->clip) cohpsk_clip(tx_fdm, COHPSK_CLIP, COHPSK_NOM_SAMPLES_PER_FRAME); for(i=0; in_nat_modem_samples; i++) mod_out[i] = fcmult(FDMDV_SCALE*NORM_PWR_COHPSK, tx_fdm[i]); i = quisk_cfInterpDecim((std::complex *)mod_out, f->n_nat_modem_samples, f->ptFilter7500to8000, 16, 15); //assert(i == f->n_nom_modem_samples); // Caution: assert fails if f->n_nat_modem_samples * 16.0 / 15.0 is not an integer delete[] tx_fdm; } /* Ok so when interleaved, we take the interleaver length of input samples, and output that many modem samples, e.g. for interleaver of length 4: record input speech 1234 freedv tx | play modem sig 1234 record modem sig 1234 freedv_rx | play output speech 1234 time axis --------->123456789012----> So a sample of input speech at time 1 is ouput at time 9. We assume the freedv_tx and freedv_rx and propogation time over channel (from when a modem signal is played at the HF tx to when it is recorded at the HF rx) is zero. The freedv tx interface ouputs n_nom_modem_samples, which a single OFDM modem frame, 112 payload bits or 4 speech codec frames. So this function must always have 1280 speech samples as input, and 1280 modem samples as output, regradless of interleaver_frames. For interleaver_frames > 1, we need to buffer samples. */ static void freedv_comptx_700d(struct freedv *f, COMP mod_out[]) { int bit, byte, i, j, k; int nspare; int data_bits_per_frame = f->ldpc->data_bits_per_frame; int bits_per_interleaved_frame = f->interleave_frames*data_bits_per_frame; uint8_t *tx_bits = new uint8_t[bits_per_interleaved_frame]; int bits_per_codec_frame = codec2_bits_per_frame(f->codec2); byte = 0; for (j=0; jpacked_codec_bits_tx[byte] >> bit) & 0x1; bit--; if (bit < 0) { bit = 7; byte++; } } if (bit != 7) byte++; } assert(byte <= f->nbyte_packed_codec_bits); // Generate Varicode txt bits. Txt bits in OFDM frame come just // after Unique Word (UW). Txt bits aren't protected by FEC, and need to be // added to each frame after interleaver as done it's thing nspare = ofdm_ntxtbits*f->interleave_frames; uint8_t *txt_bits = new uint8_t[nspare]; for(k=0; knvaricode_bits == 0) { /* get new char and encode */ char s[2]; if (f->freedv_get_next_tx_char != NULL) { s[0] = (*f->freedv_get_next_tx_char)(f->callback_state); f->nvaricode_bits = varicode_encode(f->tx_varicode_bits, s, VARICODE_MAX_BITS, 1, 1); f->varicode_bit_index = 0; } } if (f->nvaricode_bits) { txt_bits[k] = f->tx_varicode_bits[f->varicode_bit_index++]; f->nvaricode_bits--; } } /* optionally replace codec payload bits with test frames known to rx */ if (f->test_frames) { uint8_t *payload_data_bits = new uint8_t[data_bits_per_frame]; ofdm_generate_payload_data_bits(payload_data_bits, data_bits_per_frame); for (j=0; jinterleave_frames; j++) { for(i=0; i *tx_sams = new std::complex[f->interleave_frames*f->n_nat_modem_samples]; COMP asam; ofdm_ldpc_interleave_tx(f->ofdm, f->ldpc, tx_sams, tx_bits, txt_bits, f->interleave_frames, ofdm_config); for(i=0; iinterleave_frames*f->n_nat_modem_samples; i++) { asam.real = tx_sams[i].real(); asam.imag = tx_sams[i].imag(); mod_out[i] = fcmult(OFDM_AMP_SCALE*NORM_PWR_OFDM, asam); } if (f->clip) { //fprintf(stderr, "clip "); cohpsk_clip(mod_out, OFDM_CLIP, f->interleave_frames*f->n_nat_modem_samples); } delete[] tx_sams; delete[] txt_bits; delete[] tx_bits; } void freedv_comptx(struct freedv *f, COMP mod_out[], short speech_in[]) { assert(f != NULL); assert((f->mode == FREEDV_MODE_1600) || (f->mode == FREEDV_MODE_700) || (f->mode == FREEDV_MODE_700B) || (f->mode == FREEDV_MODE_700C) || (f->mode == FREEDV_MODE_2400A) || (f->mode == FREEDV_MODE_2400B) || (f->mode == FREEDV_MODE_700D)); if (f->mode == FREEDV_MODE_1600) { codec2_encode(f->codec2, f->packed_codec_bits, speech_in); freedv_comptx_fdmdv_1600(f, mod_out); } int bits_per_codec_frame = codec2_bits_per_frame(f->codec2); int bytes_per_codec_frame = (bits_per_codec_frame + 7) / 8; int i,j; /* all these modes need to pack a bunch of codec frames into one modem frame */ if ((f->mode == FREEDV_MODE_700) || (f->mode == FREEDV_MODE_700B) || (f->mode == FREEDV_MODE_700C)) { int codec_frames = f->n_codec_bits / bits_per_codec_frame; for (j=0; jcodec2, f->packed_codec_bits + j * bytes_per_codec_frame, speech_in); speech_in += codec2_samples_per_frame(f->codec2); } freedv_comptx_700(f, mod_out); } /* special treatment due to interleaver */ if (f->mode == FREEDV_MODE_700D) { int data_bits_per_frame = f->ldpc->data_bits_per_frame; int codec_frames = data_bits_per_frame / bits_per_codec_frame; //fprintf(stderr, "modem_frame_count_tx: %d dec_frames: %d bytes offset: %d\n", // f->modem_frame_count_tx, codec_frames, (f->modem_frame_count_tx*codec_frames)*bytes_per_codec_frame); /* buffer up bits until we get enough encoded bits for interleaver */ for (j=0; jcodec2, f->packed_codec_bits_tx + (f->modem_frame_count_tx*codec_frames+j)*bytes_per_codec_frame, speech_in); speech_in += codec2_samples_per_frame(f->codec2); } /* Only use extra local buffer if needed for interleave > 1 */ if (f->interleave_frames == 1) { freedv_comptx_700d(f, mod_out); } else { /* call modulate function when we have enough frames to run interleaver */ assert((f->modem_frame_count_tx >= 0) && (f->modem_frame_count_tx < f->interleave_frames)); f->modem_frame_count_tx++; if (f->modem_frame_count_tx == f->interleave_frames) { freedv_comptx_700d(f, f->mod_out); //fprintf(stderr, " calling freedv_comptx_700d()\n"); f->modem_frame_count_tx = 0; } /* output n_nom_modem_samples at a time from modulated buffer */ for(i=0; in_nat_modem_samples; i++) { mod_out[i] = f->mod_out[f->modem_frame_count_tx * f->n_nat_modem_samples+i]; } } } /* 2400 A and B are handled by the real-mode TX */ if((f->mode == FREEDV_MODE_2400A) || (f->mode == FREEDV_MODE_2400B)){ codec2_encode(f->codec2, f->packed_codec_bits, speech_in); freedv_comptx_fsk_voice(f,mod_out); } } void freedv_codectx(struct freedv *f, short mod_out[], unsigned char *packed_codec_bits) { assert(f != NULL); COMP *tx_fdm = new COMP[f->n_nom_modem_samples]; int bits_per_codec_frame; int bytes_per_codec_frame; int codec_frames; int i; bits_per_codec_frame = codec2_bits_per_frame(f->codec2); bytes_per_codec_frame = (bits_per_codec_frame + 7) / 8; codec_frames = f->n_codec_bits / bits_per_codec_frame; memcpy(f->packed_codec_bits, packed_codec_bits, bytes_per_codec_frame * codec_frames); switch(f->mode) { case FREEDV_MODE_1600: freedv_comptx_fdmdv_1600(f, tx_fdm); break; case FREEDV_MODE_700: case FREEDV_MODE_700B: case FREEDV_MODE_700C: freedv_comptx_700(f, tx_fdm); break; case FREEDV_MODE_700D: { /* special treatment due to interleaver */ int data_bits_per_frame = f->ldpc->data_bits_per_frame; int codec_frames = data_bits_per_frame / bits_per_codec_frame; int j; /* buffer up bits until we get enough encoded bits for interleaver */ for (j=0; jpacked_codec_bits_tx + (f->modem_frame_count_tx*codec_frames+j)*bytes_per_codec_frame, packed_codec_bits, bytes_per_codec_frame); packed_codec_bits += bytes_per_codec_frame; } /* call modulate function when we have enough frames to run interleaver */ assert((f->modem_frame_count_tx >= 0) && (f->modem_frame_count_tx < f->interleave_frames)); f->modem_frame_count_tx++; if (f->modem_frame_count_tx == f->interleave_frames) { freedv_comptx_700d(f, f->mod_out); f->modem_frame_count_tx = 0; } /* output n_nom_modem_samples at a time from modulated buffer */ for(i=0; in_nat_modem_samples; i++) { mod_out[i] = f->mod_out[f->modem_frame_count_tx*f->n_nat_modem_samples+i].real; } return; /* output is already real */ } case FREEDV_MODE_2400A: case FREEDV_MODE_2400B: case FREEDV_MODE_800XA: freedv_tx_fsk_voice(f, mod_out); return; /* output is already real */ } /* convert complex to real */ for(i=0; in_nom_modem_samples; i++) mod_out[i] = tx_fdm[i].real; delete[] tx_fdm; } void freedv_datatx (struct freedv *f, short mod_out[]){ assert(f != NULL); if (f->mode == FREEDV_MODE_2400A || f->mode == FREEDV_MODE_2400B || f->mode == FREEDV_MODE_800XA) { freedv_tx_fsk_data(f, mod_out); } } int freedv_data_ntxframes (struct freedv *f){ assert(f != NULL); if (f->mode == FREEDV_MODE_2400A || f->mode == FREEDV_MODE_2400B) { if (f->deframer->fdc) return freedv_data_get_n_tx_frames(f->deframer->fdc, 8); } else if (f->mode == FREEDV_MODE_800XA) { if (f->deframer->fdc) return freedv_data_get_n_tx_frames(f->deframer->fdc, 6); } return 0; } int freedv_nin(struct freedv *f) { if ((f->mode == FREEDV_MODE_700) || (f->mode == FREEDV_MODE_700B) || (f->mode == FREEDV_MODE_700C)) // For mode 700, the input rate is 8000 sps, but the modem rate is 7500 sps // For mode 700, we request a larger number of Rx samples that will be decimated to f->nin samples return (16 * f->nin + f->ptFilter8000to7500->decim_index) / 15; else return f->nin; } /*---------------------------------------------------------------------------*\ FUNCTION....: freedv_rx AUTHOR......: David Rowe DATE CREATED: 3 August 2014 Takes a frame of samples from the radio receiver, demodulates and decodes them, producing a frame of decoded speech samples. See freedv_rx.c for an example. demod_in[] is a block of received samples sampled at 8000 Hz. To account for difference in the transmit and receive sample clock frequencies, the number of demod_in[] samples is time varying. You MUST call freedv_nin() BEFORE each call to freedv_rx() and pass exactly that many samples to this function. To help set your buffer sizes, The maximum value of freedv_nin() is freedv_get_n_max_modem_samples(). freedv_rx() returns the number of output speech samples available in speech_out[], which is sampled at 8000 Hz. You should ALWAYS check the return value of freedv_rx(), and read EXACTLY that number of speech samples from speech_out[]. 1600 and 700D mode: When out of sync, the number of output speech samples returned will be freedv_nin(). When in sync to a valid FreeDV 1600 signal, the number of output speech samples will alternate between freedv_get_n_speech_samples() and 0. 700 .. 700C modes: The number of output speech samples returned will always be freedv_get_n_speech_samples(), regardless of sync. The peak level of demod_in[] is not critical, as the demod works well over a wide range of amplitude scaling. However avoid clipping (overload, or samples pinned to +/- 32767). speech_out[] will peak at just less than +/-32767. When out of sync, this function echoes the demod_in[] samples to speech_out[]. This allows the user to listen to the channel, which is useful for tuning FreeDV signals or reception of non-FreeDV signals. Setting the squelch with freedv_set_squelch_en(1) will return zero-valued samples instead. \*---------------------------------------------------------------------------*/ // short version int freedv_rx(struct freedv *f, short speech_out[], short demod_in[]) { assert(f != NULL); int i; int nin = freedv_nin(f); assert(nin <= f->n_max_modem_samples); /* FSK RX happens in real floats, so convert to those and call their demod here */ if( (f->mode == FREEDV_MODE_2400A) || (f->mode == FREEDV_MODE_2400B) || (f->mode == FREEDV_MODE_800XA) ){ float *rx_float = new float[f->n_max_modem_samples]; for(i=0; imode == FREEDV_MODE_1600) || (f->mode == FREEDV_MODE_700) || (f->mode == FREEDV_MODE_700B) || (f->mode == FREEDV_MODE_700C)) { float gain = 1.0; /* FDM RX happens with complex samps, so do that */ COMP *rx_fdm = new COMP[f->n_max_modem_samples]; for(i=0; imode == FREEDV_MODE_700D) { float gain = 2.0; /* keep levels the same as Octave simulations and C unit tests for real signals */ return freedv_shortrx(f, speech_out, demod_in, gain); } return 0; /* should never get here */ } // float input samples version int freedv_comprx_fsk(struct freedv *f, COMP demod_in[], int *valid) { /* Varicode and protocol bits */ uint8_t vc_bits[2]; uint8_t proto_bits[3]; short vc_bit; int i; int n_ascii; char ascii_out; if(f->mode == FREEDV_MODE_2400A || f->mode == FREEDV_MODE_800XA){ fsk_demod(f->fsk,(uint8_t*)f->tx_bits,demod_in); f->nin = fsk_nin(f->fsk); float EbNodB = f->fsk->stats->snr_est; /* fsk demod actually estimates Eb/No */ f->snr_est = EbNodB + 10.0*log10f(800.0/3000.0); /* so convert to SNR Rb=800, noise B=3000 */ //fprintf(stderr," %f %f\n", EbNodB, f->snr_est); } else{ /* 2400B needs real input samples */ int n = fmfsk_nin(f->fmfsk); float *demod_in_float = new float[n]; for(i=0; ifmfsk,(uint8_t*)f->tx_bits,demod_in_float); delete[] demod_in_float; f->nin = fmfsk_nin(f->fmfsk); } if(fvhff_deframe_bits(f->deframer,f->packed_codec_bits,proto_bits,vc_bits,(uint8_t*)f->tx_bits)){ /* Decode varicode text */ for(i=0; i<2; i++){ /* Note: deframe_bits spits out bits in uint8_ts while varicode_decode expects shorts */ vc_bit = vc_bits[i]; n_ascii = varicode_decode(&f->varicode_dec_states, &ascii_out, &vc_bit, 1, 1); if (n_ascii && (f->freedv_put_next_rx_char != NULL)) { (*f->freedv_put_next_rx_char)(f->callback_state, ascii_out); } } /* Pass proto bits on down if callback is present */ if( f->freedv_put_next_proto != NULL){ (*f->freedv_put_next_proto)(f->proto_callback_state,(char*)proto_bits); } *valid = 1; /* squelch if if sync but SNR too low */ if (f->squelch_en && (f->snr_est < f->snr_squelch_thresh)) { *valid = 0; } } else { /* squelch if out of sync, or echo input of squelch off */ if (f->squelch_en) *valid = 0; else *valid = -1; } f->sync = f->deframer->state; f->stats.sync = f->deframer->state; return f->n_speech_samples; } int freedv_floatrx(struct freedv *f, short speech_out[], float demod_in[]) { assert(f != NULL); int i; int nin = freedv_nin(f); assert(nin <= f->n_max_modem_samples); COMP *rx_fdm = new COMP[f->n_max_modem_samples]; for(i=0; icodec2); bytes_per_codec_frame = (bits_per_codec_frame + 7) / 8; nout = f->n_speech_samples; COMP *ademod_in = new COMP[f->nin]; for(i=0; inin; i++) ademod_in[i] = fcmult(1.0/FDMDV_SCALE, demod_in[i]); bits_per_fdmdv_frame = fdmdv_bits_per_frame(f->fdmdv); nin_prev = f->nin; fdmdv_demod(f->fdmdv, f->fdmdv_bits, &reliable_sync_bit, ademod_in, &f->nin); fdmdv_get_demod_stats(f->fdmdv, &f->stats); f->sync = f->fdmdv->sync; f->snr_est = f->stats.snr_est; if (reliable_sync_bit == 1) { f->evenframe = 1; } if (f->stats.sync) { if (f->evenframe == 0) { memcpy(f->rx_bits, f->fdmdv_bits, bits_per_fdmdv_frame*sizeof(int)); nout = 0; *valid = 0; } else { memcpy(&f->rx_bits[bits_per_fdmdv_frame], f->fdmdv_bits, bits_per_fdmdv_frame*sizeof(int)); if (f->test_frames == 0) { recd_codeword = 0; for(i=0; i<8; i++) { recd_codeword <<= 1; recd_codeword |= (f->rx_bits[i] & 0x1); } for(i=11; i<15; i++) { recd_codeword <<= 1; recd_codeword |= (f->rx_bits[i] & 0x1); } for(i=bits_per_codec_frame; irx_bits[i] & 0x1); } codeword1 = golay23_decode(recd_codeword); f->total_bit_errors += golay23_count_errors(recd_codeword, codeword1); f->total_bits += 23; //codeword1 = recd_codeword; //fprintf(stderr, "received codeword1: 0x%x decoded codeword1: 0x%x\n", recd_codeword, codeword1); for(i=0; icodec_bits[i] = f->rx_bits[i]; for(i=0; i<8; i++) { f->codec_bits[i] = (codeword1 >> (22-i)) & 0x1; } for(i=8,j=11; i<12; i++,j++) { f->codec_bits[j] = (codeword1 >> (22-i)) & 0x1; } // extract txt msg data bit ------------------------------------------------------------ data_flag_index = codec2_get_spare_bit_index(f->codec2); abit[0] = f->codec_bits[data_flag_index]; n_ascii = varicode_decode(&f->varicode_dec_states, &ascii_out, abit, 1, 1); if (n_ascii && (f->freedv_put_next_rx_char != NULL)) { (*f->freedv_put_next_rx_char)(f->callback_state, ascii_out); } // reconstruct missing bit we steal for data bit and decode speech codec2_rebuild_spare_bit(f->codec2, f->codec_bits); // pack bits, MSB received first bit = 7; byte = 0; memset(f->packed_codec_bits, 0, bytes_per_codec_frame); for(i=0; ipacked_codec_bits[byte] |= (f->codec_bits[i] << bit); bit--; if(bit < 0) { bit = 7; byte++; } } *valid = 1; } else { int test_frame_sync, bit_errors, ntest_bits, k; short *error_pattern = new short[fdmdv_error_pattern_size(f->fdmdv)]; for(k=0; k<2; k++) { /* test frames, so lets sync up to the test frames and count any errors */ fdmdv_put_test_bits(f->fdmdv, &test_frame_sync, error_pattern, &bit_errors, &ntest_bits, &f->rx_bits[k*bits_per_fdmdv_frame]); if (test_frame_sync == 1) { f->test_frame_sync_state = 1; f->test_frame_count = 0; } if (f->test_frame_sync_state) { if (f->test_frame_count == 0) { f->total_bit_errors += bit_errors; f->total_bits += ntest_bits; if (f->freedv_put_error_pattern != NULL) { (*f->freedv_put_error_pattern)(f->error_pattern_callback_state, error_pattern, fdmdv_error_pattern_size(f->fdmdv)); } } f->test_frame_count++; if (f->test_frame_count == 4) f->test_frame_count = 0; } //fprintf(stderr, "test_frame_sync: %d test_frame_sync_state: %d bit_errors: %d ntest_bits: %d\n", // test_frame_sync, f->test_frame_sync_state, bit_errors, ntest_bits); } delete[] error_pattern; } /* squelch if beneath SNR threshold or test frames enabled */ if ((f->squelch_en && (f->stats.snr_est < f->snr_squelch_thresh)) || f->test_frames) { //fprintf(stderr,"squelch %f %f !\n", f->stats.snr_est, f->snr_squelch_thresh); *valid = 0; } nout = f->n_speech_samples; } /* note this freewheels if reliable sync dissapears on bad channels */ if (f->evenframe) f->evenframe = 0; else f->evenframe = 1; //fprintf(stderr,"%d\n", f->evenframe); } /* if (sync) .... */ else { /* if not in sync pass through analog samples */ /* this lets us "hear" whats going on, e.g. during tuning */ //fprintf(stderr, "out of sync\n"); if (f->squelch_en == 0) { *valid = -1; } else { *valid = 0; } //fprintf(stderr, "%d %d %d\n", nin_prev, speech_out[0], speech_out[nin_prev-1]); nout = nin_prev; } delete[] ademod_in; return nout; } static int freedv_comprx_700(struct freedv *f, COMP demod_in_8kHz[], int *valid) { int bits_per_codec_frame, bytes_per_codec_frame; int i, j, bit, byte, nout, k; int data_flag_index, n_ascii, nspare; short abit[1]; char ascii_out; float rx_bits[COHPSK_BITS_PER_FRAME]; /* soft decn rx bits */ int sync; int frames; bits_per_codec_frame = codec2_bits_per_frame(f->codec2); bytes_per_codec_frame = (bits_per_codec_frame + 7) / 8; frames = f->n_codec_bits / bits_per_codec_frame; nout = f->n_speech_samples; // echo samples back out as default (say if sync not found) *valid = -1; // quisk_cfInterpDecim() modifies input data so lets make a copy just in case there // is no sync and we need to echo inout to output COMP *demod_in = new COMP[freedv_nin(f)]; for(i=0; i *)demod_in, freedv_nin(f), f->ptFilter8000to7500, 15, 16); //if (i != f->nin) // printf("freedv_comprx decimation: input %d output %d\n", freedv_nin(f), i); for(i=0; inin; i++) demod_in[i] = fcmult(1.0/FDMDV_SCALE, demod_in[i]); cohpsk_demod(f->cohpsk, rx_bits, &sync, demod_in, &f->nin); f->sync = sync; cohpsk_get_demod_stats(f->cohpsk, &f->stats); f->snr_est = f->stats.snr_est; memset(f->packed_codec_bits, 0, bytes_per_codec_frame * frames); if (sync) { if (f->test_frames == 0) { data_flag_index = codec2_get_spare_bit_index(f->codec2); /* optional smoothing of codec symbols */ if (f->smooth_symbols) { for(i=0; imode) { case FREEDV_MODE_700: nspare = 2; break; case FREEDV_MODE_700B: nspare = 1; // Just one spare bit for FREEDV_MODE_700B break; case FREEDV_MODE_700C: nspare = 0; // and no spare bits for 700C atm break; default: nspare = 0; fprintf(stderr, "FreeDV::freedv_comprx_700: unknown mode default to nspare = 0"); } for(k=0; kvaricode_dec_states, &ascii_out, abit, 1, 1); if (n_ascii && (f->freedv_put_next_rx_char != NULL)) { (*f->freedv_put_next_rx_char)(f->callback_state, ascii_out); } } /* pack bits, MSB received first */ bit = 7; for(i=0; ipacked_codec_bits[byte] |= ((rx_bits[j+i] < 0.0) << bit); bit--; if (bit < 0) { bit = 7; byte++; } } if (bit != 7) byte++; if (f->squelch_en && (f->stats.snr_est < f->snr_squelch_thresh)) { *valid = 0; } *valid = 1; } nout = f->n_speech_samples; } else { //fprintf(stderr, " freedv_api: f->test_frames_diversity: %d\n", f->test_frames_diversity); if (f->test_frames_diversity) { /* normal operation - error pattern on frame after diveristy combination */ short error_pattern[COHPSK_BITS_PER_FRAME]; int bit_errors; /* test data, lets see if we can sync to the test data sequence */ char rx_bits_char[COHPSK_BITS_PER_FRAME]; for(i=0; icohpsk, &f->test_frame_sync_state, error_pattern, &bit_errors, rx_bits_char, 0); if (f->test_frame_sync_state) { f->total_bit_errors += bit_errors; f->total_bits += COHPSK_BITS_PER_FRAME; if (f->freedv_put_error_pattern != NULL) { (*f->freedv_put_error_pattern)(f->error_pattern_callback_state, error_pattern, COHPSK_BITS_PER_FRAME); } } } else { /* calculate error pattern on uncombined carriers - test mode to spot any carrier specific issues like tx passband filtering */ short error_pattern[2*COHPSK_BITS_PER_FRAME]; char rx_bits_char[COHPSK_BITS_PER_FRAME]; int bit_errors_lower, bit_errors_upper; /* lower group of carriers */ float *rx_bits_lower = cohpsk_get_rx_bits_lower(f->cohpsk); for(i=0; icohpsk, &f->test_frame_sync_state, error_pattern, &bit_errors_lower, rx_bits_char, 0); /* upper group of carriers */ float *rx_bits_upper = cohpsk_get_rx_bits_upper(f->cohpsk); for(i=0; icohpsk, &f->test_frame_sync_state_upper, &error_pattern[COHPSK_BITS_PER_FRAME], &bit_errors_upper, rx_bits_char, 1); // fprintf(stderr, " freedv_api: f->test_frame_sync_state: %d f->test_frame_sync_state_upper: %d\n", // f->test_frame_sync_state, f->test_frame_sync_state_upper); /* combine total errors and call callback */ if (f->test_frame_sync_state && f->test_frame_sync_state_upper) { f->total_bit_errors += bit_errors_lower + bit_errors_upper; f->total_bits += 2*COHPSK_BITS_PER_FRAME; if (f->freedv_put_error_pattern != NULL) { (*f->freedv_put_error_pattern)(f->error_pattern_callback_state, error_pattern, 2*COHPSK_BITS_PER_FRAME); } } } *valid = 0; nout = f->n_speech_samples; } } /* no valid FreeDV signal - squelch output */ if (sync == 0) { nout = freedv_nin(f); if (f->squelch_en) { *valid = 0; } } delete[] demod_in; return nout; } /* TODO: [X] in testframe mode count coded and uncoded errors [X] freedv getter for modem and interleaver sync [X] rms level the same as fdmdv [X] way to stay in sync and not resync automatically [X] SNR est, maybe from pilots, cohpsk have an example? [X] work out how to handle return of multiple interleaved frames over time [ ] error pattern support? [ ] deal with out of sync returning nin samples, listening to analog audio when out of sync */ static int freedv_comprx_700d(struct freedv *f, short demod_in_8kHz[], float gain, int *valid) { int bits_per_codec_frame, bytes_per_codec_frame; int i, j, bit, byte, nout, k; int n_ascii; char ascii_out; int frames; struct OFDM *ofdm = f->ofdm; struct LDPC *ldpc = f->ldpc; int data_bits_per_frame = ldpc->data_bits_per_frame; int coded_bits_per_frame = ldpc->coded_bits_per_frame; int coded_syms_per_frame = ldpc->coded_syms_per_frame; int interleave_frames = f->interleave_frames; COMP *codeword_symbols = f->codeword_symbols; float *codeword_amps = f->codeword_amps; int *rx_bits = new int[ofdm_bitsperframe]; short *txt_bits = new short[ofdm_ntxtbits]; COMP *payload_syms = new COMP[coded_syms_per_frame]; float *payload_amps = new float[coded_syms_per_frame]; bits_per_codec_frame = codec2_bits_per_frame(f->codec2); bytes_per_codec_frame = (bits_per_codec_frame + 7) / 8; frames = f->n_codec_bits / bits_per_codec_frame; // pass through is too noisey .... //nout = f->n_speech_samples; nout = 0; int Nerrs_raw = 0; int Nerrs_coded = 0; int iter = 0; int parityCheckCount = 0; uint8_t *rx_uw = new uint8_t[ofdm_nuwbits]; float new_gain = gain / OFDM_AMP_SCALE; /* echo samples back out as default (say if sync not found) */ *valid = 1; f->sync = f->stats.sync = 0; /* TODO estimate this properly from signal */ float EsNo = 3.0; /* looking for modem sync */ if (ofdm->sync_state == search) { ofdm_sync_search_shorts(f->ofdm, demod_in_8kHz, new_gain); } /* OK modem is in sync */ if ((ofdm->sync_state == synced) || (ofdm->sync_state == trial)) { ofdm_demod_shorts(ofdm, rx_bits, demod_in_8kHz, new_gain); ofdm_disassemble_modem_frame(ofdm, rx_uw, payload_syms, payload_amps, txt_bits); f->sync = 1; ofdm_get_demod_stats(f->ofdm, &f->stats); f->snr_est = f->stats.snr_est; assert((ofdm_nuwbits+ofdm_ntxtbits+coded_bits_per_frame) == ofdm_bitsperframe); /* now we need to buffer for de-interleaving -------------------------------------*/ /* shift interleaved symbol buffers to make room for new symbols */ for(i=0, j=coded_syms_per_frame; jsync_state_interleaver == synced) && (ofdm->frame_count_interleaver == interleave_frames)) { ofdm->frame_count_interleaver = 0; if (f->test_frames) { int *tmp = new int[interleave_frames]; Nerrs_raw = count_uncoded_errors(ldpc, ofdm_config, tmp, interleave_frames, codeword_symbols_de); f->total_bit_errors += Nerrs_raw; f->total_bits += ofdm_bitsperframe*interleave_frames; delete[] tmp; } memset(f->packed_codec_bits, 0, bytes_per_codec_frame * frames); byte = 0; f->modem_frame_count_rx = 0; for (j=0; jmean_amp, coded_syms_per_frame); iter = run_ldpc_decoder(ldpc, out_char, llr, &parityCheckCount); if (f->test_frames) { uint8_t *payload_data_bits = new uint8_t[data_bits_per_frame]; ofdm_generate_payload_data_bits(payload_data_bits, data_bits_per_frame); Nerrs_coded = count_errors(payload_data_bits, out_char, data_bits_per_frame); f->total_bit_errors_coded += Nerrs_coded; f->total_bits_coded += data_bits_per_frame; delete[] payload_data_bits; } else { /* a frame of valid Codec 2 bits, pack into Codec 2 frame */ for (i=0; ipacked_codec_bits[byte] |= (out_char[i+k] << bit); bit--; if (bit < 0) { bit = 7; byte++; } } if (bit != 7) byte++; } } } /* for interleave frames ... */ /* make sure we don't overrun packed byte array */ assert(byte <= f->nbyte_packed_codec_bits); nout = f->n_speech_samples; if (f->squelch_en && (f->stats.snr_est < f->snr_squelch_thresh)) { *valid = 0; } } /* if interleaver synced ..... */ /* If modem is synced we can decode txt bits */ for(k=0; kvaricode_dec_states, &ascii_out, &txt_bits[k], 1, 1); if (n_ascii && (f->freedv_put_next_rx_char != NULL)) { (*f->freedv_put_next_rx_char)(f->callback_state, ascii_out); } } /* estimate uncoded BER from UW. Coded bit errors could probably be estimated as half of all failed LDPC parity checks */ for(i=0; itx_uw[i]) { f->total_bit_errors++; } } f->total_bits += ofdm_nuwbits; delete[] out_char; delete[] llr; delete[] codeword_amps_de; delete[] codeword_symbols_de; } /* if modem synced .... */ else { *valid = -1; } /* iterate state machine and update nin for next call */ f->nin = ofdm_get_nin(ofdm); //fprintf(stderr, "nin: %d\n", ofdm_get_nin(ofdm)); ofdm_sync_state_machine(ofdm, rx_uw); if (f->verbose && (ofdm->last_sync_state == search)) { fprintf(stderr, "%3d st: %-6s euw: %2d %1d f: %5.1f ist: %-6s %2d eraw: %3d ecdd: %3d iter: %3d pcc: %3d vld: %d, nout: %4d\n", f->frames++, statemode[ofdm->last_sync_state], ofdm->uw_errors, ofdm->sync_counter, (double)ofdm->foff_est_hz, statemode[ofdm->last_sync_state_interleaver], ofdm->frame_count_interleaver, Nerrs_raw, Nerrs_coded, iter, parityCheckCount, *valid, nout); } /* no valid FreeDV signal - squelch output */ bool sync = ((ofdm->sync_state == synced) || (ofdm->sync_state == trial)); if (sync == false) { if (f->squelch_en == true) { *valid = 0; } //f->snr_est = 0.0; } //fprintf(stderr, "sync: %d valid: %d snr: %3.2f\n", f->sync, *valid, f->snr_est); delete[] rx_uw; delete[] payload_amps; delete[] payload_syms; delete[] txt_bits; delete[] rx_bits; return nout; } /* Original version for all but 700D */ int freedv_comprx(struct freedv *f, short speech_out[], COMP demod_in[]) { assert(f != NULL); int bits_per_codec_frame, bytes_per_codec_frame; int i, nout = 0; int valid = 0; assert(f->nin <= f->n_max_modem_samples); bits_per_codec_frame = codec2_bits_per_frame(f->codec2); bytes_per_codec_frame = (bits_per_codec_frame + 7) / 8; if (f->mode == FREEDV_MODE_1600) { nout = freedv_comprx_fdmdv_1600(f, demod_in, &valid); } if ((f->mode == FREEDV_MODE_700) || (f->mode == FREEDV_MODE_700B) || (f->mode == FREEDV_MODE_700C)) { nout = freedv_comprx_700(f, demod_in, &valid); } if( (f->mode == FREEDV_MODE_2400A) || (f->mode == FREEDV_MODE_2400B) || (f->mode == FREEDV_MODE_800XA)){ nout = freedv_comprx_fsk(f, demod_in, &valid); } if (valid == 0) { //fprintf(stderr, "squelch nout: %d\n", nout); /* squelch */ for (i = 0; i < nout; i++) speech_out[i] = 0; } else if (valid < 0) { /* we havent got sync so play audio from radio. This might not work for all modes due to nin bouncing about */ for (i = 0; i < nout; i++) speech_out[i] = demod_in[i].real; } else { /* decoded audio to play */ int frames = f->n_codec_bits / bits_per_codec_frame; //fprintf(stderr, "frames: %d\n", frames); for (i = 0; i < frames; i++) { codec2_decode(f->codec2, speech_out, f->packed_codec_bits + i * bytes_per_codec_frame); speech_out += codec2_samples_per_frame(f->codec2); } } //fprintf(stderr,"freedv_nin(f): %d nout: %d valid: %d\n", freedv_nin(f), nout, valid); return nout; } /* 700D version */ int freedv_shortrx(struct freedv *f, short speech_out[], short demod_in[], float gain) { assert(f != NULL); int bits_per_codec_frame, bytes_per_codec_frame; int i, nout = 0; int valid = 0; assert(f->nin <= f->n_max_modem_samples); bits_per_codec_frame = codec2_bits_per_frame(f->codec2); bytes_per_codec_frame = (bits_per_codec_frame + 7) / 8; if (f->mode == FREEDV_MODE_700D) { nout = freedv_comprx_700d(f, demod_in, gain, &valid); } if (valid == 0) { //fprintf(stderr, "squelch nout: %d\n", nout); /* squelch */ for (i = 0; i < nout; i++) speech_out[i] = 0; } else if (valid < 0) { /* we havent got sync so play audio from radio. This might not work for all modes due to nin bouncing about */ for (i = 0; i < nout; i++) speech_out[i] = demod_in[i]; } else { /* decoded audio to play */ int data_bits_per_frame = f->ldpc->data_bits_per_frame; int frames = data_bits_per_frame/bits_per_codec_frame; nout = 0; if (f->modem_frame_count_rx < f->interleave_frames) { nout = f->n_speech_samples; //fprintf(stderr, "modem_frame_count_rx: %d nout: %d\n", f->modem_frame_count_rx, nout); for (i = 0; i < frames; i++) { codec2_decode(f->codec2, speech_out, f->packed_codec_bits + (i + frames*f->modem_frame_count_rx)* bytes_per_codec_frame); speech_out += codec2_samples_per_frame(f->codec2); } f->modem_frame_count_rx++; } } return nout; } int freedv_codecrx(struct freedv *f, unsigned char *packed_codec_bits, short demod_in[]) { assert(f != NULL); int i; int nin = freedv_nin(f); int valid; int ret = 0; int bits_per_codec_frame = codec2_bits_per_frame(f->codec2); assert(nin <= f->n_max_modem_samples); if (f->mode != FREEDV_MODE_700D) { COMP *rx_fdm = new COMP[f->n_max_modem_samples]; for(i=0; imode == FREEDV_MODE_1600) { freedv_comprx_fdmdv_1600(f, rx_fdm, &valid); } if ((f->mode == FREEDV_MODE_700) || (f->mode == FREEDV_MODE_700B) || (f->mode == FREEDV_MODE_700C)) { freedv_comprx_700(f, rx_fdm, &valid); } if( (f->mode == FREEDV_MODE_2400A) || (f->mode == FREEDV_MODE_2400B) || (f->mode == FREEDV_MODE_800XA)){ freedv_comprx_fsk(f, rx_fdm, &valid); } delete[] rx_fdm; } int bytes_per_codec_frame = (bits_per_codec_frame + 7) / 8; if (f->mode == FREEDV_MODE_700D) { freedv_comprx_700d(f, demod_in, 1.0, &valid); int data_bits_per_frame = f->ldpc->data_bits_per_frame; int frames = data_bits_per_frame/bits_per_codec_frame; if (valid == 1 && f->modem_frame_count_rx < f->interleave_frames) { for (i = 0; i < frames; i++) { memcpy(packed_codec_bits, f->packed_codec_bits + (i + frames*f->modem_frame_count_rx)* bytes_per_codec_frame, bytes_per_codec_frame); packed_codec_bits += bytes_per_codec_frame; ret += bytes_per_codec_frame; } f->modem_frame_count_rx++; } return ret; } if (valid == 1) { int codec_frames = f->n_codec_bits / bits_per_codec_frame; memcpy(packed_codec_bits, f->packed_codec_bits, bytes_per_codec_frame * codec_frames); ret = bytes_per_codec_frame * codec_frames; } return ret; } /*---------------------------------------------------------------------------*\ FUNCTION....: freedv_get_version AUTHOR......: Jim Ahlstrom DATE CREATED: 28 July 2015 Return the version of the FreeDV API. This is meant to help API users determine when incompatible changes have occurred. \*---------------------------------------------------------------------------*/ int freedv_get_version(void) { return VERSION; } /*---------------------------------------------------------------------------*\ FUNCTION....: freedv_set_callback_txt AUTHOR......: Jim Ahlstrom DATE CREATED: 28 July 2015 Set the callback functions and the callback state pointer that will be used for the aux txt channel. The freedv_callback_rx is a function pointer that will be called to return received characters. The freedv_callback_tx is a function pointer that will be called to send transmitted characters. The callback state is a user-defined void pointer that will be passed to the callback functions. Any or all can be NULL, and the default is all NULL. The function signatures are: void receive_char(void *callback_state, char c); char transmit_char(void *callback_state); \*---------------------------------------------------------------------------*/ void freedv_set_callback_txt(struct freedv *f, freedv_callback_rx rx, freedv_callback_tx tx, void *state) { if (f->mode != FREEDV_MODE_800XA) { f->freedv_put_next_rx_char = rx; f->freedv_get_next_tx_char = tx; f->callback_state = state; } } /*---------------------------------------------------------------------------*\ FUNCTION....: freedv_set_callback_protocol AUTHOR......: Brady OBrien DATE CREATED: 21 February 2016 Set the callback functions and callback pointer that will be used for the protocol data channel. freedv_callback_protorx will be called when a frame containing protocol data arrives. freedv_callback_prototx will be called when a frame containing protocol information is being generated. Protocol information is intended to be used to develop protocols and fancy features atop VHF freedv, much like those present in DMR. Protocol bits are to be passed in an msb-first char array The number of protocol bits are findable with freedv_get_protocol_bits \*---------------------------------------------------------------------------*/ void freedv_set_callback_protocol(struct freedv *f, freedv_callback_protorx rx, freedv_callback_prototx tx, void *callback_state){ if (f->mode != FREEDV_MODE_800XA) { f->freedv_put_next_proto = rx; f->freedv_get_next_proto = tx; f->proto_callback_state = callback_state; } } /*---------------------------------------------------------------------------*\ FUNCTION....: freedv_set_callback_datarx / freedv_set_callback_datatx AUTHOR......: Jeroen Vreeken DATE CREATED: 04 March 2016 Set the callback functions and callback pointer that will be used for the data channel. freedv_callback_datarx will be called when a packet has been successfully received. freedv_callback_data_tx will be called when transmission of a new packet can begin. If the returned size of the datatx callback is zero the data frame is still generated, but will contain only a header update. \*---------------------------------------------------------------------------*/ void freedv_set_callback_data(struct freedv *f, freedv_callback_datarx datarx, freedv_callback_datatx datatx, void *callback_state) { if ((f->mode == FREEDV_MODE_2400A) || (f->mode == FREEDV_MODE_2400B) || (f->mode == FREEDV_MODE_800XA)){ if (!f->deframer->fdc) f->deframer->fdc = freedv_data_channel_create(); if (!f->deframer->fdc) return; freedv_data_set_cb_rx(f->deframer->fdc, datarx, callback_state); freedv_data_set_cb_tx(f->deframer->fdc, datatx, callback_state); } } /*---------------------------------------------------------------------------*\ FUNCTION....: freedv_set_data_header AUTHOR......: Jeroen Vreeken DATE CREATED: 04 March 2016 Set the data header for the data channel. Header compression will be used whenever packets from this header are sent. The header will also be used for fill packets when a data frame is requested without a packet available. \*---------------------------------------------------------------------------*/ void freedv_set_data_header(struct freedv *f, unsigned char *header) { if ((f->mode == FREEDV_MODE_2400A) || (f->mode == FREEDV_MODE_2400B) || (f->mode == FREEDV_MODE_800XA)){ if (!f->deframer->fdc) f->deframer->fdc = freedv_data_channel_create(); if (!f->deframer->fdc) return; freedv_data_set_header(f->deframer->fdc, header); } } /*---------------------------------------------------------------------------*\ FUNCTION....: freedv_get_modem_stats AUTHOR......: Jim Ahlstrom DATE CREATED: 28 July 2015 Return data from the modem. The arguments are pointers to the data items. The pointers can be NULL if the data item is not wanted. \*---------------------------------------------------------------------------*/ void freedv_get_modem_stats(struct freedv *f, int *sync, float *snr_est) { if (f->mode == FREEDV_MODE_1600) fdmdv_get_demod_stats(f->fdmdv, &f->stats); if ((f->mode == FREEDV_MODE_700) || (f->mode == FREEDV_MODE_700B) || (f->mode == FREEDV_MODE_700C)) cohpsk_get_demod_stats(f->cohpsk, &f->stats); if (f->mode == FREEDV_MODE_700D) { ofdm_get_demod_stats(f->ofdm, &f->stats); } if (f->mode == FREEDV_MODE_2400B) { fmfsk_get_demod_stats(f->fmfsk, &f->stats); } if (sync) *sync = f->stats.sync; if (snr_est) *snr_est = f->stats.snr_est; } /*---------------------------------------------------------------------------*\ FUNCTIONS...: freedv_set_* AUTHOR......: Jim Ahlstrom DATE CREATED: 28 July 2015 Set some parameters used by FreeDV. It is possible to write a macro using ## for this, but I wasn't sure it would be 100% portable. \*---------------------------------------------------------------------------*/ // Set integers void freedv_set_test_frames (struct freedv *f, int val) {f->test_frames = val;} void freedv_set_test_frames_diversity (struct freedv *f, int val) {f->test_frames_diversity = val;} void freedv_set_squelch_en (struct freedv *f, int val) {f->squelch_en = val;} void freedv_set_total_bit_errors (struct freedv *f, int val) {f->total_bit_errors = val;} void freedv_set_total_bits (struct freedv *f, int val) {f->total_bits = val;} void freedv_set_total_bit_errors_coded (struct freedv *f, int val) {f->total_bit_errors_coded = val;} void freedv_set_total_bits_coded (struct freedv *f, int val) {f->total_bits_coded = val;} void freedv_set_clip (struct freedv *f, int val) {f->clip = val;} void freedv_set_varicode_code_num (struct freedv *f, int val) {varicode_set_code_num(&f->varicode_dec_states, val);} void freedv_set_ext_vco (struct freedv *f, int val) {f->ext_vco = val;} /* Band Pass Filter to cleanup OFDM tx waveform, only supported by FreeDV 700D */ void freedv_set_tx_bpf(struct freedv *f, int val) { if (f->mode == FREEDV_MODE_700D) { ofdm_set_tx_bpf(f->ofdm, val); } } void freedv_set_verbose(struct freedv *f, int verbosity) { f->verbose = verbosity; if (f->mode == FREEDV_MODE_700D) { ofdm_set_verbose(f->ofdm, f->verbose); } } // Set floats void freedv_set_snr_squelch_thresh (struct freedv *f, float val) {f->snr_squelch_thresh = val;} void freedv_set_callback_error_pattern (struct freedv *f, freedv_calback_error_pattern cb, void *state) { f->freedv_put_error_pattern = cb; f->error_pattern_callback_state = state; } void freedv_set_carrier_ampl(struct freedv *freedv, int c, float ampl) { assert(freedv->mode == FREEDV_MODE_700C); cohpsk_set_carrier_ampl(freedv->cohpsk, c, ampl); } /*---------------------------------------------------------------------------*\ FUNCTIONS...: freedv_set_alt_modem_samp_rate AUTHOR......: Brady O'Brien DATE CREATED: 25 June 2016 Attempt to set the alternative sample rate on the modem side of the api. Only a few alternative sample rates are supported. Please see below. 2400A - 48000, 96000 2400B - 48000, 96000 TODO: Implement 2400B rate changing, allow other rate changing. \*---------------------------------------------------------------------------*/ int freedv_set_alt_modem_samp_rate(struct freedv *f, int samp_rate){ if(f->mode == FREEDV_MODE_2400A){ if(samp_rate == 24000 || samp_rate == 48000 || samp_rate == 96000){ fsk_destroy(f->fsk); f->fsk = fsk_create_hbr(samp_rate,1200,10,4,1200,1200); free(f->tx_bits); /* Note: fsk expects tx/rx bits as an array of uint8_ts, not ints */ f->tx_bits = (int*) malloc(f->fsk->Nbits*sizeof(uint8_t)); f->n_nom_modem_samples = f->fsk->N; f->n_max_modem_samples = f->fsk->N + (f->fsk->Ts); f->n_nat_modem_samples = f->fsk->N; f->nin = fsk_nin(f->fsk); f->modem_sample_rate = samp_rate; return 0; }else return -1; }else if(f->mode == FREEDV_MODE_2400B){ if(samp_rate == 48000 || samp_rate == 96000){ return -1; }else return -1; } return -1; } /*---------------------------------------------------------------------------* \ FUNCTIONS...: freedv_set_sync AUTHOR......: David Rowe DATE CREATED: May 2018 Extended control of sync state machines, especially for FreeDV 700D. This mode is required to acquire sync up at very low SNRS. This is difficult to implement, for example we may get a false sync, or the state machine may fall out of sync by mistake during a long fade. So with this API call we allow some operator assistance. Ensure this is called inthe same thread as freedv_rx(). \*---------------------------------------------------------------------------*/ void freedv_set_sync(struct freedv *freedv, Sync sync_cmd) { assert (freedv != NULL); if (freedv->mode == FREEDV_MODE_700D) { ofdm_set_sync(freedv->ofdm, sync_cmd); } } struct FSK * freedv_get_fsk(struct freedv *f){ return f->fsk; } /*---------------------------------------------------------------------------*\ FUNCTIONS...: freedv_get_* AUTHOR......: Jim Ahlstrom DATE CREATED: 28 July 2015 Get some parameters from FreeDV. It is possible to write a macro using ## for this, but I wasn't sure it would be 100% portable. \*---------------------------------------------------------------------------*/ // Get integers int freedv_get_protocol_bits (struct freedv *f) {return f->n_protocol_bits;} int freedv_get_mode (struct freedv *f) {return f->mode;} int freedv_get_test_frames (struct freedv *f) {return f->test_frames;} int freedv_get_n_speech_samples (struct freedv *f) {return f->n_speech_samples;} int freedv_get_modem_sample_rate (struct freedv *f) {return f->modem_sample_rate;} int freedv_get_modem_symbol_rate (struct freedv *f) {return f->modem_symbol_rate;} int freedv_get_n_max_modem_samples (struct freedv *f) {return f->n_max_modem_samples;} int freedv_get_n_nom_modem_samples (struct freedv *f) {return f->n_nom_modem_samples;} int freedv_get_total_bits (struct freedv *f) {return f->total_bits;} int freedv_get_total_bit_errors (struct freedv *f) {return f->total_bit_errors;} int freedv_get_total_bits_coded (struct freedv *f) {return f->total_bits_coded;} int freedv_get_total_bit_errors_coded (struct freedv *f) {return f->total_bit_errors_coded;} int freedv_get_sync (struct freedv *f) {return f->stats.sync;} int freedv_get_sync_interleaver(struct freedv *f) { if (f->mode == FREEDV_MODE_700D) { return f->ofdm->sync_state_interleaver == synced; } return 0; } int freedv_get_sz_error_pattern(struct freedv *f) { if ((f->mode == FREEDV_MODE_700) || (f->mode == FREEDV_MODE_700B) || (f->mode == FREEDV_MODE_700C)) { /* if diversity disabled callback sends error pattern for upper and lower carriers */ return f->sz_error_pattern * (2 - f->test_frames_diversity); } else { return f->sz_error_pattern; } } // Get floats struct CODEC2 *freedv_get_codec2 (struct freedv *f){return f->codec2;} int freedv_get_n_codec_bits (struct freedv *f){return f->n_codec_bits;} // Get modem status void freedv_get_modem_extended_stats(struct freedv *f, struct MODEM_STATS *stats) { if (f->mode == FREEDV_MODE_1600) fdmdv_get_demod_stats(f->fdmdv, stats); if ((f->mode == FREEDV_MODE_2400A) || (f->mode == FREEDV_MODE_800XA)) { fsk_get_demod_stats(f->fsk, stats); float EbNodB = stats->snr_est; /* fsk demod actually estimates Eb/No */ stats->snr_est = EbNodB + 10.0*log10f(800.0/3000.0); /* so convert to SNR Rb=800, noise B=3000 */ } if (f->mode == FREEDV_MODE_2400B) { fmfsk_get_demod_stats(f->fmfsk, stats); } if ((f->mode == FREEDV_MODE_700) || (f->mode == FREEDV_MODE_700B) || (f->mode == FREEDV_MODE_700C)) { cohpsk_get_demod_stats(f->cohpsk, stats); } if (f->mode == FREEDV_MODE_700D) { ofdm_get_demod_stats(f->ofdm, stats); } } } // FreeDV