/*---------------------------------------------------------------------------*\
FILE........: freedv_data_raw_tx.c
AUTHOR......: David Rowe
DATE CREATED: May 2020
Demonstrates transmitting frames of raw data bytes (instead of
compressed speech) using the FreeDV API.
\*---------------------------------------------------------------------------*/
/*
Copyright (C) 2020 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 <http://www.gnu.org/licenses/>.
*/
#include <assert.h>
#include <errno.h>
#include <getopt.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "freedv_api.h"
#include "fsk.h"
#include "ldpc_codes.h"
#include "ofdm_internal.h"
size_t send_preamble(struct freedv *freedv, FILE *fout, int use_complex,
size_t n_mod_out);
size_t send_modulated_data(struct freedv *freedv, FILE *fout, int use_complex,
size_t n_mod_out, uint8_t bytes_in[]);
size_t send_postamble(struct freedv *freedv, FILE *fout, int use_complex,
size_t n_mod_out);
size_t send_silence(FILE *fout, size_t shorts_per_sample, size_t samples_delay);
void comp_to_short(short mod_out_short[], COMP mod_out_comp[], int n_mod_out);
int main(int argc, char *argv[]) {
FILE *fin, *fout;
char codename[80] = "H_256_512_4";
struct freedv_advanced adv = {0, 2, 100, 8000, 1000, 200, codename};
struct freedv *freedv;
int mode;
int use_clip, use_txbpf, testframes, Ntestframes = 0;
int use_complex = 0;
float amp = FSK_SCALE;
size_t shorts_per_sample = 1;
int Nbursts = 1, sequence_numbers = 0;
int inter_burst_delay_ms = 0;
int postdelay_ms = 0;
uint8_t source_byte = 0;
use_clip = -1;
use_txbpf = -1;
testframes = 0;
int framesperburst = 1;
int quiet = 0;
int o = 0;
int opt_idx = 0;
while (o != -1) {
static struct option long_opts[] = {
{"testframes", required_argument, 0, 't'},
{"help", no_argument, 0, 'h'},
{"txbpf", required_argument, 0, 'b'},
{"clip", required_argument, 0, 'l'},
{"Fs", required_argument, 0, 'f'},
{"Rs", required_argument, 0, 'r'},
{"tone1", required_argument, 0, '1'},
{"shift", required_argument, 0, 's'},
{"bursts", required_argument, 0, 'e'},
{"framesperburst", required_argument, 0, 'g'},
{"delay", required_argument, 0, 'j'},
{"postdelay", required_argument, 0, 'k'},
{"seq", no_argument, 0, 'd'},
{"source", required_argument, 0, 'i'},
{"amp", required_argument, 0, 'a'},
{"quiet", no_argument, 0, 'q'},
{"complexout", no_argument, 0, 'c'},
{"code", required_argument, 0, 'o'},
{"listcodes", no_argument, 0, 'x'},
{0, 0, 0, 0}};
o = getopt_long(argc, argv, "a:cdt:hb:l:e:f:g:r:1:s:m:qi:o:x", long_opts,
&opt_idx);
switch (o) {
case 'a':
amp = atof(optarg) / 2.0;
break;
case 'b':
use_txbpf = atoi(optarg);
break;
case 'c':
use_complex = 1;
shorts_per_sample = 2;
break;
case 'd':
sequence_numbers = 1;
break;
case 'i':
source_byte = strtol(optarg, NULL, 0);
fprintf(stderr, "source byte: 0x%02x\n", source_byte);
break;
case 'e':
Nbursts = atoi(optarg);
break;
case 'g':
framesperburst = atoi(optarg);
break;
case 'j':
inter_burst_delay_ms = atoi(optarg);
break;
case 'k':
postdelay_ms = atoi(optarg);
break;
case 't':
testframes = 1;
Ntestframes = atoi(optarg);
break;
case 'l':
use_clip = atoi(optarg);
break;
case 'm':
adv.M = atoi(optarg);
break;
case 'q':
quiet = 1;
break;
case 'f':
adv.Fs = atoi(optarg);
break;
case 'r':
adv.Rs = atoi(optarg);
break;
case '1':
adv.first_tone = atoi(optarg);
break;
case 's':
adv.tone_spacing = atoi(optarg);
break;
case 'o':
if (ldpc_codes_find(optarg) == -1) {
fprintf(stderr, "%s not found, try --listcodes\n", optarg);
exit(1);
}
strcpy(codename, optarg);
break;
case 'x':
ldpc_codes_list();
exit(0);
break;
case 'h':
case '?':
goto helpmsg;
break;
}
}
int dx = optind;
if (argc < 4) {
helpmsg:
fprintf(
stderr,
"\nusage: %s [options] FSK_LDPC|DATAC0|... InputBinaryDataFile "
"OutputModemRawFile\n"
"\n"
" --testframes T send a total of T test frames (T should "
"equal B*N)\n"
" --bursts B send B bursts of N testframes (default "
"1)\n"
" --framesperburst N burst mode, N frames per burst (default "
"1)\n"
" --delay ms testframe inter-burst delay in ms\n"
" --postdelay ms additional delay at end of run in ms\n"
" -c complex signed 16 bit output format "
"(default real)\n"
" --clip 0|1 clipping for reduced PAPR\n"
" --txbpf 0|1 bandpass filter\n"
" --seq send packet sequence numbers (breaks "
"testframe BER counting)\n"
" --source Byte insert a (non-zero) source address att "
"byte[0]\n"
" --complexout complex sample output (default real)\n"
" --quiet\n"
"\n"
"For FSK_LDPC only:\n\n"
" -a amp maximum amplitude of FSK signal\n"
" -m 2|4 number of FSK tones\n"
" --Fs FreqHz sample rate (default 8000)\n"
" --Rs FreqHz symbol rate (default 100)\n"
" --tone1 FreqHz freq of first tone (default 1000)\n"
" --shift FreqHz shift between tones (default 200)\n\n"
" --code CodeName LDPC code (defaults (512,256)\n"
" --listcodes list available LDPC codes\n\n",
argv[0]);
fprintf(stderr,
"example: $ %s --testframes 6 --bursts 3 --framesperburst 2 datac0 "
"/dev/zero samples.s16\n",
argv[0]);
fprintf(
stderr,
"example: $ %s -c --testframes 10 FSK_LDPC /dev/zero samples.iq16\n\n",
argv[0]);
exit(1);
}
if ((argc - dx) < 3) {
fprintf(stderr, "too few arguments.\n");
goto helpmsg;
}
mode = -1;
if (!strcmp(argv[dx], "FSK_LDPC") || !strcmp(argv[dx], "fsk_ldpc"))
mode = FREEDV_MODE_FSK_LDPC;
if (!strcmp(argv[dx], "DATAC0") || !strcmp(argv[dx], "datac0"))
mode = FREEDV_MODE_DATAC0;
if (!strcmp(argv[dx], "DATAC1") || !strcmp(argv[dx], "datac1"))
mode = FREEDV_MODE_DATAC1;
if (!strcmp(argv[dx], "DATAC3") || !strcmp(argv[dx], "datac3"))
mode = FREEDV_MODE_DATAC3;
if (!strcmp(argv[dx], "DATAC4") || !strcmp(argv[dx], "datac4"))
mode = FREEDV_MODE_DATAC4;
if (!strcmp(argv[dx], "DATAC13") || !strcmp(argv[dx], "datac13"))
mode = FREEDV_MODE_DATAC13;
if (!strcmp(argv[dx], "DATAC14") || !strcmp(argv[dx], "datac14"))
mode = FREEDV_MODE_DATAC14;
if (!strcmp(argv[dx], "CUSTOM") || !strcmp(argv[dx], "custom"))
mode = FREEDV_MODE_DATA_CUSTOM;
if (mode == -1) {
fprintf(stderr, "Error: in mode: %s", argv[dx]);
exit(1);
}
if (strcmp(argv[dx + 1], "-") == 0)
fin = stdin;
else if ((fin = fopen(argv[dx + 1], "rb")) == NULL) {
fprintf(stderr, "Error opening input file of bytes: %s: %s.\n",
argv[dx + 1], strerror(errno));
exit(1);
}
if (strcmp(argv[dx + 2], "-") == 0)
fout = stdout;
else if ((fout = fopen(argv[dx + 2], "wb")) == NULL) {
fprintf(stderr, "Error opening output modem sample file: %s: %s.\n",
argv[dx + 2], strerror(errno));
exit(1);
}
if (mode == FREEDV_MODE_FSK_LDPC)
freedv = freedv_open_advanced(mode, &adv);
else if (mode == FREEDV_MODE_DATA_CUSTOM) {
// demonstrate custom OFDM raw data modes
struct OFDM_CONFIG ofdm_config;
ofdm_init_mode("datac14", &ofdm_config);
// modify datac14 to have 3 carriers instead of 4, which means
// we have to tweak Np, and the number of unique word bits
ofdm_config.nc = 3;
ofdm_config.np = 6;
ofdm_config.nuwbits = 48;
ofdm_config.bad_uw_errors = 18;
uint8_t uw[] = {1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1,
0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0};
memcpy(ofdm_config.tx_uw, uw, sizeof(uw));
memcpy(&ofdm_config.tx_uw[ofdm_config.nuwbits - sizeof(uw)], uw,
sizeof(uw));
/* set up a trivial Tx band pass filter as a demo */
static float tx_bpf[] = {1.0, 1.0, 1.0};
ofdm_config.tx_bpf_proto = tx_bpf;
ofdm_config.tx_bpf_proto_n = 3;
adv.config = (void *)&ofdm_config;
freedv = freedv_open_advanced(mode, &adv);
freedv_ofdm_print_info(freedv);
} else {
freedv = freedv_open(mode);
}
assert(freedv != NULL);
/* these are optional ------------------ */
if (use_clip != -1) freedv_set_clip(freedv, use_clip);
if (use_txbpf != -1) freedv_set_tx_bpf(freedv, use_txbpf);
freedv_set_tx_amp(freedv, amp);
/* Data modes have a multiple of 8 payload bits/frame */
int bytes_per_modem_frame = freedv_get_bits_per_modem_frame(freedv) / 8;
int payload_bytes_per_modem_frame = bytes_per_modem_frame;
payload_bytes_per_modem_frame -= 2; /* 16 bits used for the CRC */
if (!quiet)
fprintf(stderr, "payload bytes_per_modem_frame: %d ",
payload_bytes_per_modem_frame);
assert((freedv_get_bits_per_modem_frame(freedv) % 8) == 0);
int n_mod_out = freedv_get_n_tx_modem_samples(freedv);
uint8_t bytes_in[bytes_per_modem_frame];
if (mode == FREEDV_MODE_FSK_LDPC) {
if (!quiet)
fprintf(stderr,
"Frequency: Fs: %4.1f Hz Rs: %5.0f Hz Tone1: %5.0f Hz Shift: "
"%5.0f Hz M: %d \n",
(float)adv.Fs, (float)adv.Rs, (float)adv.first_tone,
(float)adv.tone_spacing, adv.M);
if (adv.tone_spacing < adv.Rs) {
fprintf(stderr, "Need shift: %d > Rs: %d\n", adv.tone_spacing, adv.Rs);
exit(1);
}
}
/* a few sanity checks */
if (testframes) {
if (Ntestframes != framesperburst * Nbursts) {
if (!quiet)
fprintf(stderr,
"Adjusting testframes to equal framesperburst*bursts\n");
Ntestframes = framesperburst * Nbursts;
}
} else {
if (framesperburst != 1) {
fprintf(stderr,
"Only one frame per burst currently supported in stdin mode\n");
exit(1);
}
}
int frames = 0;
size_t on_samples = 0;
size_t off_samples = 0;
/* initial silence */
int samples_delay = 0;
if (inter_burst_delay_ms) {
/* user defined inter-burst delay */
samples_delay = FREEDV_FS_8000 * inter_burst_delay_ms / 1000;
} else {
/* just enough silence at the end of burst to allow demod to complete
* processing */
samples_delay = 2 * freedv_get_n_nom_modem_samples(freedv);
}
off_samples += send_silence(fout, shorts_per_sample, samples_delay);
/* --------- Test Frame Mode
* --------------------------------------------------*/
if (testframes) {
/* generate a fixed test frame */
uint8_t testframe_bytes[bytes_per_modem_frame];
memset(testframe_bytes, 0, bytes_per_modem_frame);
int bits_per_frame = freedv_get_bits_per_modem_frame(freedv);
uint8_t testframe_bits[bits_per_frame];
ofdm_generate_payload_data_bits(testframe_bits, bits_per_frame);
freedv_pack(testframe_bytes, testframe_bits, bits_per_frame);
if (!quiet) fprintf(stderr, "\n");
for (int b = 0; b < Nbursts; b++) {
on_samples += send_preamble(freedv, fout, use_complex, n_mod_out);
for (int fpb = 0; fpb < framesperburst; fpb++) {
memcpy(bytes_in, testframe_bytes, bytes_per_modem_frame);
if (source_byte) bytes_in[0] = source_byte;
if (sequence_numbers) bytes_in[1] = (frames + 1) & 0xff;
/* The raw data modes requires a CRC in the last two bytes */
uint16_t crc16 =
freedv_gen_crc16(bytes_in, payload_bytes_per_modem_frame);
bytes_in[bytes_per_modem_frame - 2] = crc16 >> 8;
bytes_in[bytes_per_modem_frame - 1] = crc16 & 0xff;
on_samples +=
send_modulated_data(freedv, fout, use_complex, n_mod_out, bytes_in);
/* if using pipes we don't want the usual buffering to occur */
if (fout == stdout) fflush(stdout);
frames++;
}
on_samples += send_postamble(freedv, fout, use_complex, n_mod_out);
int samples_delay = 0;
if (inter_burst_delay_ms) {
/* user defined inter-burst delay */
samples_delay = FREEDV_FS_8000 * inter_burst_delay_ms / 1000;
} else {
/* just enough silence at the end of burst to allow demod to complete
* processing */
samples_delay = 2 * freedv_get_n_nom_modem_samples(freedv);
}
off_samples += send_silence(fout, shorts_per_sample, samples_delay);
}
} else {
/* --------- modulate data from stdin mode
* --------------------------------------------------*/
while (fread(bytes_in, sizeof(uint8_t), payload_bytes_per_modem_frame,
fin) == payload_bytes_per_modem_frame) {
on_samples += send_preamble(freedv, fout, use_complex, n_mod_out);
if (source_byte) bytes_in[0] = source_byte;
if (sequence_numbers) bytes_in[1] = (frames + 1) & 0xff;
/* The raw data modes requires a CRC in the last two bytes */
uint16_t crc16 =
freedv_gen_crc16(bytes_in, payload_bytes_per_modem_frame);
bytes_in[bytes_per_modem_frame - 2] = crc16 >> 8;
bytes_in[bytes_per_modem_frame - 1] = crc16 & 0xff;
on_samples +=
send_modulated_data(freedv, fout, use_complex, n_mod_out, bytes_in);
/* if using pipes we don't want the usual buffering to occur */
if (fout == stdout) fflush(stdout);
on_samples += send_postamble(freedv, fout, use_complex, n_mod_out);
int samples_delay = 0;
if (inter_burst_delay_ms) {
/* user defined inter-burst delay */
samples_delay = FREEDV_FS_8000 * inter_burst_delay_ms / 1000;
} else {
/* just enough silence at the end of burst to allow demod to complete
* processing */
samples_delay = 2 * freedv_get_n_nom_modem_samples(freedv);
}
off_samples += send_silence(fout, shorts_per_sample, samples_delay);
frames++;
}
}
/* optional silence at the end of run */
if (postdelay_ms) {
int samples_delay = FREEDV_FS_8000 * postdelay_ms / 1000;
if (!quiet)
fprintf(stderr, "postdelay: %d %d\n", postdelay_ms, samples_delay);
off_samples += send_silence(fout, shorts_per_sample, samples_delay);
}
/* SNR offset to use in channel simulator to account for on/off time of burst
* signal */
float mark_space_ratio = (float)on_samples / (on_samples + off_samples);
float mark_space_SNR_offset = 10 * log10(mark_space_ratio);
if (!quiet)
fprintf(stderr, "mark:space: %3.2f SNR offset: %5.2f\n", mark_space_ratio,
mark_space_SNR_offset);
freedv_close(freedv);
fclose(fin);
fclose(fout);
return 0;
}
size_t send_preamble(struct freedv *freedv, FILE *fout, int use_complex,
size_t n_mod_out) {
short mod_out_short[2 * n_mod_out];
int shorts_per_sample = 1;
int n_preamble = 0;
if (use_complex == 0) {
n_preamble = freedv_rawdatapreambletx(freedv, mod_out_short);
} else {
COMP mod_out_comp[n_mod_out];
n_preamble = freedv_rawdatapreamblecomptx(freedv, mod_out_comp);
comp_to_short(mod_out_short, mod_out_comp, n_preamble);
shorts_per_sample = 2;
}
assert(n_preamble == freedv_get_n_tx_preamble_modem_samples(freedv));
assert(n_preamble <= n_mod_out);
fwrite(mod_out_short, sizeof(short), shorts_per_sample * n_preamble, fout);
return n_preamble;
}
size_t send_modulated_data(struct freedv *freedv, FILE *fout, int use_complex,
size_t n_mod_out, uint8_t bytes_in[]) {
short mod_out_short[2 * n_mod_out];
int shorts_per_sample = 1;
if (use_complex == 0) {
freedv_rawdatatx(freedv, mod_out_short, bytes_in);
} else {
COMP mod_out_comp[n_mod_out];
freedv_rawdatacomptx(freedv, mod_out_comp, bytes_in);
comp_to_short(mod_out_short, mod_out_comp, n_mod_out);
shorts_per_sample = 2;
}
fwrite(mod_out_short, sizeof(short), shorts_per_sample * n_mod_out, fout);
return n_mod_out;
}
size_t send_postamble(struct freedv *freedv, FILE *fout, int use_complex,
size_t n_mod_out) {
short mod_out_short[2 * n_mod_out];
int shorts_per_sample = 1;
int n_postamble = 0;
if (use_complex == 0) {
n_postamble = freedv_rawdatapostambletx(freedv, mod_out_short);
} else {
COMP mod_out_comp[n_mod_out];
n_postamble = freedv_rawdatapostamblecomptx(freedv, mod_out_comp);
comp_to_short(mod_out_short, mod_out_comp, n_postamble);
shorts_per_sample = 2;
}
assert(n_postamble == freedv_get_n_tx_postamble_modem_samples(freedv));
assert(n_postamble <= n_mod_out);
fwrite(mod_out_short, sizeof(short), shorts_per_sample * n_postamble, fout);
return n_postamble;
}
size_t send_silence(FILE *fout, size_t shorts_per_sample,
size_t samples_delay) {
size_t n = shorts_per_sample * samples_delay;
short sil_short[n];
for (int i = 0; i < n; i++) sil_short[i] = 0;
fwrite(sil_short, sizeof(short), n, fout);
return samples_delay;
}
void comp_to_short(short mod_out_short[], COMP mod_out_comp[], int n_mod_out) {
for (int i = 0; i < n_mod_out; i++) {
mod_out_short[2 * i] = (short)(mod_out_comp[i].real);
mod_out_short[2 * i + 1] = (short)(mod_out_comp[i].imag);
}
}
