Collaboration diagram for Transmission Sequencer:

Topics
	Transmission sequencer states

	Sequencer step types.

	Sequencer registers.

	Tone slopes

Data Structures
struct	sstvenc_sequencer

union	sstvenc_sequencer::sstvenc_sequencer_vars

struct	sstvenc_sequencer::sstvenc_sequencer_vars::sstvenc_sequencer_vars_silence

struct	sstvenc_sequencer::sstvenc_sequencer_vars::sstvenc_sequencer_vars_tone

struct	sstvenc_sequencer_step

union	sstvenc_sequencer_step::sstvenc_sequence_step_args

struct	sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_ts_unit

struct	sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_reg

struct	sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_duration

struct	sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_cw

struct	sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_image

Typedefs
typedef void	sstvenc_sequencer_event_cb(struct sstvenc_sequencer *const enc)

Functions
void	sstvenc_sequencer_step_set_timescale (struct sstvenc_sequencer_step *const step, uint8_t time_unit, _Bool convert)

void	sstvenc_sequencer_step_set_reg (struct sstvenc_sequencer_step *const step, uint8_t reg, double value)

void	sstvenc_sequencer_step_inc_reg (struct sstvenc_sequencer_step *const step, uint8_t reg, double value)

void	sstvenc_sequencer_step_dec_reg (struct sstvenc_sequencer_step *const step, uint8_t reg, double value)

void	sstvenc_sequencer_step_mul_reg (struct sstvenc_sequencer_step *const step, uint8_t reg, double value)

void	sstvenc_sequencer_step_div_reg (struct sstvenc_sequencer_step *const step, uint8_t reg, double value)

void	sstvenc_sequencer_step_idec_reg (struct sstvenc_sequencer_step *const step, uint8_t reg, double value)

void	sstvenc_sequencer_step_idiv_reg (struct sstvenc_sequencer_step *const step, uint8_t reg, double value)

void	sstvenc_sequencer_step_silence (struct sstvenc_sequencer_step *const step, double duration)

void	sstvenc_sequencer_step_tone (struct sstvenc_sequencer_step *const step, double duration, uint8_t slopes)

void	sstvenc_sequencer_step_cw (struct sstvenc_sequencer_step const step, const char text)

void	sstvenc_sequencer_step_image (struct sstvenc_sequencer_step const step, const struct sstvenc_mode const mode, const uint8_t framebuffer, const char fsk_id)

void	sstvenc_sequencer_step_end (struct sstvenc_sequencer_step *const step)

void	sstvenc_sequencer_init (struct sstvenc_sequencer const seq, const struct sstvenc_sequencer_step steps, sstvenc_sequencer_event_cb event_cb, const void event_cb_ctx, uint32_t sample_rate)

void	sstvenc_sequencer_reset (struct sstvenc_sequencer *const seq)

void	sstvenc_sequencer_advance (struct sstvenc_sequencer *const seq)

void	sstvenc_sequencer_compute (struct sstvenc_sequencer *const seq)

size_t	sstvenc_sequencer_fill_buffer (struct sstvenc_sequencer const seq, double buffer, size_t buffer_sz)

static void	sstvenc_sequencer_step_update_reg (struct sstvenc_sequencer_step *const step, uint8_t type, uint8_t reg, double value)

static void	sstvenc_sequencer_step_duration (struct sstvenc_sequencer_step *const step, uint8_t type, double duration)

static void	sstvenc_sequencer_next_step (struct sstvenc_sequencer *const seq, _Bool notify)

static void	sstvenc_sequencer_next_state (struct sstvenc_sequencer *const seq, uint8_t state, _Bool notify)

static void	sstvenc_sequencer_exec_set_ts (struct sstvenc_sequencer const seq, const struct sstvenc_sequencer_step const step)

static void	sstvenc_sequencer_exec_update_reg (struct sstvenc_sequencer const seq, const struct sstvenc_sequencer_step const step)

static void	sstvenc_sequencer_begin_silence (struct sstvenc_sequencer const seq, const struct sstvenc_sequencer_step const step)

static void	sstvenc_sequencer_begin_tone (struct sstvenc_sequencer const seq, const struct sstvenc_sequencer_step const step)

static void	sstvenc_sequencer_begin_cw (struct sstvenc_sequencer const seq, const struct sstvenc_sequencer_step const step)

static void	sstvenc_sequencer_begin_image (struct sstvenc_sequencer const seq, const struct sstvenc_sequencer_step const step)

static void	sstvenc_sequencer_end (struct sstvenc_sequencer *const seq)

static void	sstvenc_sequencer_exec_step (struct sstvenc_sequencer *const seq)

Variables
const struct sstvenc_sequencer_step *	sstvenc_sequencer::steps

sstvenc_sequencer_event_cb *	sstvenc_sequencer::event_cb

const void *	sstvenc_sequencer::event_cb_ctx

double	sstvenc_sequencer::output

uint32_t	sstvenc_sequencer::sstvenc_sequencer_vars::sstvenc_sequencer_vars_silence::remaining

struct sstvenc_sequencer::sstvenc_sequencer_vars::sstvenc_sequencer_vars_silence	sstvenc_sequencer::sstvenc_sequencer_vars::silence

struct sstvenc_oscillator	sstvenc_sequencer::sstvenc_sequencer_vars::sstvenc_sequencer_vars_tone::osc

struct sstvenc_pulseshape	sstvenc_sequencer::sstvenc_sequencer_vars::sstvenc_sequencer_vars_tone::ps

struct sstvenc_sequencer::sstvenc_sequencer_vars::sstvenc_sequencer_vars_tone	sstvenc_sequencer::sstvenc_sequencer_vars::tone

struct sstvenc_cw_mod	sstvenc_sequencer::sstvenc_sequencer_vars::cw

struct sstvenc_mod	sstvenc_sequencer::sstvenc_sequencer_vars::sstv

union sstvenc_sequencer::sstvenc_sequencer_vars	sstvenc_sequencer::vars

double	sstvenc_sequencer::regs [SSTVENC_SEQ_NUM_REGS]

uint32_t	sstvenc_sequencer::sample_rate

uint16_t	sstvenc_sequencer::step

uint8_t	sstvenc_sequencer::time_unit

uint8_t	sstvenc_sequencer::state

uint8_t	sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_ts_unit::time_unit

_Bool	sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_ts_unit::convert

struct sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_ts_unit	sstvenc_sequencer_step::sstvenc_sequence_step_args::ts

double	sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_reg::value

uint8_t	sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_reg::reg

struct sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_reg	sstvenc_sequencer_step::sstvenc_sequence_step_args::reg

double	sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_duration::duration

uint8_t	sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_duration::slopes

struct sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_duration	sstvenc_sequencer_step::sstvenc_sequence_step_args::duration

const char *	sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_cw::text

struct sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_cw	sstvenc_sequencer_step::sstvenc_sequence_step_args::cw

const struct sstvenc_mode *	sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_image::mode

const uint8_t *	sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_image::framebuffer

const char *	sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_image::fsk_id

struct sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_image	sstvenc_sequencer_step::sstvenc_sequence_step_args::image

union sstvenc_sequencer_step::sstvenc_sequence_step_args	sstvenc_sequencer_step::args

uint8_t	sstvenc_sequencer_step::type

Detailed Description

This module aids in combining a SSTV (or in fact, multiple if desired) with arbitrary tone generation and the CW modulator to enable adding of CW IDs to meet regulatory requirements and to enable triggering of VOX circuits or SSTV repeaters.

Data Structure Documentation

◆ sstvenc_sequencer

struct sstvenc_sequencer

SSTV transmission sequencer data structure. This stores a record of the sequence being transmitted and the current step.

Definition at line 333 of file sequence.h.

Collaboration diagram for sstvenc_sequencer:

[legend]

Data Fields
sstvenc_sequencer_event_cb *	event_cb	Event call-back, called on each state transition
const void *	event_cb_ctx	Optional event callback context
double	output	Output sample
double	regs[SSTVENC_SEQ_NUM_REGS]	SSTV sequencer register parameters. The indices are
uint32_t	sample_rate	Sample rate in hertz.
uint8_t	state	Sequencer state machine state, see Transmission sequencer states
uint16_t	step	The current step being executed. This is an index into sstvenc_sequencer::steps.
const struct sstvenc_sequencer_step *	steps	The list of sequence steps to be carried out.
uint8_t	time_unit	Time scale unit of measure
union sstvenc_sequencer_vars	vars

◆ sstvenc_sequencer::sstvenc_sequencer_vars

union sstvenc_sequencer::sstvenc_sequencer_vars

Sequencer state machine variables

Definition at line 347 of file sequence.h.

Collaboration diagram for sstvenc_sequencer::sstvenc_sequencer_vars:

[legend]

Data Fields
struct sstvenc_cw_mod	cw	State machine for CW transmission states.
struct sstvenc_sequencer_vars_silence	silence
struct sstvenc_mod	sstv	State machine for SSTV transmission states.
struct sstvenc_sequencer_vars_tone	tone

◆ sstvenc_sequencer::sstvenc_sequencer_vars::sstvenc_sequencer_vars_silence

struct sstvenc_sequencer::sstvenc_sequencer_vars::sstvenc_sequencer_vars_silence

State machine logic for the "silence" states.

Definition at line 351 of file sequence.h.

Collaboration diagram for sstvenc_sequencer::sstvenc_sequencer_vars::sstvenc_sequencer_vars_silence:

[legend]

Data Fields
uint32_t	remaining	Number of samples remaining of silence

◆ sstvenc_sequencer::sstvenc_sequencer_vars::sstvenc_sequencer_vars_tone

struct sstvenc_sequencer::sstvenc_sequencer_vars::sstvenc_sequencer_vars_tone

State machine for tone states.

Definition at line 359 of file sequence.h.

Collaboration diagram for sstvenc_sequencer::sstvenc_sequencer_vars::sstvenc_sequencer_vars_tone:

[legend]

Data Fields
struct sstvenc_oscillator	osc	Oscillator state machine
struct sstvenc_pulseshape	ps	Pulse Shaper state machine

◆ sstvenc_sequencer_step

struct sstvenc_sequencer_step

A sequencer step is a single instruction. Some instructions alter the current state of the state machine, others just adjust parameters.

Definition at line 404 of file sequence.h.

Collaboration diagram for sstvenc_sequencer_step:

[legend]

Data Fields
union sstvenc_sequence_step_args	args
uint8_t	type	The type of sequencer step. See Sequencer step types.

◆ sstvenc_sequencer_step::sstvenc_sequence_step_args

union sstvenc_sequencer_step::sstvenc_sequence_step_args

Definition at line 405 of file sequence.h.

Collaboration diagram for sstvenc_sequencer_step::sstvenc_sequence_step_args:

[legend]

Data Fields
struct sstvenc_sequence_step_cw	cw
struct sstvenc_sequence_step_duration	duration
struct sstvenc_sequence_step_image	image
struct sstvenc_sequence_step_set_reg	reg
struct sstvenc_sequence_step_set_ts_unit	ts

◆ sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_ts_unit

struct sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_ts_unit

Setting of the time-scale unit. sstvenc_sequencer_step::type is set to SSTVENC_SEQ_STEP_TYPE_SET_TS_UNIT.

Definition at line 410 of file sequence.h.

Collaboration diagram for sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_ts_unit:

[legend]

Data Fields
_Bool	convert	Convert fields to the new unit?
uint8_t	time_unit	The new time-scale unit

◆ sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_reg

struct sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_reg

Set a register to a new value. sstvenc_sequencer_step::type is set to one of:

Definition at line 429 of file sequence.h.

Collaboration diagram for sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_reg:

[legend]

Data Fields
uint8_t	reg	The register being updated
double	value	The new register value / operand value

◆ sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_duration

struct sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_duration

Emit silence or a tone for the specified time period. sstvenc_sequencer_step::type is set to one of:

Definition at line 443 of file sequence.h.

Collaboration diagram for sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_duration:

[legend]

Data Fields
double	duration	The number of time units (set by sstvenc_sequencer_regs#time_unit) that we should be emitting silence or a tone for. Set to INFINITY for an infinite time period.
uint8_t	slopes	Slopes enabled. Whether or not we enable the rising or falling slopes on the pulse. Not used for silences.

◆ sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_cw

struct sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_cw

Send a CW message. sstvenc_sequencer_step::type is set to SSTVENC_SEQ_STEP_TYPE_EMIT_CW.

Definition at line 463 of file sequence.h.

Collaboration diagram for sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_cw:

[legend]

Data Fields
const char *	text	The CW string to emit

◆ sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_image

struct sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_image

Send a SSTV image. sstvenc_sequencer_step::type is set to SSTVENC_SEQ_STEP_TYPE_EMIT_IMAGE.

Definition at line 472 of file sequence.h.

Collaboration diagram for sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_image:

[legend]

Data Fields
const uint8_t *	framebuffer	The image framebuffer
const char *	fsk_id	The FSK ID
const struct sstvenc_mode *	mode	The SSTV image mode to use for transmission

Typedef Documentation

◆ sstvenc_sequencer_event_cb

typedef void sstvenc_sequencer_event_cb(struct sstvenc_sequencer *const enc)

Callback routine for sequencer events. This is called at the start of each sequencer step, and finally at the end. The callback should not block the state machine for lengthy periods as this will cause delays in the transmission.

Definition at line 327 of file sequence.h.

Function Documentation

◆ sstvenc_sequencer_advance()

void sstvenc_sequencer_advance ( struct sstvenc_sequencer *const seq )

Advance the state of the state machine when generating infinite tones or silence. This does nothing unless the state machine is in one of the following states:

Definition at line 373 of file sequence.c.

                                                                    {
        switch (seq->state) {
        case SSTVENC_SEQ_STATE_GEN_INF_SILENCE:
                sstvenc_sequencer_next_state(
                    seq, SSTVENC_SEQ_STATE_END_SILENCE, false);
                sstvenc_sequencer_next_step(seq, true);
                break;
        case SSTVENC_SEQ_STATE_GEN_INF_TONE:
                sstvenc_ps_advance(&(seq->vars.tone.ps));
                break;
        default:
                return;
        }
}

References sstvenc_sequencer::sstvenc_sequencer_vars::sstvenc_sequencer_vars_tone::ps, sstvenc_ps_advance(), SSTVENC_SEQ_STATE_END_SILENCE, SSTVENC_SEQ_STATE_GEN_INF_SILENCE, SSTVENC_SEQ_STATE_GEN_INF_TONE, sstvenc_sequencer_next_state(), sstvenc_sequencer_next_step(), sstvenc_sequencer::state, sstvenc_sequencer::sstvenc_sequencer_vars::tone, and sstvenc_sequencer::vars.

Here is the call graph for this function:

◆ sstvenc_sequencer_begin_cw()

static void sstvenc_sequencer_begin_cw	(	struct sstvenc_sequencer *const	seq,
		const struct sstvenc_sequencer_step *const	step )

static

Definition at line 289 of file sequence.c.

                                                                            {
        sstvenc_sequencer_next_state(seq, SSTVENC_SEQ_STATE_BEGIN_CW, true);
 
        sstvenc_cw_init(&(seq->vars.cw), step->args.cw.text,
                        seq->regs[SSTVENC_SEQ_REG_AMPLITUDE],
                        seq->regs[SSTVENC_SEQ_REG_FREQUENCY],
                        seq->regs[SSTVENC_SEQ_REG_DIT_PERIOD],
                        seq->regs[SSTVENC_SEQ_REG_PULSE_RISE],
                        seq->sample_rate, seq->time_unit);
 
        sstvenc_sequencer_next_state(seq, SSTVENC_SEQ_STATE_GEN_CW, true);
}

References sstvenc_sequencer_step::args, sstvenc_sequencer::sstvenc_sequencer_vars::cw, sstvenc_sequencer_step::sstvenc_sequence_step_args::cw, sstvenc_sequencer::regs, sstvenc_sequencer::sample_rate, sstvenc_cw_init(), SSTVENC_SEQ_REG_AMPLITUDE, SSTVENC_SEQ_REG_DIT_PERIOD, SSTVENC_SEQ_REG_FREQUENCY, SSTVENC_SEQ_REG_PULSE_RISE, SSTVENC_SEQ_STATE_BEGIN_CW, SSTVENC_SEQ_STATE_GEN_CW, sstvenc_sequencer_next_state(), sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_cw::text, sstvenc_sequencer::time_unit, and sstvenc_sequencer::vars.

Referenced by sstvenc_sequencer_exec_step().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_sequencer_begin_image()

static void sstvenc_sequencer_begin_image	(	struct sstvenc_sequencer *const	seq,
		const struct sstvenc_sequencer_step *const	step )

static

Definition at line 303 of file sequence.c.

                                                     {
        sstvenc_sequencer_next_state(seq, SSTVENC_SEQ_STATE_BEGIN_IMAGE,
                                     true);
 
        sstvenc_modulator_init(&(seq->vars.sstv), step->args.image.mode,
                               step->args.image.fsk_id,
                               step->args.image.framebuffer,
                               seq->regs[SSTVENC_SEQ_REG_DIT_PERIOD],
                               seq->regs[SSTVENC_SEQ_REG_PULSE_RISE],
                               seq->sample_rate, seq->time_unit);
        seq->vars.sstv.ps.amplitude = seq->regs[SSTVENC_SEQ_REG_AMPLITUDE];
 
        sstvenc_sequencer_next_state(seq, SSTVENC_SEQ_STATE_GEN_IMAGE, true);
}

References sstvenc_pulseshape::amplitude, sstvenc_sequencer_step::args, sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_image::framebuffer, sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_image::fsk_id, sstvenc_sequencer_step::sstvenc_sequence_step_args::image, sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_image::mode, sstvenc_mod::ps, sstvenc_sequencer::regs, sstvenc_sequencer::sample_rate, sstvenc_sequencer::sstvenc_sequencer_vars::sstv, sstvenc_modulator_init(), SSTVENC_SEQ_REG_AMPLITUDE, SSTVENC_SEQ_REG_DIT_PERIOD, SSTVENC_SEQ_REG_PULSE_RISE, SSTVENC_SEQ_STATE_BEGIN_IMAGE, SSTVENC_SEQ_STATE_GEN_IMAGE, sstvenc_sequencer_next_state(), sstvenc_sequencer::time_unit, and sstvenc_sequencer::vars.

Referenced by sstvenc_sequencer_exec_step().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_sequencer_begin_silence()

static void sstvenc_sequencer_begin_silence	(	struct sstvenc_sequencer *const	seq,
		const struct sstvenc_sequencer_step *const	step )

static

Initialise the state machine for a run of silence.

Definition at line 231 of file sequence.c.

                                                     {
        sstvenc_sequencer_next_state(seq, SSTVENC_SEQ_STATE_BEGIN_SILENCE,
                                     true);
 
        if (step->args.duration.duration == INFINITY) {
                sstvenc_sequencer_next_state(
                    seq, SSTVENC_SEQ_STATE_GEN_INF_SILENCE, true);
        } else {
                seq->vars.silence.remaining = sstvenc_ts_unit_to_samples(
                    step->args.duration.duration, seq->sample_rate,
                    seq->time_unit);
                sstvenc_sequencer_next_state(
                    seq, SSTVENC_SEQ_STATE_GEN_SILENCE, true);
        }
}

References sstvenc_sequencer_step::args, sstvenc_sequencer_step::sstvenc_sequence_step_args::duration, sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_duration::duration, sstvenc_sequencer::sstvenc_sequencer_vars::sstvenc_sequencer_vars_silence::remaining, sstvenc_sequencer::sample_rate, sstvenc_sequencer::sstvenc_sequencer_vars::silence, SSTVENC_SEQ_STATE_BEGIN_SILENCE, SSTVENC_SEQ_STATE_GEN_INF_SILENCE, SSTVENC_SEQ_STATE_GEN_SILENCE, sstvenc_sequencer_next_state(), sstvenc_ts_unit_to_samples(), sstvenc_sequencer::time_unit, and sstvenc_sequencer::vars.

Referenced by sstvenc_sequencer_exec_step().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_sequencer_begin_tone()

static void sstvenc_sequencer_begin_tone	(	struct sstvenc_sequencer *const	seq,
		const struct sstvenc_sequencer_step *const	step )

static

Definition at line 249 of file sequence.c.

                                                     {
        _Bool init_osc = seq->state != SSTVENC_SEQ_STATE_END_TONE;
        sstvenc_sequencer_next_state(seq, SSTVENC_SEQ_STATE_BEGIN_SILENCE,
                                     true);
 
        sstvenc_ps_init(
            &(seq->vars.tone.ps), seq->regs[SSTVENC_SEQ_REG_AMPLITUDE],
            (step->args.duration.slopes & SSTVENC_SEQ_SLOPE_RISING)
                ? seq->regs[SSTVENC_SEQ_REG_PULSE_RISE]
                : 0.0,
            step->args.duration.duration,
            (step->args.duration.slopes & SSTVENC_SEQ_SLOPE_FALLING)
                ? seq->regs[SSTVENC_SEQ_REG_PULSE_FALL]
                : 0.0,
            seq->sample_rate, seq->time_unit);
 
        if (init_osc) {
                sstvenc_osc_init(&(seq->vars.tone.osc), 0.0,
                                 seq->regs[SSTVENC_SEQ_REG_FREQUENCY],
                                 seq->regs[SSTVENC_SEQ_REG_PHASE],
                                 seq->sample_rate);
        } else {
                sstvenc_osc_set_frequency(
                    &(seq->vars.tone.osc),
                    seq->regs[SSTVENC_SEQ_REG_FREQUENCY]);
                seq->vars.tone.osc.offset = seq->regs[SSTVENC_SEQ_REG_PHASE];
        }
 
        if (step->args.duration.duration == INFINITY) {
                sstvenc_sequencer_next_state(
                    seq, SSTVENC_SEQ_STATE_GEN_INF_TONE, true);
        } else {
                sstvenc_sequencer_next_state(seq, SSTVENC_SEQ_STATE_GEN_TONE,
                                             true);
        }
}

References sstvenc_sequencer_step::args, sstvenc_sequencer_step::sstvenc_sequence_step_args::duration, sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_duration::duration, sstvenc_oscillator::offset, sstvenc_sequencer::sstvenc_sequencer_vars::sstvenc_sequencer_vars_tone::osc, sstvenc_sequencer::sstvenc_sequencer_vars::sstvenc_sequencer_vars_tone::ps, sstvenc_sequencer::regs, sstvenc_sequencer::sample_rate, sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_duration::slopes, sstvenc_osc_init(), sstvenc_osc_set_frequency(), sstvenc_ps_init(), SSTVENC_SEQ_REG_AMPLITUDE, SSTVENC_SEQ_REG_FREQUENCY, SSTVENC_SEQ_REG_PHASE, SSTVENC_SEQ_REG_PULSE_FALL, SSTVENC_SEQ_REG_PULSE_RISE, SSTVENC_SEQ_SLOPE_FALLING, SSTVENC_SEQ_SLOPE_RISING, SSTVENC_SEQ_STATE_BEGIN_SILENCE, SSTVENC_SEQ_STATE_END_TONE, SSTVENC_SEQ_STATE_GEN_INF_TONE, SSTVENC_SEQ_STATE_GEN_TONE, sstvenc_sequencer_next_state(), sstvenc_sequencer::state, sstvenc_sequencer::time_unit, sstvenc_sequencer::sstvenc_sequencer_vars::tone, and sstvenc_sequencer::vars.

Referenced by sstvenc_sequencer_exec_step().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_sequencer_compute()

void sstvenc_sequencer_compute ( struct sstvenc_sequencer *const seq )

Compute the next sample to be emitted by the sequencer. The result will be stored in sstvenc_sequencer::output.

This should be called until sstvenc_sequencer::state reaches the value SSTVENC_SEQ_STATE_DONE.

Definition at line 388 of file sequence.c.

                                                                    {
retry:
        switch (seq->state) {
        case SSTVENC_SEQ_STATE_INIT:
        case SSTVENC_SEQ_STATE_END_SILENCE:
        case SSTVENC_SEQ_STATE_END_TONE:
        case SSTVENC_SEQ_STATE_END_CW:
        case SSTVENC_SEQ_STATE_END_IMAGE:
                sstvenc_sequencer_exec_step(seq);
                goto retry;
                break;
        case SSTVENC_SEQ_STATE_BEGIN_SILENCE:
        case SSTVENC_SEQ_STATE_GEN_SILENCE:
        case SSTVENC_SEQ_STATE_GEN_INF_SILENCE:
                seq->output = 0.0;
                if (seq->vars.silence.remaining > 0) {
                        seq->vars.silence.remaining--;
                } else {
                        sstvenc_sequencer_next_state(
                            seq, SSTVENC_SEQ_STATE_END_SILENCE, true);
                        goto retry;
                }
                break;
        case SSTVENC_SEQ_STATE_BEGIN_TONE:
        case SSTVENC_SEQ_STATE_GEN_TONE:
        case SSTVENC_SEQ_STATE_GEN_INF_TONE:
                sstvenc_ps_compute(&(seq->vars.tone.ps));
                seq->vars.tone.osc.amplitude = seq->vars.tone.ps.output;
                sstvenc_osc_compute(&(seq->vars.tone.osc));
                seq->output = seq->vars.tone.osc.output;
 
                if (seq->vars.tone.ps.phase >= SSTVENC_PS_PHASE_DONE) {
                        sstvenc_sequencer_next_state(
                            seq, SSTVENC_SEQ_STATE_END_TONE, true);
                        goto retry;
                }
                break;
        case SSTVENC_SEQ_STATE_BEGIN_CW:
        case SSTVENC_SEQ_STATE_GEN_CW:
                sstvenc_cw_compute(&(seq->vars.cw));
                seq->output = seq->vars.cw.output;
 
                if (seq->vars.cw.state >= SSTVENC_CW_MOD_STATE_DONE) {
                        sstvenc_sequencer_next_state(
                            seq, SSTVENC_SEQ_STATE_END_CW, true);
                        goto retry;
                }
                break;
        case SSTVENC_SEQ_STATE_BEGIN_IMAGE:
        case SSTVENC_SEQ_STATE_GEN_IMAGE:
                sstvenc_modulator_compute(&(seq->vars.sstv));
                seq->output = seq->vars.sstv.osc.output;
 
                if (seq->vars.sstv.ps.phase >= SSTVENC_PS_PHASE_DONE) {
                        sstvenc_sequencer_next_state(
                            seq, SSTVENC_SEQ_STATE_END_IMAGE, true);
                        goto retry;
                }
                break;
        case SSTVENC_SEQ_STATE_DONE:
        default:
                break;
        }
}

Referenced by sstvenc_sequencer_fill_buffer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_sequencer_end()

static void sstvenc_sequencer_end ( struct sstvenc_sequencer *const seq )

static

Definition at line 320 of file sequence.c.

                                                                       {
        sstvenc_sequencer_next_state(seq, SSTVENC_SEQ_STATE_DONE, true);
}

References SSTVENC_SEQ_STATE_DONE, and sstvenc_sequencer_next_state().

Referenced by sstvenc_sequencer_exec_step().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_sequencer_exec_set_ts()

static void sstvenc_sequencer_exec_set_ts	(	struct sstvenc_sequencer *const	seq,
		const struct sstvenc_sequencer_step *const	step )

static

Execute a SET_TS instruction.

Definition at line 166 of file sequence.c.

                                                     {
        /* Perform conversions if asked */
        if (step->args.ts.convert) {
                const uint64_t old_scale
                    = sstvenc_ts_unit_scale(seq->time_unit);
                const uint64_t new_scale
                    = sstvenc_ts_unit_scale(step->args.ts.time_unit);
                double scale = (double)new_scale / (double)old_scale;
 
                for (uint8_t reg = 0; reg < SSTVENC_SEQ_NUM_REGS; reg++) {
                        seq->regs[reg] *= scale;
                }
        }
 
        /* Apply new unit setting */
        seq->time_unit = step->args.ts.time_unit;
 
        /* Step is complete */
        sstvenc_sequencer_next_step(seq, true);
}

References sstvenc_sequencer_step::args, sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_ts_unit::convert, sstvenc_sequencer::regs, SSTVENC_SEQ_NUM_REGS, sstvenc_sequencer_next_step(), sstvenc_ts_unit_scale(), sstvenc_sequencer::time_unit, sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_ts_unit::time_unit, and sstvenc_sequencer_step::sstvenc_sequence_step_args::ts.

Referenced by sstvenc_sequencer_exec_step().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_sequencer_exec_step()

static void sstvenc_sequencer_exec_step ( struct sstvenc_sequencer *const seq )

static

Execute the step pointed to by sstvenc_sequencer::step.

Definition at line 327 of file sequence.c.

                                                                             {
        const struct sstvenc_sequencer_step* step = &(seq->steps[seq->step]);
        switch (step->type) {
        case SSTVENC_SEQ_STEP_TYPE_SET_TS_UNIT:
                sstvenc_sequencer_exec_set_ts(seq, step);
                break;
        case SSTVENC_SEQ_STEP_TYPE_SET_REGISTER:
        case SSTVENC_SEQ_STEP_TYPE_INC_REGISTER:
        case SSTVENC_SEQ_STEP_TYPE_DEC_REGISTER:
        case SSTVENC_SEQ_STEP_TYPE_MUL_REGISTER:
        case SSTVENC_SEQ_STEP_TYPE_DIV_REGISTER:
        case SSTVENC_SEQ_STEP_TYPE_IDEC_REGISTER:
        case SSTVENC_SEQ_STEP_TYPE_IDIV_REGISTER:
                sstvenc_sequencer_exec_update_reg(seq, step);
                break;
        case SSTVENC_SEQ_STEP_TYPE_EMIT_SILENCE:
                sstvenc_sequencer_begin_silence(seq, step);
                break;
        case SSTVENC_SEQ_STEP_TYPE_EMIT_TONE:
                sstvenc_sequencer_begin_tone(seq, step);
                break;
        case SSTVENC_SEQ_STEP_TYPE_EMIT_CW:
                sstvenc_sequencer_begin_cw(seq, step);
                break;
        case SSTVENC_SEQ_STEP_TYPE_EMIT_IMAGE:
                sstvenc_sequencer_begin_image(seq, step);
                break;
        case SSTVENC_SEQ_STEP_TYPE_END:
        default:
                sstvenc_sequencer_end(seq);
                break;
        }
}

Referenced by sstvenc_sequencer_compute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_sequencer_exec_update_reg()

static void sstvenc_sequencer_exec_update_reg	(	struct sstvenc_sequencer *const	seq,
		const struct sstvenc_sequencer_step *const	step )

static

Execute a register manipulation instruction.

Definition at line 192 of file sequence.c.

                                                     {
        if (step->args.reg.reg < SSTVENC_SEQ_NUM_REGS) {
                /* Get a pointer to the register for convenience */
                double* const value = &(seq->regs[step->args.reg.reg]);
 
                switch (step->type) {
                case SSTVENC_SEQ_STEP_TYPE_SET_REGISTER:
                        *value = step->args.reg.value;
                        break;
                case SSTVENC_SEQ_STEP_TYPE_INC_REGISTER:
                        *value += step->args.reg.value;
                        break;
                case SSTVENC_SEQ_STEP_TYPE_DEC_REGISTER:
                        *value -= step->args.reg.value;
                        break;
                case SSTVENC_SEQ_STEP_TYPE_MUL_REGISTER:
                        *value *= step->args.reg.value;
                        break;
                case SSTVENC_SEQ_STEP_TYPE_DIV_REGISTER:
                        *value /= step->args.reg.value;
                        break;
                case SSTVENC_SEQ_STEP_TYPE_IDEC_REGISTER:
                        *value = step->args.reg.value - *value;
                        break;
                case SSTVENC_SEQ_STEP_TYPE_IDIV_REGISTER:
                        *value = step->args.reg.value / *value;
                        break;
                }
        }
 
        /* Step is complete */
        sstvenc_sequencer_next_step(seq, true);
}

References sstvenc_sequencer_step::args, sstvenc_sequencer_step::sstvenc_sequence_step_args::reg, sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_reg::reg, sstvenc_sequencer::regs, SSTVENC_SEQ_NUM_REGS, SSTVENC_SEQ_STEP_TYPE_DEC_REGISTER, SSTVENC_SEQ_STEP_TYPE_DIV_REGISTER, SSTVENC_SEQ_STEP_TYPE_IDEC_REGISTER, SSTVENC_SEQ_STEP_TYPE_IDIV_REGISTER, SSTVENC_SEQ_STEP_TYPE_INC_REGISTER, SSTVENC_SEQ_STEP_TYPE_MUL_REGISTER, SSTVENC_SEQ_STEP_TYPE_SET_REGISTER, sstvenc_sequencer_next_step(), sstvenc_sequencer_step::type, and sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_reg::value.

Referenced by sstvenc_sequencer_exec_step().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_sequencer_fill_buffer()

size_t sstvenc_sequencer_fill_buffer	(	struct sstvenc_sequencer *const	seq,
		double *	buffer,
		size_t	buffer_sz )

Fill the given buffer with audio samples from the sequencer. Stop if we run out of buffer space or if the sequencer state machine finishes. Return the number of samples generated.

Parameters

[in,out]	seq	Sequencer state machine to pull samples from.
[out]	buffer	Audio buffer to write samples to.
[in]	buffer_sz	Size of the audio buffer in samples.

Returns: Number of samples written to buffer

Definition at line 453 of file sequence.c.

                                                                       {
        size_t written_sz = 0;
 
        while ((buffer_sz > 0) && (seq->state < SSTVENC_SEQ_STATE_DONE)) {
                sstvenc_sequencer_compute(seq);
 
                buffer[0] = seq->output;
                buffer++;
                buffer_sz--;
 
                written_sz++;
        }
 
        return written_sz;
}

References sstvenc_sequencer::output, SSTVENC_SEQ_STATE_DONE, sstvenc_sequencer_compute(), and sstvenc_sequencer::state.

Here is the call graph for this function:

◆ sstvenc_sequencer_init()

void sstvenc_sequencer_init	(	struct sstvenc_sequencer *const	seq,
		const struct sstvenc_sequencer_step *	steps,
		sstvenc_sequencer_event_cb *	event_cb,
		const void *	event_cb_ctx,
		uint32_t	sample_rate )

Initialise the sequencer with the given sequencer steps.

Parameters

[in,out]	seq	Sequencer to initialise
[in]	steps	Sequencer steps, the last step MUST have sstvenc_sequence_step#type set to SSTVENC_SEQ_STEP_TYPE_END.
[in]	event_cb	Optional event callback, set to NULL for no callback.
[in]	event_cb_ctx	Optional event callback context.
[in]	sample_rate	Sample rate in hertz.

Definition at line 125 of file sequence.c.

                                                                            {
        seq->steps        = steps;
        seq->event_cb     = event_cb;
        seq->event_cb_ctx = event_cb_ctx;
        sstvenc_sequencer_reset(seq);
}

References sstvenc_sequencer::event_cb, sstvenc_sequencer::event_cb_ctx, sstvenc_sequencer_reset(), and sstvenc_sequencer::steps.

Here is the call graph for this function:

◆ sstvenc_sequencer_next_state()

static void sstvenc_sequencer_next_state	(	struct sstvenc_sequencer *const	seq,
		uint8_t	state,
		_Bool	notify )

static

Enter a new state in the state machine. Optionally call the callback routine if it is defined.

Definition at line 152 of file sequence.c.

                                                                      {
        if (seq->state != state) {
                seq->state = state;
 
                if (notify && seq->event_cb) {
                        seq->event_cb(seq);
                }
        }
}

References sstvenc_sequencer::event_cb, and sstvenc_sequencer::state.

Referenced by sstvenc_sequencer_advance(), sstvenc_sequencer_begin_cw(), sstvenc_sequencer_begin_image(), sstvenc_sequencer_begin_silence(), sstvenc_sequencer_begin_tone(), sstvenc_sequencer_compute(), and sstvenc_sequencer_end().

Here is the caller graph for this function:

◆ sstvenc_sequencer_next_step()

static void sstvenc_sequencer_next_step	(	struct sstvenc_sequencer *const	seq,
		_Bool	notify )

static

Advance to the next step in the sequence. Optionally call the callback routine if it is defined.

Definition at line 139 of file sequence.c.

                                                      {
        seq->step++;
 
        if (notify && seq->event_cb) {
                seq->event_cb(seq);
        }
}

References sstvenc_sequencer::event_cb, and sstvenc_sequencer::step.

Referenced by sstvenc_sequencer_advance(), sstvenc_sequencer_exec_set_ts(), and sstvenc_sequencer_exec_update_reg().

Here is the caller graph for this function:

◆ sstvenc_sequencer_reset()

void sstvenc_sequencer_reset ( struct sstvenc_sequencer *const seq )

Reset the state machine back to the initial state.

Definition at line 361 of file sequence.c.

                                                                  {
        seq->step                             = 0;
        seq->state                            = SSTVENC_SEQ_STATE_INIT;
        seq->regs[SSTVENC_SEQ_REG_AMPLITUDE]  = 1.0;
        seq->regs[SSTVENC_SEQ_REG_FREQUENCY]  = 800.0;
        seq->regs[SSTVENC_SEQ_REG_PHASE]      = 0.0;
        seq->regs[SSTVENC_SEQ_REG_PULSE_RISE] = 0.002;
        seq->regs[SSTVENC_SEQ_REG_PULSE_FALL] = 0.002;
        seq->regs[SSTVENC_SEQ_REG_DIT_PERIOD] = 0.05;
        seq->time_unit                        = SSTVENC_TS_UNIT_SECONDS;
}

References sstvenc_sequencer::regs, SSTVENC_SEQ_REG_AMPLITUDE, SSTVENC_SEQ_REG_DIT_PERIOD, SSTVENC_SEQ_REG_FREQUENCY, SSTVENC_SEQ_REG_PHASE, SSTVENC_SEQ_REG_PULSE_FALL, SSTVENC_SEQ_REG_PULSE_RISE, SSTVENC_SEQ_STATE_INIT, SSTVENC_TS_UNIT_SECONDS, sstvenc_sequencer::state, sstvenc_sequencer::step, and sstvenc_sequencer::time_unit.

Referenced by sstvenc_sequencer_init().

Here is the caller graph for this function:

◆ sstvenc_sequencer_step_cw()

void sstvenc_sequencer_step_cw	(	struct sstvenc_sequencer_step *const	step,
		const char *	text )

Configure a step that emits CW text.

Parameters

[out]	step	Sequencer step
[in]	text	The CW text to emit.

Definition at line 105 of file sequence.c.

                                                                          {
        step->type         = SSTVENC_SEQ_STEP_TYPE_EMIT_CW;
        step->args.cw.text = text;
}

References sstvenc_sequencer_step::args, sstvenc_sequencer_step::sstvenc_sequence_step_args::cw, SSTVENC_SEQ_STEP_TYPE_EMIT_CW, sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_cw::text, and sstvenc_sequencer_step::type.

◆ sstvenc_sequencer_step_dec_reg()

void sstvenc_sequencer_step_dec_reg	(	struct sstvenc_sequencer_step *const	step,
		uint8_t	reg,
		double	value )

Configure a step that sets the register to old_value - value.

Parameters

[out]	step	Sequencer step
[in]	reg	Register to adjust (see Sequencer registers.)
[in]	value	Amount to subtract from the register

Definition at line 49 of file sequence.c.

                                                               {
        sstvenc_sequencer_step_update_reg(
            step, SSTVENC_SEQ_STEP_TYPE_DEC_REGISTER, reg, value);
}

References SSTVENC_SEQ_STEP_TYPE_DEC_REGISTER, and sstvenc_sequencer_step_update_reg().

Here is the call graph for this function:

◆ sstvenc_sequencer_step_div_reg()

void sstvenc_sequencer_step_div_reg	(	struct sstvenc_sequencer_step *const	step,
		uint8_t	reg,
		double	value )

Configure a step that sets the register to old_value / value.

Parameters

[out]	step	Sequencer step
[in]	reg	Register to adjust (see Sequencer registers.)
[in]	value	Amount to divide the register value by

Definition at line 61 of file sequence.c.

                                                               {
        sstvenc_sequencer_step_update_reg(
            step, SSTVENC_SEQ_STEP_TYPE_DIV_REGISTER, reg, value);
}

References SSTVENC_SEQ_STEP_TYPE_DIV_REGISTER, and sstvenc_sequencer_step_update_reg().

Here is the call graph for this function:

◆ sstvenc_sequencer_step_duration()

static void sstvenc_sequencer_step_duration	(	struct sstvenc_sequencer_step *const	step,
		uint8_t	type,
		double	duration )

static

Configure a sequencer step that sets up an operation for a given duration.

Parameters

[out]	step	Sequencer step
[in]	duration	Operation duration

Definition at line 86 of file sequence.c.

                                                               {
        step->type                   = type;
        step->args.duration.duration = duration;
}

References sstvenc_sequencer_step::args, sstvenc_sequencer_step::sstvenc_sequence_step_args::duration, sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_duration::duration, and sstvenc_sequencer_step::type.

Referenced by sstvenc_sequencer_step_silence(), and sstvenc_sequencer_step_tone().

Here is the caller graph for this function:

◆ sstvenc_sequencer_step_end()

void sstvenc_sequencer_step_end ( struct sstvenc_sequencer_step *const step )

Configure the final step in the sequence.

Parameters

[out] step Sequencer step

Definition at line 121 of file sequence.c.

                                                                           {
        step->type = SSTVENC_SEQ_STEP_TYPE_END;
}

References SSTVENC_SEQ_STEP_TYPE_END, and sstvenc_sequencer_step::type.

◆ sstvenc_sequencer_step_idec_reg()

void sstvenc_sequencer_step_idec_reg	(	struct sstvenc_sequencer_step *const	step,
		uint8_t	reg,
		double	value )

Configure a step that sets the register to value - old_value.

Parameters

[out]	step	Sequencer step
[in]	reg	Register to adjust (see Sequencer registers.)
[in]	value	Amount to add to the register value

Definition at line 67 of file sequence.c.

                                                                          {
        sstvenc_sequencer_step_update_reg(
            step, SSTVENC_SEQ_STEP_TYPE_IDEC_REGISTER, reg, value);
}

References SSTVENC_SEQ_STEP_TYPE_IDEC_REGISTER, and sstvenc_sequencer_step_update_reg().

Here is the call graph for this function:

◆ sstvenc_sequencer_step_idiv_reg()

void sstvenc_sequencer_step_idiv_reg	(	struct sstvenc_sequencer_step *const	step,
		uint8_t	reg,
		double	value )

Configure a step that sets the register to value / old_value.

Parameters

[out]	step	Sequencer step
[in]	reg	Register to adjust (see Sequencer registers.)
[in]	value	Amount to subtract from the register

Definition at line 73 of file sequence.c.

                                                                          {
        sstvenc_sequencer_step_update_reg(
            step, SSTVENC_SEQ_STEP_TYPE_IDIV_REGISTER, reg, value);
}

References SSTVENC_SEQ_STEP_TYPE_IDIV_REGISTER, and sstvenc_sequencer_step_update_reg().

Here is the call graph for this function:

◆ sstvenc_sequencer_step_image()

void sstvenc_sequencer_step_image	(	struct sstvenc_sequencer_step *const	step,
		const struct sstvenc_mode *const	mode,
		const uint8_t *	framebuffer,
		const char *	fsk_id )

Configure a step that emits a SSTV image.

Parameters

[out]	step	Sequencer step
[in]	mode	The SSTV mode to use.
[in]	framebuffer	The framebuffer containing the SSTV image. The image must be in the correct colourspace format and dimensions for the SSTV mode selected.

Definition at line 111 of file sequence.c.

                                                         {
        step->type                   = SSTVENC_SEQ_STEP_TYPE_EMIT_IMAGE;
        step->args.image.mode        = mode;
        step->args.image.framebuffer = framebuffer;
        step->args.image.fsk_id      = fsk_id;
}

References sstvenc_sequencer_step::args, sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_image::framebuffer, sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_image::fsk_id, sstvenc_sequencer_step::sstvenc_sequence_step_args::image, sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_image::mode, SSTVENC_SEQ_STEP_TYPE_EMIT_IMAGE, and sstvenc_sequencer_step::type.

◆ sstvenc_sequencer_step_inc_reg()

void sstvenc_sequencer_step_inc_reg	(	struct sstvenc_sequencer_step *const	step,
		uint8_t	reg,
		double	value )

Configure a step that sets the register to old_value + value.

Parameters

[out]	step	Sequencer step
[in]	reg	Register to adjust (see Sequencer registers.)
[in]	value	Amount to add to the register value

Definition at line 43 of file sequence.c.

                                                               {
        sstvenc_sequencer_step_update_reg(
            step, SSTVENC_SEQ_STEP_TYPE_INC_REGISTER, reg, value);
}

References SSTVENC_SEQ_STEP_TYPE_INC_REGISTER, and sstvenc_sequencer_step_update_reg().

Here is the call graph for this function:

◆ sstvenc_sequencer_step_mul_reg()

void sstvenc_sequencer_step_mul_reg	(	struct sstvenc_sequencer_step *const	step,
		uint8_t	reg,
		double	value )

Configure a step that sets the register to old_value * value.

Parameters

[out]	step	Sequencer step
[in]	reg	Register to adjust (see Sequencer registers.)
[in]	value	Amount to multiply the register value by

Definition at line 55 of file sequence.c.

                                                               {
        sstvenc_sequencer_step_update_reg(
            step, SSTVENC_SEQ_STEP_TYPE_MUL_REGISTER, reg, value);
}

References SSTVENC_SEQ_STEP_TYPE_MUL_REGISTER, and sstvenc_sequencer_step_update_reg().

Here is the call graph for this function:

◆ sstvenc_sequencer_step_set_reg()

void sstvenc_sequencer_step_set_reg	(	struct sstvenc_sequencer_step *const	step,
		uint8_t	reg,
		double	value )

Configure a step that sets a register to a new value.

Parameters

[out]	step	Sequencer step
[in]	reg	Register to adjust (see Sequencer registers.)
[in]	value	New register value

Definition at line 37 of file sequence.c.

                                                               {
        sstvenc_sequencer_step_update_reg(
            step, SSTVENC_SEQ_STEP_TYPE_SET_REGISTER, reg, value);
}

References SSTVENC_SEQ_STEP_TYPE_SET_REGISTER, and sstvenc_sequencer_step_update_reg().

Here is the call graph for this function:

◆ sstvenc_sequencer_step_set_timescale()

void sstvenc_sequencer_step_set_timescale	(	struct sstvenc_sequencer_step *const	step,
		uint8_t	time_unit,
		_Bool	convert )

Configure a step that sets the timescale unit.

Parameters

[out]	step	Sequencer step
[in]	time_unit	Timescale unit
[in]	convert	Convert existing registers?

Definition at line 13 of file sequence.c.

                   {
        step->type              = SSTVENC_SEQ_STEP_TYPE_SET_TS_UNIT;
        step->args.ts.time_unit = time_unit;
        step->args.ts.convert   = convert;
}

References sstvenc_sequencer_step::args, sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_ts_unit::convert, SSTVENC_SEQ_STEP_TYPE_SET_TS_UNIT, sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_ts_unit::time_unit, sstvenc_sequencer_step::sstvenc_sequence_step_args::ts, and sstvenc_sequencer_step::type.

◆ sstvenc_sequencer_step_silence()

void sstvenc_sequencer_step_silence	(	struct sstvenc_sequencer_step *const	step,
		double	duration )

Configure a step that emits silence.

Parameters

[out]	step	Sequencer step
[in]	duration	The length of time to emit silence. Use INFINITY for indefinite time periods.

Definition at line 92 of file sequence.c.

                                                     {
        sstvenc_sequencer_step_duration(
            step, SSTVENC_SEQ_STEP_TYPE_EMIT_SILENCE, duration);
}

References SSTVENC_SEQ_STEP_TYPE_EMIT_SILENCE, and sstvenc_sequencer_step_duration().

Here is the call graph for this function:

◆ sstvenc_sequencer_step_tone()

void sstvenc_sequencer_step_tone	(	struct sstvenc_sequencer_step *const	step,
		double	duration,
		uint8_t	slopes )

Configure a step that emits a tone. The frequency and phase information is set by whatever frequency is configured in the frequency register.

Parameters

[out]	step	Sequencer step
[in]	duration	The length of time to emit a tone. Use INFINITY for indefinite time
[in]	slopes	Which slopes to enable (see Tone slopes) periods.

Definition at line 98 of file sequence.c.

                                                                  {
        sstvenc_sequencer_step_duration(step, SSTVENC_SEQ_STEP_TYPE_EMIT_TONE,
                                        duration);
        step->args.duration.slopes = slopes;
}

References sstvenc_sequencer_step::args, sstvenc_sequencer_step::sstvenc_sequence_step_args::duration, sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_duration::slopes, SSTVENC_SEQ_STEP_TYPE_EMIT_TONE, and sstvenc_sequencer_step_duration().

Here is the call graph for this function:

◆ sstvenc_sequencer_step_update_reg()

static void sstvenc_sequencer_step_update_reg	(	struct sstvenc_sequencer_step *const	step,
		uint8_t	type,
		uint8_t	reg,
		double	value )

static

Configure a step that manipulates a register.

Parameters

[out]	step	Sequencer step
[in]	type	Instruction type
[in]	reg	Register to adjust (see Sequencer registers.)
[in]	value	New register value

Definition at line 30 of file sequence.c.

                                                                           {
        step->type           = type;
        step->args.reg.reg   = reg;
        step->args.reg.value = value;
}

References sstvenc_sequencer_step::args, sstvenc_sequencer_step::sstvenc_sequence_step_args::reg, sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_reg::reg, sstvenc_sequencer_step::type, and sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_reg::value.

Referenced by sstvenc_sequencer_step_dec_reg(), sstvenc_sequencer_step_div_reg(), sstvenc_sequencer_step_idec_reg(), sstvenc_sequencer_step_idiv_reg(), sstvenc_sequencer_step_inc_reg(), sstvenc_sequencer_step_mul_reg(), and sstvenc_sequencer_step_set_reg().

Here is the caller graph for this function:

Variable Documentation

◆ args

union sstvenc_sequencer_step::sstvenc_sequence_step_args sstvenc_sequencer_step::args

Referenced by sstvenc_sequencer_begin_cw(), sstvenc_sequencer_begin_image(), sstvenc_sequencer_begin_silence(), sstvenc_sequencer_begin_tone(), sstvenc_sequencer_exec_set_ts(), sstvenc_sequencer_exec_update_reg(), sstvenc_sequencer_step_cw(), sstvenc_sequencer_step_duration(), sstvenc_sequencer_step_image(), sstvenc_sequencer_step_set_timescale(), sstvenc_sequencer_step_tone(), and sstvenc_sequencer_step_update_reg().

◆ convert

_Bool sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_set_ts_unit::convert

Convert fields to the new unit?

Definition at line 414 of file sequence.h.

Referenced by sstvenc_sequencer_exec_set_ts(), and sstvenc_sequencer_step_set_timescale().

◆ cw [1/2]

struct sstvenc_cw_mod sstvenc_sequencer::sstvenc_sequencer_vars::cw

State machine for CW transmission states.

Definition at line 369 of file sequence.h.

Referenced by sstvenc_sequencer_begin_cw(), and sstvenc_sequencer_compute().

◆ cw [2/2]

struct sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_cw sstvenc_sequencer_step::sstvenc_sequence_step_args::cw

Referenced by sstvenc_sequencer_begin_cw(), and sstvenc_sequencer_step_cw().

◆ duration [1/2]

struct sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_duration sstvenc_sequencer_step::sstvenc_sequence_step_args::duration

Referenced by sstvenc_sequencer_begin_silence(), sstvenc_sequencer_begin_tone(), sstvenc_sequencer_step_duration(), and sstvenc_sequencer_step_tone().

◆ duration [2/2]

double sstvenc_sequencer_step::sstvenc_sequence_step_args::sstvenc_sequence_step_duration::duration

The number of time units (set by sstvenc_sequencer_regs#time_unit) that we should be emitting silence or a tone for. Set to INFINITY for an infinite time period.

Definition at line 450 of file sequence.h.

Referenced by sstvenc_sequencer_begin_silence(), sstvenc_sequencer_begin_tone(), and sstvenc_sequencer_step_duration().