Collaboration diagram for SSTV encoder:

Topics
	SSTV Encoder Phases

	SSTV frequency specifications.

	SSTV mode specifications.

	RGB to YUV conversions (and vice versa).

	SSTV VIS header bits

	SSTV scan line segments

Data Structures
struct	sstvenc_encoder

union	sstvenc_encoder::sstvenc_encoder_phase_data

struct	sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_vis_data

struct	sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data

struct	sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_fsk_data

Macros
#define	SSTVENC_ENCODER_FSK_SEGMENT_BEGIN (0)

#define	SSTVENC_ENCODER_FSK_SEGMENT_PREAMBLE (1)

#define	SSTVENC_ENCODER_FSK_SEGMENT_ID (2)

#define	SSTVENC_ENCODER_FSK_SEGMENT_TAIL (3)

#define	SSTVENC_ENCODER_FSK_SEGMENT_DONE (4)

Typedefs
typedef void	sstvenc_encoder_callback(struct sstvenc_encoder *const enc)

Functions
void	sstvenc_encoder_init (struct sstvenc_encoder const enc, const struct sstvenc_mode mode, const char fsk_id, const uint8_t framebuffer)

const struct sstvenc_encoder_pulse *	sstvenc_encoder_next_pulse (struct sstvenc_encoder *const enc)

static void	sstvenc_encoder_new_phase (struct sstvenc_encoder *const enc, uint8_t phase)

static void	sstvenc_encoder_begin_seq (struct sstvenc_encoder const enc, const struct sstvenc_encoder_pulse seq, sstvenc_encoder_callback *on_done)

static const struct sstvenc_encoder_pulse *	sstvenc_encoder_next_seq_pulse (struct sstvenc_encoder *const enc)

static void	sstvenc_encoder_begin_vis (struct sstvenc_encoder *const enc)

static uint32_t	sstvenc_encoder_vis_data_freq (struct sstvenc_encoder *const enc)

static uint32_t	sstvenc_encoder_vis_parity_freq (struct sstvenc_encoder *const enc)

static const struct sstvenc_encoder_pulse *	sstvenc_encoder_next_vis_pulse (struct sstvenc_encoder *const enc)

static void	sstvenc_encoder_begin_image (struct sstvenc_encoder *const enc)

static void	sstvenc_encoder_begin_scanline (struct sstvenc_encoder *const enc)

static void	sstvenc_encoder_begin_channel (struct sstvenc_encoder *const enc, uint8_t segment, uint8_t ch)

static void	sstvenc_encoder_next_scan_seg (struct sstvenc_encoder *const enc, uint8_t next_segment)

static void	sstvenc_encoder_on_initseq_done (struct sstvenc_encoder *const enc)

static void	sstvenc_encoder_begin_fsk (struct sstvenc_encoder *const enc)

static void	sstvenc_encoder_on_finalseq_done (struct sstvenc_encoder *const enc)

static void	sstvenc_encoder_begin_frontporch (struct sstvenc_encoder *const enc)

static void	sstvenc_encoder_begin_gap01 (struct sstvenc_encoder *const enc)

static void	sstvenc_encoder_begin_gap12 (struct sstvenc_encoder *const enc)

static void	sstvenc_encoder_begin_gap23 (struct sstvenc_encoder *const enc)

static void	sstvenc_encoder_begin_backporch (struct sstvenc_encoder *const enc)

static const struct sstvenc_encoder_pulse *	sstvenc_encoder_next_channel_pulse (struct sstvenc_encoder *const enc, uint8_t ch)

static const struct sstvenc_encoder_pulse *	sstvenc_encoder_next_image_pulse (struct sstvenc_encoder *const enc)

static void	sstvenc_encoder_fsk_load_next (struct sstvenc_encoder *const enc)

static const struct sstvenc_encoder_pulse *	sstvenc_encoder_next_fsk_pulse (struct sstvenc_encoder *const enc)

Variables
const struct sstvenc_mode *	sstvenc_encoder::mode

const char *	sstvenc_encoder::fsk_id

const uint8_t *	sstvenc_encoder::framebuffer

const struct sstvenc_encoder_pulse *	sstvenc_encoder::seq

sstvenc_encoder_callback *	sstvenc_encoder::seq_done_cb

struct sstvenc_encoder_pulse	sstvenc_encoder::pulse

uint8_t	sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_vis_data::bit

struct sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_vis_data	sstvenc_encoder::sstvenc_encoder_phase_data::vis

uint16_t	sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data::x

uint16_t	sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data::y

uint8_t	sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data::segment

struct sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data	sstvenc_encoder::sstvenc_encoder_phase_data::scan

uint8_t	sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_fsk_data::segment

uint8_t	sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_fsk_data::seg_sz

uint8_t	sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_fsk_data::byte

uint8_t	sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_fsk_data::bv

uint8_t	sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_fsk_data::bit

struct sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_fsk_data	sstvenc_encoder::sstvenc_encoder_phase_data::fsk

union sstvenc_encoder::sstvenc_encoder_phase_data	sstvenc_encoder::vars

uint8_t	sstvenc_encoder::phase

static const uint8_t	sstvenc_encoder_fsk_preamble [] = {0x20, 0x2a}

static const uint8_t	sstvenc_encoder_fsk_tail [] = {0x01}

Detailed Description

This is an asynchronous SSTV encoder that emits frequency/duration pairs to be used with an oscillator (see Oscillator implementation) to produce actual audio samples.

Depending on the SSTV mode it will expect a framebuffer with one of the following forms:

for modes with colour-space SSTVENC_CSO_MODE_MONO: an array of uint8_ts measuring sstvenc_mode::width times sstvenc_mode::height. Each element represents the pixel's monochromatic brightness level.
for modes with colour-space SSTVENC_CSO_MODE_RGB: an array of uint8_ts measuring sstvenc_mode::width times sstvenc_mode::height times 3. Every 3 elements represents a pixel's RGB colour in the order: red, green, blue.
for modes with colour-spaces SSTVENC_CSO_MODE_YUV or SSTVENC_CSO_MODE_YUV2: an array of uint8_ts measuring sstvenc_mode::width times sstvenc_mode::height times 3. Every 3 elements represents a pixel's YUV colour in the order: Y (luminance), U (R-Y), V (B-Y).

The routines in RGB to YUV conversions (and vice versa). may be useful for converting between RGB and YUV or monochrome modes in your application.

Calling code initialises a context by calling sstvenc_encoder_init then repeatedly calling sstvenc_encoder_next_pulse to compute each SSTV image pulse. Calling code may conclude the state machine is finished when sstvenc_encoder::phase reaches SSTVENC_ENCODER_PHASE_DONE or when sstvenc_encoder_next_pulse returns NULL.

Data Structure Documentation

◆ sstvenc_encoder

struct sstvenc_encoder

SSTV encoder data structure. This encodes the state of the encoder and all the necessary oscillator and pulse shaper structures.

Definition at line 98 of file sstv.h.

Collaboration diagram for sstvenc_encoder:

[legend]

Data Fields
const uint8_t *	framebuffer	The framebuffer holding the image to be sent. The image is assumed to be in the correct format for the SSTV mode, i.e. correct dimensions, channel count and colour space. For colour SSTV modes, the values are interleaved for each channel, so c0, c1, c2; for the first pixel, then c0, c1, c2 for the second, etc. Use SSTVENC_MODE_GET_CH to determine what channel is what.
const char *	fsk_id	The FSK-ID to be appended to the end. NULL for no FSK ID
const struct sstvenc_mode *	mode	The SSTV mode being used for encoding.
uint8_t	phase	The transmission phase we are in.
struct sstvenc_encoder_pulse	pulse	The current pulse being emitted
const struct sstvenc_encoder_pulse *	seq	The current pulse sequence being emitted
sstvenc_encoder_callback *	seq_done_cb	What to do if the sequence is done?
union sstvenc_encoder_phase_data	vars

◆ sstvenc_encoder::sstvenc_encoder_phase_data

union sstvenc_encoder::sstvenc_encoder_phase_data

Definition at line 126 of file sstv.h.

Collaboration diagram for sstvenc_encoder::sstvenc_encoder_phase_data:

[legend]

Data Fields
struct sstvenc_encoder_phase_fsk_data	fsk
struct sstvenc_encoder_phase_scan_data	scan
struct sstvenc_encoder_phase_vis_data	vis

◆ sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_vis_data

struct sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_vis_data

Definition at line 127 of file sstv.h.

Collaboration diagram for sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_vis_data:

[legend]

Data Fields
uint8_t	bit	The current bit being sent

◆ sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data

struct sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data

Definition at line 132 of file sstv.h.

Collaboration diagram for sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data:

[legend]

Data Fields
uint8_t	segment	Scanline segment being emitted
uint16_t	x	The current image X position being scanned
uint16_t	y	The current image Y position being scanned

◆ sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_fsk_data

struct sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_fsk_data

Definition at line 149 of file sstv.h.

Collaboration diagram for sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_fsk_data:

[legend]

Data Fields
uint8_t	bit	The current bit of the byte being sent
uint8_t	bv	The current byte value being sent
uint8_t	byte	The current byte position being sent
uint8_t	seg_sz	The current segment length
uint8_t	segment	The current byte segment being sent

Macro Definition Documentation

◆ SSTVENC_ENCODER_FSK_SEGMENT_BEGIN

#define SSTVENC_ENCODER_FSK_SEGMENT_BEGIN (0)

Definition at line 892 of file sstv.c.

Referenced by sstvenc_encoder_begin_fsk(), and sstvenc_encoder_fsk_load_next().

◆ SSTVENC_ENCODER_FSK_SEGMENT_DONE

#define SSTVENC_ENCODER_FSK_SEGMENT_DONE (4)

Definition at line 896 of file sstv.c.

Referenced by sstvenc_encoder_begin_fsk(), sstvenc_encoder_fsk_load_next(), and sstvenc_encoder_next_fsk_pulse().

◆ SSTVENC_ENCODER_FSK_SEGMENT_ID

#define SSTVENC_ENCODER_FSK_SEGMENT_ID (2)

Definition at line 894 of file sstv.c.

Referenced by sstvenc_encoder_fsk_load_next().

◆ SSTVENC_ENCODER_FSK_SEGMENT_PREAMBLE

#define SSTVENC_ENCODER_FSK_SEGMENT_PREAMBLE (1)

Definition at line 893 of file sstv.c.

Referenced by sstvenc_encoder_fsk_load_next().

◆ SSTVENC_ENCODER_FSK_SEGMENT_TAIL

#define SSTVENC_ENCODER_FSK_SEGMENT_TAIL (3)

Definition at line 895 of file sstv.c.

Referenced by sstvenc_encoder_fsk_load_next().

Typedef Documentation

◆ sstvenc_encoder_callback

typedef void sstvenc_encoder_callback(struct sstvenc_encoder *const enc)

Callback routine for SSTV encoder events.

Definition at line 92 of file sstv.h.

Function Documentation

◆ sstvenc_encoder_begin_backporch()

static void sstvenc_encoder_begin_backporch ( struct sstvenc_encoder *const enc )

static

Set up the state machine to begin sending the back-porch sync pulses at the end of the scan line.

Parameters

[in,out] enc SSTV encoder instance

Definition at line 714 of file sstv.c.

                                                                   {
#ifdef _DEBUG_SSTV
        printf("%s: begin row %u back porch\n", __func__, enc->vars.scan.y);
#endif
        sstvenc_encoder_next_scan_seg(enc,
                                      SSTVENC_ENCODER_SCAN_SEGMENT_BACKPORCH);
        sstvenc_encoder_begin_seq(enc, enc->mode->backporch, NULL);
}

References sstvenc_mode::backporch, sstvenc_encoder::mode, sstvenc_encoder::sstvenc_encoder_phase_data::scan, sstvenc_encoder_begin_seq(), sstvenc_encoder_next_scan_seg(), SSTVENC_ENCODER_SCAN_SEGMENT_BACKPORCH, sstvenc_encoder::vars, and sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data::y.

Referenced by sstvenc_encoder_next_image_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_encoder_begin_channel()

static void sstvenc_encoder_begin_channel	(	struct sstvenc_encoder *const	enc,
		uint8_t	segment,
		uint8_t	ch )

static

Set up the state machine for transmitting the given channel of the current scan line.

Parameters

[in,out]	enc	SSTV encoder instance
[in]	ch	SSTV scan line channel being emitted (0-3 inclusive)

Definition at line 586 of file sstv.c.

                                                                       {
#ifdef _DEBUG_SSTV
        printf("%s: begin row %u channel %u\n", __func__, enc->vars.scan.y,
               ch);
#endif
        sstvenc_encoder_next_scan_seg(enc, segment);
        enc->vars.scan.x = 0;
        enc->pulse.duration_ns
            = (uint32_t)((((double)enc->mode->scanline_period_ns[ch])
                          / enc->mode->width)
                         + 0.5);
#ifdef _DEBUG_SSTV
        printf("%s: %" PRIu32 " ns per pixel\n", __func__,
               enc->pulse.duration_ns);
#endif
}

References sstvenc_encoder_pulse::duration_ns, sstvenc_encoder::mode, sstvenc_encoder::pulse, sstvenc_encoder::sstvenc_encoder_phase_data::scan, sstvenc_mode::scanline_period_ns, sstvenc_encoder_next_scan_seg(), sstvenc_encoder::vars, sstvenc_mode::width, sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data::x, and sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data::y.

Referenced by sstvenc_encoder_next_image_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_encoder_begin_frontporch()

static void sstvenc_encoder_begin_frontporch ( struct sstvenc_encoder *const enc )

static

Set up the state machine to begin sending the front-porch sync pulses at the beginning of the scan line.

Parameters

[in,out] enc SSTV encoder instance

Definition at line 677 of file sstv.c.

                                                                    {
#ifdef _DEBUG_SSTV
        printf("%s: begin row %u front porch\n", __func__, enc->vars.scan.y);
#endif
        sstvenc_encoder_next_scan_seg(
            enc, SSTVENC_ENCODER_SCAN_SEGMENT_FRONTPORCH);
        sstvenc_encoder_begin_seq(enc, enc->mode->frontporch, NULL);
}

References sstvenc_mode::frontporch, sstvenc_encoder::mode, sstvenc_encoder::sstvenc_encoder_phase_data::scan, sstvenc_encoder_begin_seq(), sstvenc_encoder_next_scan_seg(), SSTVENC_ENCODER_SCAN_SEGMENT_FRONTPORCH, sstvenc_encoder::vars, and sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data::y.

Referenced by sstvenc_encoder_begin_scanline().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_encoder_begin_fsk()

static void sstvenc_encoder_begin_fsk ( struct sstvenc_encoder *const enc )

static

Set up the state machine for sending the FSK ID.

Parameters

[in,out] enc SSTV encoder instance

Definition at line 976 of file sstv.c.

                                                                         {
        sstvenc_encoder_new_phase(enc, SSTVENC_ENCODER_PHASE_FSK);
        enc->vars.fsk.byte = 0;
        enc->vars.fsk.bit  = 0;
 
        if (enc->fsk_id) {
#ifdef _DEBUG_SSTV
                printf("%s: initialise FSK state\n", __func__);
#endif
                enc->vars.fsk.segment = SSTVENC_ENCODER_FSK_SEGMENT_BEGIN;
                sstvenc_encoder_fsk_load_next(enc);
        } else {
#ifdef _DEBUG_SSTV
                printf("%s: no FSK defined\n", __func__);
#endif
                enc->vars.fsk.segment = SSTVENC_ENCODER_FSK_SEGMENT_DONE;
        }
}

References sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_fsk_data::bit, sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_fsk_data::byte, sstvenc_encoder::sstvenc_encoder_phase_data::fsk, sstvenc_encoder::fsk_id, sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_fsk_data::segment, sstvenc_encoder_fsk_load_next(), SSTVENC_ENCODER_FSK_SEGMENT_BEGIN, SSTVENC_ENCODER_FSK_SEGMENT_DONE, sstvenc_encoder_new_phase(), SSTVENC_ENCODER_PHASE_FSK, and sstvenc_encoder::vars.

Referenced by sstvenc_encoder_on_finalseq_done().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_encoder_begin_gap01()

static void sstvenc_encoder_begin_gap01 ( struct sstvenc_encoder *const enc )

static

Set up the state machine to begin sending the sync pulses that separate channels 0 and 1.

Parameters

[in,out] enc SSTV encoder instance

Definition at line 686 of file sstv.c.

                                                                           {
#ifdef _DEBUG_SSTV
        printf("%s: begin row %u gap 0/1\n", __func__, enc->vars.scan.y);
#endif
        sstvenc_encoder_next_scan_seg(enc,
                                      SSTVENC_ENCODER_SCAN_SEGMENT_GAP01);
        sstvenc_encoder_begin_seq(enc, enc->mode->gap01, NULL);
}

References sstvenc_mode::gap01, sstvenc_encoder::mode, sstvenc_encoder::sstvenc_encoder_phase_data::scan, sstvenc_encoder_begin_seq(), sstvenc_encoder_next_scan_seg(), SSTVENC_ENCODER_SCAN_SEGMENT_GAP01, sstvenc_encoder::vars, and sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data::y.

Referenced by sstvenc_encoder_next_image_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_encoder_begin_gap12()

static void sstvenc_encoder_begin_gap12 ( struct sstvenc_encoder *const enc )

static

Set up the state machine to begin sending the sync pulses that separate channels 1 and 2.

Parameters

[in,out] enc SSTV encoder instance

Definition at line 695 of file sstv.c.

                                                                           {
#ifdef _DEBUG_SSTV
        printf("%s: begin row %u gap 1/2\n", __func__, enc->vars.scan.y);
#endif
        sstvenc_encoder_next_scan_seg(enc,
                                      SSTVENC_ENCODER_SCAN_SEGMENT_GAP12);
        sstvenc_encoder_begin_seq(enc, enc->mode->gap12, NULL);
}

References sstvenc_mode::gap12, sstvenc_encoder::mode, sstvenc_encoder::sstvenc_encoder_phase_data::scan, sstvenc_encoder_begin_seq(), sstvenc_encoder_next_scan_seg(), SSTVENC_ENCODER_SCAN_SEGMENT_GAP12, sstvenc_encoder::vars, and sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data::y.

Referenced by sstvenc_encoder_next_image_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_encoder_begin_gap23()

static void sstvenc_encoder_begin_gap23 ( struct sstvenc_encoder *const enc )

static

Set up the state machine to begin sending the sync pulses that separate channels 2 and 3.

Parameters

[in,out] enc SSTV encoder instance

Definition at line 704 of file sstv.c.

                                                                           {
#ifdef _DEBUG_SSTV
        printf("%s: begin row %u gap 2/3\n", __func__, enc->vars.scan.y);
#endif
        sstvenc_encoder_next_scan_seg(enc,
                                      SSTVENC_ENCODER_SCAN_SEGMENT_GAP23);
        sstvenc_encoder_begin_seq(enc, enc->mode->gap23, NULL);
}

References sstvenc_mode::gap23, sstvenc_encoder::mode, sstvenc_encoder::sstvenc_encoder_phase_data::scan, sstvenc_encoder_begin_seq(), sstvenc_encoder_next_scan_seg(), SSTVENC_ENCODER_SCAN_SEGMENT_GAP23, sstvenc_encoder::vars, and sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data::y.

Referenced by sstvenc_encoder_next_image_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_encoder_begin_image()

static void sstvenc_encoder_begin_image ( struct sstvenc_encoder *const enc )

static

Set up the state machine for the beginning of the image scan.

Parameters

[in,out] enc SSTV encoder instance

Definition at line 569 of file sstv.c.

                                                                           {
#ifdef _DEBUG_SSTV
        printf("%s: begin image scan\n", __func__);
#endif
        enc->phase       = SSTVENC_ENCODER_PHASE_SCAN;
        enc->vars.scan.y = 0;
        sstvenc_encoder_begin_scanline(enc);
}

References sstvenc_encoder::phase, sstvenc_encoder::sstvenc_encoder_phase_data::scan, sstvenc_encoder_begin_scanline(), SSTVENC_ENCODER_PHASE_SCAN, sstvenc_encoder::vars, and sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data::y.

Referenced by sstvenc_encoder_next_pulse(), and sstvenc_encoder_on_initseq_done().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_encoder_begin_scanline()

static void sstvenc_encoder_begin_scanline ( struct sstvenc_encoder *const enc )

static

Set up the state machine for the beginning of a single scan line.

Parameters

[in,out] enc SSTV encoder instance

Definition at line 579 of file sstv.c.

                                                                  {
#ifdef _DEBUG_SSTV
        printf("%s: begin row %u\n", __func__, enc->vars.scan.y);
#endif
        sstvenc_encoder_begin_frontporch(enc);
}

References sstvenc_encoder::sstvenc_encoder_phase_data::scan, sstvenc_encoder_begin_frontporch(), sstvenc_encoder::vars, and sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data::y.

Referenced by sstvenc_encoder_begin_image(), and sstvenc_encoder_next_image_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_encoder_begin_seq()

static void sstvenc_encoder_begin_seq	(	struct sstvenc_encoder *const	enc,
		const struct sstvenc_encoder_pulse *	seq,
		sstvenc_encoder_callback *	on_done )

static

Begin a pulse sequence.

Parameters

[in,out]	enc	SSTV encoder instance
[in]	seq	Pulse sequence, terminated with a 0ns "pulse".
[in]	on_done	Callback to run when the pulse sequence ends.

Definition at line 402 of file sstv.c.

                                                                         {
        enc->seq = seq;
        if ((!enc->seq) || (!enc->seq->duration_ns)) {
#ifdef _DEBUG_SSTV
                printf("%s: empty sequence\n", __func__);
#endif
                if (on_done) {
#ifdef _DEBUG_SSTV
                        printf("%s: calling on_done callback\n", __func__);
#endif
                        /* Nothing to do */
                        on_done(enc);
                }
        } else {
#ifdef _DEBUG_SSTV
                printf("%s: begin sequence %p\n", __func__, (void*)seq);
#endif
                enc->seq_done_cb = on_done;
        }
}

References sstvenc_encoder_pulse::duration_ns, sstvenc_encoder::seq, and sstvenc_encoder::seq_done_cb.

Referenced by sstvenc_encoder_begin_backporch(), sstvenc_encoder_begin_frontporch(), sstvenc_encoder_begin_gap01(), sstvenc_encoder_begin_gap12(), sstvenc_encoder_begin_gap23(), and sstvenc_encoder_next_pulse().

Here is the caller graph for this function:

◆ sstvenc_encoder_begin_vis()

static void sstvenc_encoder_begin_vis ( struct sstvenc_encoder *const enc )

static

Start sending the VIS header.

Parameters

[in,out] enc SSTV encoder instance

Definition at line 453 of file sstv.c.

                                                                         {
#ifdef _DEBUG_SSTV
        printf("%s: begin sending VIS header\n", __func__);
#endif
        enc->phase        = SSTVENC_ENCODER_PHASE_VIS;
        enc->vars.vis.bit = SSTVENC_VIS_BIT_START1;
}

References sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_vis_data::bit, sstvenc_encoder::phase, SSTVENC_ENCODER_PHASE_VIS, SSTVENC_VIS_BIT_START1, sstvenc_encoder::vars, and sstvenc_encoder::sstvenc_encoder_phase_data::vis.

Referenced by sstvenc_encoder_next_pulse().

Here is the caller graph for this function:

◆ sstvenc_encoder_fsk_load_next()

static void sstvenc_encoder_fsk_load_next ( struct sstvenc_encoder *const enc )

static

Determine the value of the next (6-bit) FSK byte to transmit and load it into the state machine.

Parameters

[in,out] enc SSTV encoder instance

Definition at line 900 of file sstv.c.

                                                                             {
        switch (enc->vars.fsk.segment) {
        case SSTVENC_ENCODER_FSK_SEGMENT_BEGIN:
#ifdef _DEBUG_SSTV
                printf("%s: load FSK preamble\n", __func__);
#endif
                enc->vars.fsk.segment = SSTVENC_ENCODER_FSK_SEGMENT_PREAMBLE;
                enc->vars.fsk.byte    = 0;
                enc->vars.fsk.seg_sz  = sizeof(sstvenc_encoder_fsk_preamble);
                /* Fall-thru */
        case SSTVENC_ENCODER_FSK_SEGMENT_PREAMBLE:
                if (enc->vars.fsk.byte < enc->vars.fsk.seg_sz) {
                        enc->vars.fsk.bv
                            = sstvenc_encoder_fsk_preamble[enc->vars.fsk
                                                               .byte];
                        enc->vars.fsk.bit = 0;
#ifdef _DEBUG_SSTV
                        printf("%s: preamble byte 0x%02x\n", __func__,
                               enc->vars.fsk.bv);
#endif
                        break;
                } else {
                        enc->vars.fsk.segment
                            = SSTVENC_ENCODER_FSK_SEGMENT_ID;
                        enc->vars.fsk.seg_sz = strlen(enc->fsk_id);
                        enc->vars.fsk.byte   = 0;
#ifdef _DEBUG_SSTV
                        printf("%s: end of preamble, load FSK ID byte 0\n",
                               __func__);
#endif
                }
                /* Fall-thru */
        case SSTVENC_ENCODER_FSK_SEGMENT_ID:
                if (enc->vars.fsk.byte < enc->vars.fsk.seg_sz) {
#ifdef _DEBUG_SSTV
                        printf("%s: FSK ID byte %u = 0x%02x\n", __func__,
                               enc->vars.fsk.byte, enc->vars.fsk.bv);
#endif
                        enc->vars.fsk.bv
                            = (uint8_t)(enc->fsk_id[enc->vars.fsk.byte])
                              - 0x20;
                        enc->vars.fsk.bit = 0;
                        break;
                } else {
#ifdef _DEBUG_SSTV
                        printf("%s: end of FSK ID, load FSK TAIL byte 0\n",
                               __func__);
#endif
                        enc->vars.fsk.segment
                            = SSTVENC_ENCODER_FSK_SEGMENT_TAIL;
                        enc->vars.fsk.seg_sz
                            = sizeof(sstvenc_encoder_fsk_tail);
                        enc->vars.fsk.byte = 0;
                }
                /* Fall-thru */
        case SSTVENC_ENCODER_FSK_SEGMENT_TAIL:
                if (enc->vars.fsk.byte < enc->vars.fsk.seg_sz) {
#ifdef _DEBUG_SSTV
                        printf("%s: FSK TAIL byte %u = 0x%02x\n", __func__,
                               enc->vars.fsk.byte, enc->vars.fsk.bv);
#endif
                        enc->vars.fsk.bv
                            = sstvenc_encoder_fsk_tail[enc->vars.fsk.byte];
                        enc->vars.fsk.bit = 0;
                        break;
                } else {
#ifdef _DEBUG_SSTV
                        printf("%s: end of FSK TAIL\n", __func__);
#endif
                        enc->vars.fsk.segment
                            = SSTVENC_ENCODER_FSK_SEGMENT_DONE;
                        enc->vars.fsk.byte = 0;
                }
        }
}

Referenced by sstvenc_encoder_begin_fsk(), and sstvenc_encoder_next_fsk_pulse().

Here is the caller graph for this function:

◆ sstvenc_encoder_init()

void sstvenc_encoder_init	(	struct sstvenc_encoder *const	enc,
		const struct sstvenc_mode *	mode,
		const char *	fsk_id,
		const uint8_t *	framebuffer )

Initialise the SSTV encoder with the given parameters.

Parameters

[in,out]	enc	SSTV encoder context to initialise
[in]	mode	SSTV mode to encode
[in]	fsk_id	FSK ID to send at the end, NULL to disable.
[in]	framebuffer	Framebuffer data representing the image.

Definition at line 392 of file sstv.c.

                                                      {
        memset(enc, 0, sizeof(struct sstvenc_encoder));
        enc->mode        = mode;
        enc->fsk_id      = fsk_id;
        enc->framebuffer = framebuffer;
        enc->phase       = SSTVENC_ENCODER_PHASE_INIT;
}

References sstvenc_encoder::framebuffer, sstvenc_encoder::fsk_id, sstvenc_encoder::mode, sstvenc_encoder::phase, and SSTVENC_ENCODER_PHASE_INIT.

Referenced by sstvenc_modulator_init().

Here is the caller graph for this function:

◆ sstvenc_encoder_new_phase()

static void sstvenc_encoder_new_phase	(	struct sstvenc_encoder *const	enc,
		uint8_t	phase )

static

Transition the encoder to the next phase. Used as a debugging attachment point in development.

Parameters

[out]	enc	SSTV encoder context
[in]	phase	New phase, SSTV Encoder Phases

Definition at line 384 of file sstv.c.

                                                                           {
#ifdef _DEBUG_SSTV
        printf("%s: entering phase 0x%02x\n", __func__, phase);
#endif
        enc->phase = phase;
}

References sstvenc_encoder::phase.

Referenced by sstvenc_encoder_begin_fsk(), and sstvenc_encoder_next_pulse().

Here is the caller graph for this function:

◆ sstvenc_encoder_next_channel_pulse()

static const struct sstvenc_encoder_pulse * sstvenc_encoder_next_channel_pulse	(	struct sstvenc_encoder *const	enc,
		uint8_t	ch )

static

Compute the frequency of the next pulse for the current pixel in the indicated scan line.

Parameters

[in,out]	enc	SSTV encoder instance
[in]	ch	Scan line channel (0-3 inclusive)

Returns: Pointer to SSTV pixel pulse.

Return values

NULL	End of scan segment.

Definition at line 605 of file sstv.c.

                                                                     {
 
        if (enc->vars.scan.x >= enc->mode->width) {
                /* End of the channel */
                return NULL;
        }
 
        uint32_t idx = sstvenc_get_pixel_posn(enc->mode, enc->vars.scan.x,
                                              enc->vars.scan.y);
        uint8_t  value;
 
        switch (enc->mode->colour_space_order & SSTVENC_CSO_MASK_MODE) {
        case SSTVENC_CSO_MODE_YUV2: {
                const uint16_t row_length = 3 * enc->mode->width;
                assert(!(enc->vars.scan.y % 2));
 
                switch (
                    SSTVENC_MODE_GET_CH(ch, enc->mode->colour_space_order)) {
                case SSTVENC_CSO_CH_NONE:
                        /* Channel not used */
                        return NULL;
                case SSTVENC_CSO_CH_Y:
                        value = enc->framebuffer[idx];
                        break;
                case SSTVENC_CSO_CH_Y2:
                        value = enc->framebuffer[idx + row_length];
                        break;
                case SSTVENC_CSO_CH_U:
                        value = (enc->framebuffer[idx + 1]
                                 + enc->framebuffer[idx + row_length + 1])
                                / 2.0;
                        break;
                case SSTVENC_CSO_CH_V:
                        value = (enc->framebuffer[idx + 2]
                                 + enc->framebuffer[idx + row_length + 2])
                                / 2.0;
                        break;
                default:
                        value = 0.0;
                }
                break;
        }
        default:
                switch (
                    SSTVENC_MODE_GET_CH(ch, enc->mode->colour_space_order)) {
                case SSTVENC_CSO_CH_NONE:
                        /* Channel not used */
                        return NULL;
                case SSTVENC_CSO_CH_Y:
                case SSTVENC_CSO_CH_R:
                        value = enc->framebuffer[idx];
                        break;
                case SSTVENC_CSO_CH_U:
                case SSTVENC_CSO_CH_G:
                        value = enc->framebuffer[idx + 1];
                        break;
                case SSTVENC_CSO_CH_V:
                case SSTVENC_CSO_CH_B:
                        value = enc->framebuffer[idx + 2];
                        break;
                default:
                        value = 0.0;
                }
        }
 
        enc->pulse.frequency = sstvenc_level_freq(value);
        enc->vars.scan.x++;
        return &(enc->pulse);
}

References sstvenc_mode::colour_space_order, sstvenc_encoder::framebuffer, sstvenc_encoder_pulse::frequency, sstvenc_encoder::mode, sstvenc_encoder::pulse, sstvenc_encoder::sstvenc_encoder_phase_data::scan, SSTVENC_CSO_CH_B, SSTVENC_CSO_CH_G, SSTVENC_CSO_CH_NONE, SSTVENC_CSO_CH_R, SSTVENC_CSO_CH_U, SSTVENC_CSO_CH_V, SSTVENC_CSO_CH_Y, SSTVENC_CSO_CH_Y2, SSTVENC_CSO_MASK_MODE, SSTVENC_CSO_MODE_YUV2, sstvenc_get_pixel_posn(), sstvenc_level_freq(), SSTVENC_MODE_GET_CH, sstvenc_encoder::vars, sstvenc_mode::width, sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data::x, and sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data::y.

Referenced by sstvenc_encoder_next_image_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_encoder_next_fsk_pulse()

static const struct sstvenc_encoder_pulse * sstvenc_encoder_next_fsk_pulse ( struct sstvenc_encoder *const enc )

static

Compute the frequency of the next pulse for the FSK ID according to the state machine.

Parameters

[in,out] enc SSTV encoder instance

Returns: Pointer to FSK pulse.

Return values

NULL	End of FSK ID.

Definition at line 996 of file sstv.c.

                                                                  {
        if (enc->vars.fsk.bit >= 6) {
#ifdef _DEBUG_SSTV
                printf("%s: end of FSK byte\n", __func__);
#endif
                enc->vars.fsk.byte++;
                sstvenc_encoder_fsk_load_next(enc);
        }
 
        if (enc->vars.fsk.segment >= SSTVENC_ENCODER_FSK_SEGMENT_DONE) {
                /* This is the end of the FSK ID */
#ifdef _DEBUG_SSTV
                printf("%s: end of FSK\n", __func__);
#endif
                return NULL;
        }
 
        /* Next bit */
        if (enc->vars.fsk.bv & (1 << enc->vars.fsk.bit)) {
#ifdef _DEBUG_SSTV
                printf("%s: FSK bit value 1\n", __func__);
#endif
                enc->pulse.frequency = SSTVENC_FREQ_FSKID_BIT1;
        } else {
#ifdef _DEBUG_SSTV
                printf("%s: FSK bit value 0\n", __func__);
#endif
                enc->pulse.frequency = SSTVENC_FREQ_FSKID_BIT0;
        }
        enc->pulse.duration_ns = 1000 * SSTVENC_PERIOD_FSKID_BIT;
        enc->vars.fsk.bit++;
 
        return &(enc->pulse);
}

Referenced by sstvenc_encoder_next_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_encoder_next_image_pulse()

static const struct sstvenc_encoder_pulse * sstvenc_encoder_next_image_pulse ( struct sstvenc_encoder *const enc )

static

Compute the frequency of the next pulse for the image according to the state machine.

Parameters

[in,out] enc SSTV encoder instance

Returns: Pointer to SSTV image pulse.

Return values

NULL	End of image scan.

Definition at line 740 of file sstv.c.

                                                                    {
        const struct sstvenc_encoder_pulse* pulse = NULL;
restart:
        switch (enc->vars.scan.segment) {
        case SSTVENC_ENCODER_SCAN_SEGMENT_FRONTPORCH:
                pulse = sstvenc_encoder_next_seq_pulse(enc);
#ifdef _DEBUG_SSTV
                printf("%s: front porch pulse = %p (*, %u)\n", __func__,
                       (void*)pulse, enc->vars.scan.y);
#endif
                if (pulse) {
                        return pulse;
                }
                /* Fall-thru */
                sstvenc_encoder_begin_channel(
                    enc, SSTVENC_ENCODER_SCAN_SEGMENT_CH0, 0);
        case SSTVENC_ENCODER_SCAN_SEGMENT_CH0:
                pulse = sstvenc_encoder_next_channel_pulse(enc, 0);
#ifdef _DEBUG_SSTV
                printf("%s: ch0 pulse = %p (%u, %u)\n", __func__,
                       (void*)pulse, enc->vars.scan.x, enc->vars.scan.y);
#endif
                if (pulse) {
                        return pulse;
                }
                /* Fall-thru */
                sstvenc_encoder_begin_gap01(enc);
        case SSTVENC_ENCODER_SCAN_SEGMENT_GAP01:
                pulse = sstvenc_encoder_next_seq_pulse(enc);
#ifdef _DEBUG_SSTV
                printf("%s: gap 0/1 pulse = %p (*, %u)\n", __func__,
                       (void*)pulse, enc->vars.scan.y);
#endif
                if (pulse) {
                        return pulse;
                }
                /* Fall-thru */
                sstvenc_encoder_begin_channel(
                    enc, SSTVENC_ENCODER_SCAN_SEGMENT_CH1, 1);
        case SSTVENC_ENCODER_SCAN_SEGMENT_CH1:
                pulse = sstvenc_encoder_next_channel_pulse(enc, 1);
#ifdef _DEBUG_SSTV
                printf("%s: ch1 pulse = %p (%u, %u)\n", __func__,
                       (void*)pulse, enc->vars.scan.x, enc->vars.scan.y);
#endif
                if (pulse) {
                        return pulse;
                }
                /* Fall-thru */
                sstvenc_encoder_begin_gap12(enc);
        case SSTVENC_ENCODER_SCAN_SEGMENT_GAP12:
                pulse = sstvenc_encoder_next_seq_pulse(enc);
#ifdef _DEBUG_SSTV
                printf("%s: gap 1/2 pulse = %p (*, %u)\n", __func__,
                       (void*)pulse, enc->vars.scan.y);
#endif
                if (pulse) {
                        return pulse;
                }
                /* Fall-thru */
                sstvenc_encoder_begin_channel(
                    enc, SSTVENC_ENCODER_SCAN_SEGMENT_CH2, 2);
        case SSTVENC_ENCODER_SCAN_SEGMENT_CH2:
                pulse = sstvenc_encoder_next_channel_pulse(enc, 2);
#ifdef _DEBUG_SSTV
                printf("%s: ch2 pulse = %p (%u, %u)\n", __func__,
                       (void*)pulse, enc->vars.scan.x, enc->vars.scan.y);
#endif
                if (pulse) {
                        return pulse;
                }
                /* Fall-thru */
                sstvenc_encoder_begin_gap23(enc);
        case SSTVENC_ENCODER_SCAN_SEGMENT_GAP23:
                pulse = sstvenc_encoder_next_seq_pulse(enc);
#ifdef _DEBUG_SSTV
                printf("%s: gap 2/3 pulse = %p (*, %u)\n", __func__,
                       (void*)pulse, enc->vars.scan.y);
#endif
                if (pulse) {
                        return pulse;
                }
                /* Fall-thru */
                sstvenc_encoder_next_scan_seg(
                    enc, SSTVENC_ENCODER_SCAN_SEGMENT_CH3);
                sstvenc_encoder_begin_channel(
                    enc, SSTVENC_ENCODER_SCAN_SEGMENT_CH3, 3);
        case SSTVENC_ENCODER_SCAN_SEGMENT_CH3:
                pulse = sstvenc_encoder_next_channel_pulse(enc, 3);
#ifdef _DEBUG_SSTV
                printf("%s: ch3 pulse = %p (%u, %u)\n", __func__,
                       (void*)pulse, enc->vars.scan.x, enc->vars.scan.y);
#endif
                if (pulse) {
                        return pulse;
                }
                /* Fall-thru */
                sstvenc_encoder_begin_backporch(enc);
        case SSTVENC_ENCODER_SCAN_SEGMENT_BACKPORCH:
#ifdef _DEBUG_SSTV
                printf("%s: back porch pulse = %p (*, %u)\n", __func__,
                       (void*)pulse, enc->vars.scan.y);
#endif
                pulse = sstvenc_encoder_next_seq_pulse(enc);
#ifdef _DEBUG_SSTV
                printf("%s: back porch pulse = %p\n", __func__, (void*)pulse);
#endif
                if (pulse) {
                        return pulse;
                }
                /* Fall-thru */
        default:
#ifdef _DEBUG_SSTV
                printf("%s: end of scan line\n", __func__);
#endif
                sstvenc_encoder_next_scan_seg(
                    enc, SSTVENC_ENCODER_SCAN_SEGMENT_NEXT);
                break;
        }
 
        /* If we reach here, that's the end of the scan line */
        enc->vars.scan.x = 0;
        switch (enc->mode->colour_space_order & SSTVENC_CSO_MASK_MODE) {
        case SSTVENC_CSO_MODE_YUV2:
#ifdef _DEBUG_SSTV
                printf("%s: YUV2 increment two rows\n", __func__);
#endif
                enc->vars.scan.y += 2;
                break;
        default:
#ifdef _DEBUG_SSTV
                printf("%s: increment single row\n", __func__);
#endif
                enc->vars.scan.y++;
        }
 
        if (enc->vars.scan.y < enc->mode->height) {
                /* Go again */
#ifdef _DEBUG_SSTV
                printf("%s: repeat for row %u\n", __func__, enc->vars.scan.y);
#endif
                sstvenc_encoder_begin_scanline(enc);
                goto restart;
        }
 
        /* That's it! */
#ifdef _DEBUG_SSTV
        printf("%s: end of image\n", __func__);
#endif
        return NULL;
}

Referenced by sstvenc_encoder_next_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_encoder_next_pulse()

const struct sstvenc_encoder_pulse * sstvenc_encoder_next_pulse ( struct sstvenc_encoder *const enc )

Compute the next pulse to be emitted. This value returns NULL when there are no more pulses to transmit.

Definition at line 1032 of file sstv.c.

                                                              {
        const struct sstvenc_encoder_pulse* pulse = NULL;
        switch (enc->phase) {
        case SSTVENC_ENCODER_PHASE_INIT:
#ifdef _DEBUG_SSTV
                printf("%s: initialise encoder\n", __func__);
#endif
                sstvenc_encoder_begin_vis(enc);
                /* Fall-thru */
        case SSTVENC_ENCODER_PHASE_VIS:
#ifdef _DEBUG_SSTV
                printf("%s: next VIS pulse\n", __func__);
#endif
                pulse = sstvenc_encoder_next_vis_pulse(enc);
                if (pulse) {
                        break;
                } else {
                        sstvenc_encoder_begin_seq(
                            enc, enc->mode->initseq,
                            sstvenc_encoder_on_initseq_done);
                }
                /* Fall-thru */
#ifdef _DEBUG_SSTV
                printf("%s: end of VIS\n", __func__);
#endif
        case SSTVENC_ENCODER_PHASE_INITSEQ:
                pulse = sstvenc_encoder_next_seq_pulse(enc);
                if (pulse) {
                        break;
                } else {
                        sstvenc_encoder_begin_image(enc);
                }
                /* Fall-thru */
#ifdef _DEBUG_SSTV
                printf("%s: end of init sequence\n", __func__);
#endif
                break;
        case SSTVENC_ENCODER_PHASE_SCAN:
                pulse = sstvenc_encoder_next_image_pulse(enc);
                if (pulse) {
                        break;
                } else {
                        sstvenc_encoder_begin_seq(
                            enc, enc->mode->finalseq,
                            sstvenc_encoder_on_finalseq_done);
                }
#ifdef _DEBUG_SSTV
                printf("%s: end of image scan\n", __func__);
#endif
                /* Fall-thru */
        case SSTVENC_ENCODER_PHASE_FINALSEQ:
                pulse = sstvenc_encoder_next_seq_pulse(enc);
                if (pulse) {
                        break;
                }
#ifdef _DEBUG_SSTV
                printf("%s: end of final sequence\n", __func__);
#endif
                /* Fall-thru */
        case SSTVENC_ENCODER_PHASE_FSK:
                pulse = sstvenc_encoder_next_fsk_pulse(enc);
                if (pulse) {
                        break;
                }
                /* Fall-thru */
#ifdef _DEBUG_SSTV
                printf("%s: end of FSK ID\n", __func__);
#endif
        default:
                sstvenc_encoder_new_phase(enc, SSTVENC_ENCODER_PHASE_DONE);
                break;
        }
 
        return pulse;
}

References sstvenc_mode::finalseq, sstvenc_mode::initseq, sstvenc_encoder::mode, sstvenc_encoder::phase, sstvenc_encoder_begin_image(), sstvenc_encoder_begin_seq(), sstvenc_encoder_begin_vis(), sstvenc_encoder_new_phase(), sstvenc_encoder_next_fsk_pulse(), sstvenc_encoder_next_image_pulse(), sstvenc_encoder_next_seq_pulse(), sstvenc_encoder_next_vis_pulse(), sstvenc_encoder_on_finalseq_done(), sstvenc_encoder_on_initseq_done(), SSTVENC_ENCODER_PHASE_DONE, SSTVENC_ENCODER_PHASE_FINALSEQ, SSTVENC_ENCODER_PHASE_FSK, SSTVENC_ENCODER_PHASE_INIT, SSTVENC_ENCODER_PHASE_INITSEQ, SSTVENC_ENCODER_PHASE_SCAN, and SSTVENC_ENCODER_PHASE_VIS.

Referenced by sstvenc_modulator_next_tone().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_encoder_next_scan_seg()

static void sstvenc_encoder_next_scan_seg	(	struct sstvenc_encoder *const	enc,
		uint8_t	next_segment )

static

Initialise the state for the next scan segment. Used as a debugging attachment point in development.

Parameters

[in,out]	enc	SSTV encoder instance
[in]	next_segment	The next scan line segment. SSTV scan line segments

Definition at line 723 of file sstv.c.

                                                                {
#ifdef _DEBUG_SSTV
        printf("%s: entering segment 0x%02x\n", __func__, next_segment);
#endif
        enc->vars.scan.segment = next_segment;
}

References sstvenc_encoder::sstvenc_encoder_phase_data::scan, sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_scan_data::segment, and sstvenc_encoder::vars.

Referenced by sstvenc_encoder_begin_backporch(), sstvenc_encoder_begin_channel(), sstvenc_encoder_begin_frontporch(), sstvenc_encoder_begin_gap01(), sstvenc_encoder_begin_gap12(), sstvenc_encoder_begin_gap23(), and sstvenc_encoder_next_image_pulse().

Here is the caller graph for this function:

◆ sstvenc_encoder_next_seq_pulse()

static const struct sstvenc_encoder_pulse * sstvenc_encoder_next_seq_pulse ( struct sstvenc_encoder *const enc )

static

Emit the next pulse in the pulse sequence. If there are no more pulses, call the call-back function (if defined).

Parameters

[in,out] enc SSTV encoder instance

Returns: Next pulse in the sequence

Return values

NULL	No more pulses in the sequence.

Definition at line 426 of file sstv.c.

                                                                  {
        if (enc->seq && enc->seq->duration_ns) {
                const struct sstvenc_encoder_pulse* pulse = enc->seq;
                enc->seq++;
#ifdef _DEBUG_SSTV
                printf("%s: returning pulse at %p\n", __func__, (void*)pulse);
#endif
                return pulse;
        } else if (enc->seq_done_cb) {
#ifdef _DEBUG_SSTV
                printf("%s: end of pulse sequence, calling callback\n",
                       __func__, (void*)(enc->seq_done_cb));
#endif
                sstvenc_encoder_callback* seq_done_cb = enc->seq_done_cb;
                enc->seq_done_cb                      = NULL;
                enc->seq                              = NULL;
                seq_done_cb(enc);
        } else {
#ifdef _DEBUG_SSTV
                printf("%s: end of pulse sequence, no callback\n", __func__);
#endif
                enc->seq_done_cb = NULL;
                enc->seq         = NULL;
        }
        return NULL;
}

References sstvenc_encoder_pulse::duration_ns, sstvenc_encoder::seq, and sstvenc_encoder::seq_done_cb.

Referenced by sstvenc_encoder_next_image_pulse(), and sstvenc_encoder_next_pulse().

Here is the caller graph for this function:

◆ sstvenc_encoder_next_vis_pulse()

static const struct sstvenc_encoder_pulse * sstvenc_encoder_next_vis_pulse ( struct sstvenc_encoder *const enc )

static

Determine and emit the next VIS header pulse to be sent.

Parameters

[in,out] enc SSTV encoder instance

Returns: Pointer to SSTV VIS header pulse frequency (in Hz) and duration (in ns)

Return values

NULL	End of VIS header.

Definition at line 488 of file sstv.c.

                                                                  {
        switch (enc->vars.vis.bit) {
        case SSTVENC_VIS_BIT_START1:
#ifdef _DEBUG_SSTV
                printf("%s: VIS header start bit 1\n", __func__);
#endif
                enc->pulse.frequency   = SSTVENC_FREQ_VIS_START;
                enc->pulse.duration_ns = 1000 * SSTVENC_PERIOD_VIS_START;
                enc->vars.vis.bit++;
                return &(enc->pulse);
        case SSTVENC_VIS_BIT_START2:
#ifdef _DEBUG_SSTV
                printf("%s: VIS header start bit 2\n", __func__);
#endif
                enc->pulse.frequency   = SSTVENC_FREQ_SYNC;
                enc->pulse.duration_ns = 1000 * SSTVENC_PERIOD_VIS_SYNC;
                enc->vars.vis.bit++;
                return &(enc->pulse);
        case SSTVENC_VIS_BIT_START3:
#ifdef _DEBUG_SSTV
                printf("%s: VIS header start bit 3\n", __func__);
#endif
                enc->pulse.frequency   = SSTVENC_FREQ_VIS_START;
                enc->pulse.duration_ns = 1000 * SSTVENC_PERIOD_VIS_START;
                enc->vars.vis.bit++;
                return &(enc->pulse);
        case SSTVENC_VIS_BIT_START4:
#ifdef _DEBUG_SSTV
                printf("%s: VIS header start bit 4\n", __func__);
#endif
                enc->pulse.frequency   = SSTVENC_FREQ_SYNC;
                enc->pulse.duration_ns = 1000 * SSTVENC_PERIOD_VIS_BIT;
                enc->vars.vis.bit++;
                return &(enc->pulse);
        case SSTVENC_VIS_BIT_DATA1:
        case SSTVENC_VIS_BIT_DATA2:
        case SSTVENC_VIS_BIT_DATA3:
        case SSTVENC_VIS_BIT_DATA4:
        case SSTVENC_VIS_BIT_DATA5:
        case SSTVENC_VIS_BIT_DATA6:
        case SSTVENC_VIS_BIT_DATA7:
#ifdef _DEBUG_SSTV
                printf("%s: VIS header data bit\n", __func__);
#endif
                enc->pulse.frequency   = sstvenc_encoder_vis_data_freq(enc);
                enc->pulse.duration_ns = 1000 * SSTVENC_PERIOD_VIS_BIT;
                enc->vars.vis.bit++;
                return &(enc->pulse);
        case SSTVENC_VIS_BIT_PARITY:
#ifdef _DEBUG_SSTV
                printf("%s: VIS header parity bit\n", __func__);
#endif
                enc->pulse.frequency   = sstvenc_encoder_vis_parity_freq(enc);
                enc->pulse.duration_ns = 1000 * SSTVENC_PERIOD_VIS_BIT;
                enc->vars.vis.bit++;
                return &(enc->pulse);
        case SSTVENC_VIS_BIT_STOP:
#ifdef _DEBUG_SSTV
                printf("%s: VIS header stop bit\n", __func__);
#endif
                enc->pulse.frequency   = SSTVENC_FREQ_SYNC;
                enc->pulse.duration_ns = 1000 * SSTVENC_PERIOD_VIS_BIT;
                enc->vars.vis.bit++;
                return &(enc->pulse);
        default:
#ifdef _DEBUG_SSTV
                printf("%s: VIS header is finished\n", __func__);
#endif
                /* This is the end of the VIS header */
                return NULL;
        }
}

References sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_vis_data::bit, sstvenc_encoder_pulse::duration_ns, sstvenc_encoder_pulse::frequency, sstvenc_encoder::pulse, sstvenc_encoder_vis_data_freq(), sstvenc_encoder_vis_parity_freq(), SSTVENC_FREQ_SYNC, SSTVENC_FREQ_VIS_START, SSTVENC_PERIOD_VIS_BIT, SSTVENC_PERIOD_VIS_START, SSTVENC_PERIOD_VIS_SYNC, SSTVENC_VIS_BIT_DATA1, SSTVENC_VIS_BIT_DATA2, SSTVENC_VIS_BIT_DATA3, SSTVENC_VIS_BIT_DATA4, SSTVENC_VIS_BIT_DATA5, SSTVENC_VIS_BIT_DATA6, SSTVENC_VIS_BIT_DATA7, SSTVENC_VIS_BIT_PARITY, SSTVENC_VIS_BIT_START1, SSTVENC_VIS_BIT_START2, SSTVENC_VIS_BIT_START3, SSTVENC_VIS_BIT_START4, SSTVENC_VIS_BIT_STOP, sstvenc_encoder::vars, and sstvenc_encoder::sstvenc_encoder_phase_data::vis.

Referenced by sstvenc_encoder_next_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_encoder_on_finalseq_done()

static void sstvenc_encoder_on_finalseq_done ( struct sstvenc_encoder *const enc )

static

Handle the end of the end-of-image pulse sequence. This triggers a transition to sending the FSK ID.

Parameters

[in,out] enc SSTV encoder instance

Definition at line 732 of file sstv.c.

                                                                    {
#ifdef _DEBUG_SSTV
        printf("%s: end of final image sequence\n", __func__);
#endif
        sstvenc_encoder_begin_fsk(enc);
}

References sstvenc_encoder_begin_fsk().

Referenced by sstvenc_encoder_next_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_encoder_on_initseq_done()

static void sstvenc_encoder_on_initseq_done ( struct sstvenc_encoder *const enc )

static

End of initialisation pulse sequence. This signals the beginning of the image scan.

Parameters

[in,out] enc SSTV encoder instance

Definition at line 562 of file sstv.c.

                                                                   {
#ifdef _DEBUG_SSTV
        printf("%s: initial sequence done\n", __func__);
#endif
        sstvenc_encoder_begin_image(enc);
}

References sstvenc_encoder_begin_image().

Referenced by sstvenc_encoder_next_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sstvenc_encoder_vis_data_freq()

static uint32_t sstvenc_encoder_vis_data_freq ( struct sstvenc_encoder *const enc )

static

Compute the frequency for the next VIS data bit.

Parameters

[in,out] enc SSTV encoder instance

Returns: SSTV VIS header data bit frequency in Hz.

Definition at line 462 of file sstv.c.

                                                                 {
        uint8_t bit = enc->vars.vis.bit - SSTVENC_VIS_BIT_DATA1;
        if (enc->mode->vis_code & (1 << bit)) {
                return SSTVENC_FREQ_VIS_BIT1;
        } else {
                return SSTVENC_FREQ_VIS_BIT0;
        }
}

References sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_vis_data::bit, sstvenc_encoder::mode, SSTVENC_FREQ_VIS_BIT0, SSTVENC_FREQ_VIS_BIT1, SSTVENC_VIS_BIT_DATA1, sstvenc_encoder::vars, sstvenc_encoder::sstvenc_encoder_phase_data::vis, and sstvenc_mode::vis_code.

Referenced by sstvenc_encoder_next_vis_pulse().

Here is the caller graph for this function:

◆ sstvenc_encoder_vis_parity_freq()

static uint32_t sstvenc_encoder_vis_parity_freq ( struct sstvenc_encoder *const enc )

static

Compute the frequency for the VIS parity bit. The 8th bit of the VIS header is used to invert the parity for modes that require it.

Parameters

[in,out] enc SSTV encoder instance

Returns: SSTV VIS header parity bit frequency in Hz.

Definition at line 472 of file sstv.c.

                                                                   {
        uint8_t ones = 0;
        for (uint8_t i = 0; i < 8; i++) {
                if (enc->mode->vis_code & (1 << i)) {
                        ones++;
                }
        }
 
        if ((ones % 2) == 1) {
                return SSTVENC_FREQ_VIS_BIT1;
        } else {
                return SSTVENC_FREQ_VIS_BIT0;
        }
}

References sstvenc_encoder::mode, SSTVENC_FREQ_VIS_BIT0, SSTVENC_FREQ_VIS_BIT1, and sstvenc_mode::vis_code.

Referenced by sstvenc_encoder_next_vis_pulse().

Here is the caller graph for this function:

Variable Documentation

◆ bit [1/2]

uint8_t sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_fsk_data::bit

The current bit of the byte being sent

Definition at line 173 of file sstv.h.

Referenced by sstvenc_encoder_begin_fsk(), sstvenc_encoder_fsk_load_next(), and sstvenc_encoder_next_fsk_pulse().

◆ bit [2/2]

uint8_t sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_vis_data::bit

The current bit being sent

Definition at line 129 of file sstv.h.

Referenced by sstvenc_encoder_begin_vis(), sstvenc_encoder_next_vis_pulse(), and sstvenc_encoder_vis_data_freq().

◆ bv

uint8_t sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_fsk_data::bv

The current byte value being sent

Definition at line 168 of file sstv.h.

Referenced by sstvenc_encoder_fsk_load_next(), and sstvenc_encoder_next_fsk_pulse().

◆ byte

uint8_t sstvenc_encoder::sstvenc_encoder_phase_data::sstvenc_encoder_phase_fsk_data::byte

The current byte position being sent

Definition at line 163 of file sstv.h.

Referenced by sstvenc_encoder_begin_fsk(), sstvenc_encoder_fsk_load_next(), and sstvenc_encoder_next_fsk_pulse().

◆ framebuffer

const uint8_t* sstvenc_encoder::framebuffer

The framebuffer holding the image to be sent. The image is assumed to be in the correct format for the SSTV mode, i.e. correct dimensions, channel count and colour space.

For colour SSTV modes, the values are interleaved for each channel, so c0, c1, c2; for the first pixel, then c0, c1, c2 for the second, etc. Use SSTVENC_MODE_GET_CH to determine what channel is what.

Definition at line 115 of file sstv.h.

Referenced by sstvenc_encoder_init(), and sstvenc_encoder_next_channel_pulse().