scrape/quisk-kc4upr
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
a7975ab23f
quisk-kc4upr/quisk.h

421 lines
18 KiB
C
Executable File
Raw Blame History

#define DEBUG_IO 0
#define DEBUG_MIC 0
// Sound parameters
//
#define QUISK_SC_SIZE 128
#define QUISK_PATH_SIZE 256 // max file path length
#define IP_SIZE 32
#define MAX_FILTER_SIZE 10001
#define BIG_VOLUME 2.2e9
#define CLOSED_TEXT "The sound device is closed."
#define CLIP32 2147483647
#define CLIP16 32767
#define SAMP_BUFFER_SIZE 66000 // size of arrays used to capture samples
#define IMD_TONE_1 1200 // frequency of IMD test tones
#define IMD_TONE_2 1600
#define INTERP_FILTER_TAPS 85 // interpolation filter
#define MIC_OUT_RATE 48000 // mic post-processing sample rate
#define PA_LIST_SIZE 16 // max number of pulseaudio devices
#define QUISK_MAX_RECEIVERS 9 // max number of receiver channels
// Test the audio: 0 == No test; normal operation;
// 1 == Copy real data to the output; 2 == copy imaginary data to the output;
// 3 == Copy transmit audio to the output.
#define TEST_AUDIO 0
#ifdef MS_WINDOWS
#define QUISK_SHUT_RD SD_RECEIVE
#define QUISK_SHUT_BOTH SD_BOTH
#else
#define SOCKET int
#define INVALID_SOCKET -1
#define QUISK_SHUT_RD SHUT_RD
#define QUISK_SHUT_BOTH SHUT_RDWR
#endif
#if PY_MAJOR_VERSION >= 3
#define PyInt_FromLong PyLong_FromLong
#define PyInt_Check PyLong_Check
#define PyInt_AsLong PyLong_AsLong
#define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask
#endif
#define PyString_FromString PyUnicode_FromString
typedef enum _rx_mode {
CWL = 0,
CWU = 1,
LSB = 2,
USB = 3,
AM = 4,
FM = 5,
EXT = 6,
DGT_U = 7,
DGT_L = 8,
DGT_IQ = 9,
IMD = 10,
FDV_U = 11,
FDV_L = 12,
DGT_FM = 13
} rx_mode_type;
// Pulseaudio support added by Philip G. Lee. Many thanks!
/*!
* \brief Specifies which driver a \c sound_dev is opened with
*/
typedef enum dev_driver{
DEV_DRIVER_NONE = 0,
DEV_DRIVER_PORTAUDIO,
DEV_DRIVER_ALSA,
DEV_DRIVER_PULSEAUDIO
} dev_driver_t;
struct sound_dev { // data for sound capture or playback device
char name[QUISK_SC_SIZE]; // string name of device
char stream_description[QUISK_SC_SIZE]; // Short description of device/stream
void * handle; // Handle of open device, or NULL
dev_driver_t driver; // Which audio driver the device is using
void * buffer; // Handle of buffer for device
int portaudio_index; // index of portaudio device, or -1
int doAmplPhase; // Amplitude and Phase corrections
double AmPhAAAA;
double AmPhCCCC;
double AmPhDDDD;
double portaudio_latency; // Suggested latency for portaudio device
int sample_rate; // Sample rate such as 48000, 96000, 192000
int sample_bytes; // Size of one channel sample in bytes, either 2 or 3 or 4
int num_channels; // number of channels per frame: 1, 2, 3, ...
int channel_I; // Index of I and Q channels: 0, 1, ...
int channel_Q;
int channel_Delay; // Delay this channel by one sample; -1 for no delay, else channel_I or _Q
int overrange; // Count for ADC overrange (clip) for device
// Number of frames for a read request.
// If 0, the read should be non-blocking and read all available
// frames.
int read_frames;
int latency_frames; // desired latency in audio play samples
int play_buf_size; // size of playback buffer in samples
int use_float; // DirectX: Use IEEE floating point
int dataPos; // DirectX: data position
int oldPlayPos; // DirectX: previous value of playPos
int play_delay; // DirectX: bytes of sound available to play
int started; // DirectX: started flag or state
int dev_error; // read or write error
int dev_underrun; // lack of samples to play
int dev_latency; // latency frames
unsigned int rate_min; // min and max available sample rates
unsigned int rate_max;
unsigned int chan_min; // min and max available number of channels
unsigned int chan_max;
complex double dc_remove; // filter to remove DC from samples
double save_sample; // Used to delay the I or Q sample
char msg1[QUISK_SC_SIZE]; // string for information message
int stream_dir_record; // 1 for recording, 0 for playback
char server[IP_SIZE]; // server string for remote pulseaudio
int stream_format; // format of pulseaudio device
int pulse_stream_state; // state of the pulseaudio stream
volatile int cork_status; // 1 for corked, 0 for uncorked
double average_square; // average of squared sample magnitude
} ;
struct sound_conf {
char dev_capt_name[QUISK_SC_SIZE];
char dev_play_name[QUISK_SC_SIZE];
int sample_rate; // Input sample rate from the ADC
int playback_rate; // Output play rate to sound card
int data_poll_usec;
int latency_millisecs;
unsigned int rate_min;
unsigned int rate_max;
unsigned int chan_min;
unsigned int chan_max;
int read_error;
int write_error;
int underrun_error;
int overrange; // count of ADC overrange (clip) for non-soundcard device
int latencyCapt;
int latencyPlay;
int interupts;
char msg1[QUISK_SC_SIZE];
char err_msg[QUISK_SC_SIZE];
// These parameters are for the microphone:
char mic_dev_name[QUISK_SC_SIZE]; // capture device
char name_of_mic_play[QUISK_SC_SIZE]; // playback device
char mic_ip[IP_SIZE];
int mic_sample_rate; // capture sample rate
int mic_playback_rate; // playback sample rate
int tx_audio_port;
int mic_read_error;
int mic_channel_I; // channel number for microphone: 0, 1, ...
int mic_channel_Q;
double mic_out_volume;
char IQ_server[IP_SIZE]; //IP address of optional streaming IQ server (pulseaudio)
int verbose_pulse; //verbose output for pulse audio
} ;
enum quisk_rec_state {
IDLE,
RECORD_RADIO,
RECORD_MIC,
PLAYBACK,
PLAY_FILE,
PLAY_SAMPLES } ;
extern enum quisk_rec_state quisk_record_state;
struct QuiskWav { // data to create a WAV or RAW audio file
double scale;
int sample_rate;
short format; // RAW is 0; PCM integer is 1; IEEE float is 3.
short nChan;
short bytes_per_sample;
FILE * fp;
unsigned int samples;
int fpStart;
int fpEnd;
int fpPos;
} ;
void QuiskWavClose(struct QuiskWav *);
int QuiskWavWriteOpen(struct QuiskWav *, char *, short, short, short, int, double);
void QuiskWavWriteC(struct QuiskWav *, complex double *, int);
void QuiskWavWriteD(struct QuiskWav *, double *, int);
int QuiskWavReadOpen(struct QuiskWav *, char *, short, short, short, int, double);
void QuiskWavReadC(struct QuiskWav *, complex double *, int);
void QuiskWavReadD(struct QuiskWav *, double *, int);
void QuiskMeasureRate(const char *, int);
extern struct sound_conf quisk_sound_state, * pt_quisk_sound_state;
extern int mic_max_display; // display value of maximum microphone signal level
extern int quiskSpotLevel; // 0 for no spotting; else the level 10 to 1000
extern int data_width;
extern int quisk_using_udp; // is a UDP port used for capture (0 or 1)?
extern int quisk_rx_udp_started; // have we received any data?
extern rx_mode_type rxMode; // mode CWL, USB, etc.
extern int quisk_tx_tune_freq; // Transmit tuning frequency as +/- sample_rate / 2
extern PyObject * quisk_pyConfig; // Configuration module instance
extern double quisk_mic_preemphasis; // Mic preemphasis 0.0 to 1.0; or -1.0
extern double quisk_mic_clip; // Mic clipping; try 3.0 or 4.0
extern int quisk_noise_blanker; // Noise blanker level, 0 for off
extern int quisk_sidetoneCtrl; // sidetone control value 0 to 1000
extern int quiskKeyupDelay; // key-up delay from the config file
extern double quisk_audioVolume; // volume control for radio sound playback, 0.0 to 1.0
extern int quiskImdLevel; // level for rxMode IMD
extern int quiskTxHoldState; // state machine for Tx wait for repeater frequency shift
extern double quisk_ctcss_freq; // frequency in Hertz
extern unsigned char quisk_pc_to_hermes[17 * 4]; // Data to send from the PC to the Hermes hardware
extern unsigned char quisk_hermeslite_writequeue[4 * 5]; // One-time writes to Hermes-Lite
extern unsigned int quisk_hermeslite_writepointer; // write pointer into write queue, nonzero value triggers writes,
extern unsigned int quisk_hermeslite_writeattempts; // counter for write retries
extern unsigned int quisk_hermes_code_version; // Hermes code version from Hermes to PC
extern unsigned int quisk_hermes_board_id; // Hermes board ID from Hermes to PC
extern int quisk_use_rx_udp; // Method of access to UDP hardware
extern complex double cRxFilterOut(complex double, int, int);
extern int quisk_multirx_count; // number of additional receivers zero or 1, 2, 3, ..
extern struct sound_dev quisk_DigitalRx1Output; // Output sound device for sub-receiver 1
extern int quisk_is_vna; // is this the VNA program?
extern PyObject * quisk_set_spot_level(PyObject * , PyObject *);
extern PyObject * quisk_get_tx_filter(PyObject * , PyObject *);
extern PyObject * quisk_set_ampl_phase(PyObject * , PyObject *);
extern PyObject * quisk_capt_channels(PyObject * , PyObject *);
extern PyObject * quisk_play_channels(PyObject * , PyObject *);
extern PyObject * quisk_micplay_channels(PyObject * , PyObject *);
extern PyObject * quisk_sound_devices(PyObject * , PyObject *);
extern PyObject * quisk_pa_sound_devices(PyObject * , PyObject *);
extern PyObject * quisk_sound_errors(PyObject *, PyObject *);
extern PyObject * quisk_set_file_record(PyObject *, PyObject *);
extern PyObject * quisk_set_file_name(PyObject *, PyObject *, PyObject *);
extern PyObject * quisk_set_tx_audio(PyObject *, PyObject *, PyObject *);
extern PyObject * quisk_is_vox(PyObject *, PyObject *);
extern PyObject * quisk_set_udp_tx_correct(PyObject *, PyObject *);
extern PyObject * quisk_set_hermes_filter(PyObject *, PyObject *);
extern PyObject * quisk_set_alex_hpf(PyObject *, PyObject *);
extern PyObject * quisk_set_alex_lpf(PyObject *, PyObject *);
extern PyObject * quisk_freedv_open(PyObject *, PyObject *);
extern PyObject * quisk_freedv_close(PyObject *, PyObject *);
extern PyObject * quisk_freedv_get_snr(PyObject *, PyObject *);
extern PyObject * quisk_freedv_get_version(PyObject *, PyObject *);
extern PyObject * quisk_freedv_get_rx_char(PyObject *, PyObject *);
extern PyObject * quisk_freedv_set_options(PyObject *, PyObject *, PyObject *);
extern PyObject * quisk_set_sparams(PyObject *, PyObject *, PyObject *);
// These function pointers are the Start/Stop/Read interface for
// the SDR-IQ and any other C-language extension modules that return
// radio data samples.
typedef void (* ty_sample_start)(void);
typedef void (* ty_sample_stop)(void);
typedef int (* ty_sample_read)(complex double *);
typedef int (* ty_sample_write)(complex double *, int);
extern ty_sample_write quisk_pt_sample_write;
void quisk_open_sound(void);
void quisk_close_sound(void);
int quisk_process_samples(complex double *, int);
void quisk_play_samples(complex double *, int);
void quisk_play_zeros(int);
void quisk_start_sound(void);
int quisk_get_overrange(void);
void quisk_mixer_set(char *, int, PyObject *, char *, int);
int quisk_read_sound(void);
int quisk_process_microphone(int, complex double *, int);
void quisk_open_mic(void);
void quisk_close_mic(void);
int quisk_open_key(const char *);
void quisk_close_key(void);
void quisk_set_key_down(int);
void quisk_set_tx_mode(void);
void ptimer(int);
int quisk_extern_demod(complex double *, int, double);
void quisk_tmp_microphone(complex double *, int);
void quisk_tmp_record(complex double * , int, double);
void quisk_file_microphone(complex double *, int);
void quisk_file_playback(complex double *, int, double);
void quisk_tmp_playback(complex double *, int, double);
void quisk_hermes_tx_send(int, int *);
void quisk_udp_mic_error(char *);
void quisk_check_freedv_mode(void);
void quisk_calc_audio_graph(double, complex double *, double *, int, int);
int QuiskDeltaMsec(int);
#if defined(ENABLE_GPIO_KEYER)
/* KC4UPR: Define some additional functions for the GPIO Keyer. These
* allow setting various parameters for the keyer.
* mode - straight/bug, Iambic A, Iambic B
* speed - speed in words-per-minute (WPM), 1-60
* weight - dot vs dash weight, in range 33-66
* reverse - reverse left/right paddles (dot/dash by default)
* strict - enforce strict character spacing
* enabled - enable/disable the keyer
* hangtime - msecs to transmit after last CW symbol
*/
void quisk_set_gpio_keyer_mode(int);
void quisk_set_gpio_keyer_speed(int);
void quisk_set_gpio_keyer_weight(int);
void quisk_set_gpio_keyer_reversed(int);
void quisk_set_gpio_keyer_strict(int);
void quisk_set_gpio_keyer_enabled(int);
void quisk_set_gpio_keyer_hangtime(int);
#endif
// Functions supporting digital voice codecs
typedef int (* ty_dvoice_codec_rx)(complex double *, double *, int, int);
typedef int (* ty_dvoice_codec_tx)(complex double *, double *, int);
extern ty_dvoice_codec_rx pt_quisk_freedv_rx;
extern ty_dvoice_codec_tx pt_quisk_freedv_tx;
// Driver function definitions=================================================
int quisk_read_alsa(struct sound_dev *, complex double *);
void quisk_play_alsa(struct sound_dev *, int, complex double *, int, double);
void quisk_start_sound_alsa(struct sound_dev **, struct sound_dev **);
void quisk_close_sound_alsa(struct sound_dev **, struct sound_dev **);
int quisk_read_portaudio(struct sound_dev *, complex double *);
void quisk_play_portaudio(struct sound_dev *, int, complex double *, int, double);
void quisk_start_sound_portaudio(struct sound_dev **, struct sound_dev **);
void quisk_close_sound_portaudio(void);
void play_sound_interface(struct sound_dev * , int, complex double * , int, double);
int quisk_read_pulseaudio(struct sound_dev *, complex double *);
void quisk_play_pulseaudio(struct sound_dev *, int, complex double *, int, double);
void quisk_start_sound_pulseaudio(struct sound_dev **, struct sound_dev **);
void quisk_close_sound_pulseaudio(void);
void quisk_cork_pulseaudio(struct sound_dev *, int);
void quisk_flush_pulseaudio(struct sound_dev *);
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/*
Functions defined below this point are available for export to other extension modules using the
standard Python CObject or Capsule interface. See the documentation in import_quisk_api.c. Note
that index zero is used for a structure pointer, not a function pointer.
To add a function, declare it twice, use the next array index, and add it to QUISK_API_INIT.
Be very careful; here be dragons!
*/
#ifdef IMPORT_QUISK_API
// For use by modules that import the _quisk symbols
extern void ** Quisk_API; // array of pointers to functions and variables from module _quisk
int import_quisk_api(void); // used to initialize Quisk_API
#define QuiskGetConfigInt (*( int (*) (const char *, int) )Quisk_API[1])
#define QuiskGetConfigDouble (*( double (*) (const char *, double) )Quisk_API[2])
#define QuiskGetConfigString (*( char * (*) (const char *, char *) )Quisk_API[3])
#define QuiskTimeSec (*( double (*) (void) )Quisk_API[4])
#define QuiskSleepMicrosec (*( void (*) (int) )Quisk_API[5])
#define QuiskPrintTime (*( void (*) (const char *, int) )Quisk_API[6])
#define quisk_sample_source (*( void (*) (ty_sample_start, ty_sample_stop, ty_sample_read) )Quisk_API[7])
#define quisk_dvoice_freedv (*( void (*) (ty_dvoice_codec_rx, ty_dvoice_codec_tx) )Quisk_API[8])
#define quisk_is_key_down (*( int (*) (void) )Quisk_API[9])
#define quisk_sample_source4 (*( void (*) (ty_sample_start, ty_sample_stop, ty_sample_read, ty_sample_write) )Quisk_API[10])
//#if defined(ENABLE_GPIO_KEYER)
/* KC4UPR: Provide API definitions for the GPIO Keyer functions.
* However... since this doesn't seem to be required for various other
* functions that are accessible from Python, I've commented it all out,
* since in truth I really don't know what it's for/how to use it.
*/
//#define quisk_set_gpio_keyer_mode (*( void (*) (int) )Quisk_API[11])
//#define quisk_set_gpio_keyer_speed (*( void (*) (int) )Quisk_API[12])
//#define quisk_set_gpio_keyer_weight (*( void (*) (int) )Quisk_API[13])
//#define quisk_set_gpio_keyer_reversed (*( void (*) (int) )Quisk_API[14])
//#define quisk_set_gpio_keyer_strict (*( void (*) (int) )Quisk_API[15])
//#define quisk_set_gpio_keyer_enabled (*( void (*) (int) )Quisk_API[16])
//#define quisk_set_gpio_keyer_hangtime (*( void (*) (int) )Quisk_API[17])
//#endif
#else
// Used to export symbols from _quisk in quisk.c
int QuiskGetConfigInt(const char *, int);
double QuiskGetConfigDouble(const char *, double);
char * QuiskGetConfigString(const char *, char *);
double QuiskTimeSec(void);
void QuiskSleepMicrosec(int);
void QuiskPrintTime(const char *, int);
void quisk_sample_source(ty_sample_start, ty_sample_stop, ty_sample_read);
void quisk_dvoice_freedv(ty_dvoice_codec_rx, ty_dvoice_codec_tx);
int quisk_is_key_down(void);
void quisk_sample_source4(ty_sample_start, ty_sample_stop, ty_sample_read, ty_sample_write);
//#if defined(ENABLE_GPIO_KEYER)
/* KC4UPR: Provide API definitions for the GPIO Keyer functions.
* However... since this doesn't seem to be required for various other
* functions that are accessible from Python, I've commented it all out,
* since in truth I really don't know what it's for/how to use it.
*/
//void quisk_set_gpio_keyer_mode(int);
//void quisk_set_gpio_keyer_speed(int);
//void quisk_set_gpio_keyer_weight(int);
//void quisk_set_gpio_keyer_reversed(int);
//void quisk_set_gpio_keyer_strict(int);
//void quisk_set_gpio_keyer_enabled(int);
//void quisk_set_gpio_keyer_hangtime(int);
//#endif
//#if defined(ENABLE_GPIO_KEYER)
/* KC4UPR: Provide API definitions for the GPIO Keyer functions.
* However... since this doesn't seem to be required for various other
* functions that are accessible from Python, I've commented it all out,
* since in truth I really don't know what it's for/how to use it.
*/
//#define QUISK_API_INIT { \
// &quisk_sound_state, &QuiskGetConfigInt, &QuiskGetConfigDouble, &QuiskGetConfigString, &QuiskTimeSec, \
// &QuiskSleepMicrosec, &QuiskPrintTime, &quisk_sample_source, &quisk_dvoice_freedv, &quisk_is_key_down, \
// &quisk_sample_source4, &quisk_set_gpio_keyer_mode, &quisk_set_gpio_keyer_speed, \
// &quisk_set_gpio_keyer_weight, &quisk_set_gpio_keyer_reversed, &quisk_set_gpio_keyer_strict, \
// &quisk_set_gpio_keyer_enabled, &quisk_set_gpio_keyer_hangtime \
// }
//#else
#define QUISK_API_INIT { \
&quisk_sound_state, &QuiskGetConfigInt, &QuiskGetConfigDouble, &QuiskGetConfigString, &QuiskTimeSec, \
&QuiskSleepMicrosec, &QuiskPrintTime, &quisk_sample_source, &quisk_dvoice_freedv, &quisk_is_key_down, \
&quisk_sample_source4 \
}
//#endif
#endif
Reference in New Issue View Git Blame Copy Permalink