Всё об устройстве и работе SSTV с примерами на Python

SSTV (slow-scan television) — телевидение с медленной разверткой, узкополосный формат передачи данных, позволяющий передавать изображения через эфир. В этой статье будут рассмотрены подробности кодирования, декодирования SSTV-сигнала.

Статья может быть интересна радиолюбителям, желающим познакомиться с новым форматом связи, а также тем, кто хочет в подробностях понять как же работает эта технология.

Введение

Телевидение — технология передачи визуальной информации посредством радиосвязи, включающая в себя преобразование изображения в сигнал, его передачу в эфире и последующее декодирование с восстановлением исходного изображения на принимающем устройстве.

Технология SSTV базируется на схожих с классическим телесигналом принципах.

Телевидение, как таковое, подразумевает, что происходит передача изображения; в частности в обычном телесигнале изображение передается покадрово, по 25 кадров в секунду.

Каждый кадр, в свою очередь, передается построчно. В строках содержится информация о яркости цветовых каналов (в частности яркость и цветоразностный сигнал при передаче YCbCr).

Для передачи всей этой информации требуется достаточно широкая полоса пропускания сигнала, а также высокочастотное декодирование. К примеру, для SECAM необходима полоса шириной 6.5 МГц.

Отличительной особенностью SSTV является то, что используется относительно узкая полоса пропускания, в единицы килогерц, что в свою очередь может передаваться в слышимом для человека диапазоне частот. И, как следствие использования узкополосной передачи, является скорость передачи кадра, которая может варьироваться от десятков секунд, до нескольких минут на один кадр. По этой причине SSTV используется для передачи одиночных изображений.

Необходимо упомянуть, что технология SSTV использовалась на заре освоения космоса, когда технологии еще не позволяли передавать и обрабатывать широкополосные сигналы; например фотография обратной (темной) стороны Луны была передана посредством телевидения с медленной разверткой.

С тех пор принципы SSTV не претерпели фундаментальных изменений, изменился формат и способы кодирования строк и цветности.

На момент написания статьи технология активно используется радиолюбителями.

Области применения

SSTV в основном используется радиолюбителями, когда романтика телеграфной и телефонной передачи надоедает и хочется попробовать чего-то нового и необычного; например попытаться увидеться с корреспондентом, находящегося за тысячи километров по ту сторону радиоэфира, либо же отправить ему через эфир свою QSL-карточку (открытка с рапортом, диапазоном и позывными, подтверждающая факт проведения связи в эфире). Также популярен  прием изображений с Международной Космической Станции на диапазоне 2м (144 МГц); передачи, как правило, приурочены к праздничным и памятным событиям.

Также, технология SSTV может быть использована как средство передачи данных последнего шанса, в экстренных ситуациях, когда, например, необходимо передать карты, схемы, фотографии, и т.д., а использование других каналов связи сильно затруднено и/или невозможно.

Принципы работы SSTV

В основе формирования SSTV сигнала лежит использование FSK (Frequency Shift Keying) — частотной манипуляции. Данные определяются тоном (частотой) сигнала, меняющегося во времени; при этом частотная манипуляция обладает свойствами помехоустойчивой, т.к. помехи влияют на амплитуду несущего сигнала, а не на его частоту.

Кодирование цвета

При кодировании изображения, последнее разбивается на отдельные цветовые каналы яркости цвета или цветоразностного сигнала. Далее, в зависимости от яркости канала формируется тон, высота которого пропорционально яркости канала; чем ярче — тем выше тон.

В SSTV яркость канала разбивается на 255 значений, соответственно одна цветовая строка будет содержать в себе тональности с шагом, кратным 1/255. Например широкополосный формат SSTV имеет диапазон тонов от 1.5 КГц до 2.3 КГц, таким образом, получается диапазон в 800 Гц (2300 — 1500 = 800) и 3.137 Гц (800 / 255 = 3.137) на одну ступень яркости.

В случае узкополосных форматов, диапазон частот составляет 256 Гц (от 2.044 КГц до 2.3 КГц), соответственно одному шагу яркости соответствует 1 Гц.

Рисунок 1: Соотношение частоты яркости сигнала.

На рисунке 1 приведен наглядный пример соотношения частот и яркости канала.

Структура сигнала

Сигнал SSTV состоит из:

1. заголовка, по которому приемник определяет начало и формат передаваемого сигнала, относительно которого будет происходить декодирование строк;

2. импульса синхронизации строки;

3. последовательно закодированных строк изображения.

Заголовок сигнала

Заголовок сигнала в свою очередь состоит из серии калибровочных импульсов и VIS-кода.

Рисунок 2: Структура калибровочных импульсов.

Сигнал VIS (Vertical Interval Signaling) включает в себя стартовый импульс, кодовые биты, определяющие формат, завершающийся стоп-битом.
На рисунке 3 приведена структура VIS-сигнала.

Рисунок 3: Структура VIS-кода.

Как видно из рисунка, сигнал формируется сначала из двух тонов 1.9 КГц, длительностью по 0.3 сек, разделенные тоном в 1.2 КГц, длительностью 0.01 сек.

Далее кодируются последовательность из 8 бит, определяющая формат видеосигнала. Нулю соответствует тон в 1.3 КГц, единице 1.1 КГц.

В зависимости от типа сигнала, узкополосный или широкополосный, длительность бита равняется 0.022 сек и 0.03 сек соответственно.

Биты VIS-кода определяют тип формата и его свойства

Таблица 1: Расшифровка VIS-кода.

Первые 4 бита определяют цветовые свойства формата, следующие 3 бита унифицируют формат.

Последний 8-й бит — бит четности, который принимает значение 1, если количество информационных бит нечетное.

На данный момент предел в 8 бит уже практически исчерпан и в некоторых форматах этот код расширен до 16 бит.

Примеры кодов некоторых форматов:
Martin 1: 00101100
Robot 36: 00001000
PD50: 01011101
Scottie DX: 01001100

Примеры 16-и битных кодов:
MMSSTV ML180: 0000010100100011
MMSSTV MP320: 0000101000100011

Кодирование строк

При кодировании строк, исходное изображение раскладывается на каналы цветности.

У черно-белого изображения — это канал яркости. Цветные изображения состоят из компонентов красного, зеленого и синих цветов (RGB), либо из яркости и цветоразностных составляющих по синему и красному цветам.

В случае передачи изображения в формате RGB последовательно передается каждый цветовой канал (могут передаваться как в порядке R, G, B, так и B, G, R).

В зависимости от формата, под каждый канал может быть определено разное время передачи. Так, например, в формате Robot выделено вдвое меньшее время, чем под канал яркости; таким образом, при потере цветности, изображение будет черно-белым.

Рисунок 4: Общий вид кодирования строки формата Robot.

Определение начала строки осуществляется добавлением в сигнал импульсов синхронизации. В большинстве форматов импульс синхронизации добавляется перед началом строки.

Каналы цветности также могут быть отделены импульсами синхронизации. Так, например, на рисунке 4 показана структура формата Robot, между каналами Y и Cb (и между каналами Cb и Cr) расположен сигнал длительностью 4 миллисекунды.

Каждый формат кодирования изображения может иметь свой порядок синхронизации строк и каналов; например в семействе форматов Martin каналы передаются в формате GBR, при этом каждый канал отделен от другого импульсом; в семействе MMSSTV каналы передаются неразрывно, а формат AVT вообще не имеет синхроимпульсов в строке.

Узкополосный SSTV

Узкополосные (narrow) форматы SSTV отличаются от широкополосных (wide) тем, что имеют полосу частот для передачи изображения в 256 Гц (от 2.04 КГц до 2.3 КГц).

Рисунок 5: Заголовок узкополосного SSTV.

Перед передачей VIS-кода формируется заголовок длительностью 400 миллисекунд, содержащий в себе 2 пары тонов в 1.9 КГц и 2.3 КГц, длительностью 100 миллисекунд каждый. По этим сигналам на принимающей стороне происходит определение типа передачи.

Следующей особенностью узкополосного формата является способ формирования VIS-кода. Код записывается 4-я группами по 6 бит каждая. Кодируемые значения представлены в таблице 2. Дополнительная информация о свойствах формата в биты VIS-кода не вносится.

Таблица 2: группы данных VIS-кода узкополосного SSTV

VIS-код для узкополосного формата MMSSTV MP73-N (идентификатор формата равен значению 2) имеет вид 101101-010101-000010-010111

В остальном принципы передачи изображения идентичны широкополосным SSTV.

Форматы SSTV

Перечень наиболее распространенных широкополосных SSTV-форматов используемых в любительской радиосвязи.

Таблица 3: Wide SSTV форматы

Перечень наиболее распространенных узкополосных SSTV-форматов используемых в любительской радиосвязи.

Таблица 4: Wide SSTV форматы

Как видно из таблиц 3 и 4, в большинстве форматов числовое значение в имени кода соответствует времени передачи кадра или очень близкое к нему.

Кодирование SSTV сигнала

Пример кодирования изображения в SSTV сигнал на языке python.

Для работы примера потребуются библиотеки:

numpy~=2.2.3 pillow~=11.1.0 scipy~=1.15.2 

Установка через pip:

pip install numpy~=2.2.3 pillow~=11.1.0 scipy~=1.15.2 

В качестве примера взят формат Robot 72.

Параметры формата:

• Ширина полосы: широкополосный (1.5-2.3 КГц)

• Количество строк: 240

• Размер строки: 320

• Цветопередача: YCbCr

• Время кадра: 72 секунды

Импорт:

import math import statistics import typing from itertools import chain  import numpy as np from PIL import Image from scipy.io.wavfile import write 

Объявление типов (опционально):

Signal = typing.List[float] SignalGen = typing.Generator[float, None, None] Color = int  Tone = typing.NamedTuple("Tone", [("freq", typing.Union[int, typing.Tuple[int, int]]), ("time", float)]) Channel = typing.NamedTuple("Channel", [("id", typing.Union[int, typing.Tuple[int, int]]), ("time", float)]) 

Частота дискретизации выходного звукового файла:

SAMPLE_RATE = 11025 

Вспомогательные функции:

def yield_tones(tones) -> SignalGen:    for tone in tones:        yield (tone.freq, tone.time)  FREQ_LOW = 1500 FREQ_HIGH = 2300  def color_to_freq(color: Color) -> float:    return color * (FREQ_HIGH - FREQ_LOW) / 255 + FREQ_LOW 

FREQ_LOW — нижняя частота кодирования цвета, FREQ_HIGH — верхняя соответственно.

Параметр color — значение яркости цветового канала, лежащее в диапазоне от 0 до 255.

Определение SSTV-заголовка:

HEADER_WIDE = [    Tone(1900, 0.100000),    Tone(1500, 0.100000),    Tone(1900, 0.100000),    Tone(1500, 0.100000),    Tone(2300, 0.100000),    Tone(1500, 0.100000),    Tone(2300, 0.100000),    Tone(1500, 0.100000), ]  def encode_header() -> SignalGen:    yield from yield_tones(HEADER_WIDE) 

HEADER_WIDE — последовательность тонов, согласно спецификации к формату, где первым параметром задается частота в герцах, а вторым — продолжительность сигнала в секундах (значение 0.100000 соответствует 100 миллисекундам).

Определение VIS-кода и калибровочного сигнала:

VIS_CODE = 12  BIT_1_WIDE_FREQ = 1100 BIT_0_WIDE_FREQ = 1300  VIS_WIDE_BIT_SIZE = 0.030000 VIS_BIT_TONE_WIDE = Tone((BIT_0_WIDE_FREQ, BIT_1_WIDE_FREQ), VIS_WIDE_BIT_SIZE) VIS_BIT_TONE_MEDIAN_WIDE = Tone(statistics.median([BIT_0_WIDE_FREQ, BIT_1_WIDE_FREQ]), VIS_WIDE_BIT_SIZE)  CALIBRATION_WIDE = [    Tone(1900, 0.300000),    Tone(1200, 0.010000),    Tone(1900, 0.300000),    Tone(1200, 0.030000), ]  def encode_vis() -> SignalGen:    fsk_len = 8    vis = VIS_CODE    vis |= (vis.bit_count() & 1) << fsk_len - 1  # Parity bit     yield from yield_tones(CALIBRATION_WIDE)     value = vis    for _ in range(fsk_len):        yield (VIS_BIT_TONE_WIDE.freq[value & 1], VIS_BIT_TONE_WIDE.time)        value >>= 1     yield (VIS_BIT_TONE_MEDIAN_WIDE.freq, VIS_BIT_TONE_MEDIAN_WIDE.time) 

Формату Robot 72 соответствует VIS-код со значением 12; количество бит, необходимых для кодирования VIS-кода, составляет 8 бит (значение переменной fsk_len).

Для кодирования бит используются частоты 1.1 КГц для логических единиц и 1.3 КГц для нулей соответственно (значения BIT_1_WIDE_FREQ, BIT_0_WIDE_FREQ).

Функция encode_vis определяет количество бит в VIS-коде и выравнивает четность исходного числа, выставляя 8 бит.

VIS_BIT_TONE_MEDIAN_WIDE — сигнал завершения блока с VIS-кодом.

Определение параметров кодирования изображения

COLOR = "YCbCr"  LINE_WIDTH = 320 LINE_COUNT = 240 

Формат Robot 72 использует цветоразностное кодирование. Размер кадра 320*240. Эти значения используются для кадрирования исходного изображения, а также для получения значения цветов каналов согласно цветовой схеме из COLOR.

Определение продолжительности импульсов синхронизации и длительности импульсов цветопередачи:

SCAN_TIME = 0.138000  PIXEL_TIME = SCAN_TIME / LINE_WIDTH HALF_SCAN_TIME = SCAN_TIME / 2 HALF_PIXEL_TIME = HALF_SCAN_TIME / LINE_WIDTH  SYNC_PULSE = 0.009000 SYNC_PORCH = 0.003000 SEP_PULSE = 0.004500 SEP_PORCH = 0.001500 

SCAN_TIME — длительность одной строки изображения. Исходя из этого определяется длительность сигнала на один пиксел изображения. Т.к. у формата Robot 72 значения обоих цветоразностных сигналов передаются за то же время, за которое передается строка с яркостью, необходимо определить половину времени на пиксел.

Значения длительности импульсов синхронизации и импульсов-разделителей взяты из спецификации к формату.

Определение структуры кодирования формата:

TIMING_SEQUENCE = [    Tone(1200, SYNC_PULSE),    Tone(1500, SYNC_PORCH),    Channel(0, PIXEL_TIME),    Tone(1500, SEP_PULSE),    Tone(1900, SEP_PORCH),    Channel(1, HALF_PIXEL_TIME),    Tone(1500, SEP_PULSE),    Tone(1900, SEP_PORCH),    Channel(2, HALF_PIXEL_TIME), ] 

Список TIMING_SEQUENCE описывает последовательность кодирования данных одной строки изображения. Перед кодированием первого канала записываются сигналы синхронизации (1.2 и 1.5 КГц). Перед последующими каналами записываются импульсы-разделители (1.5 и 1.9 КГц). Как можно заметить, для последующих каналов длительность пикселов определяется значением HALF_PIXEL_TIME.

Определение генераторной функции, переводящей изображение в последовательность тонов, согласно TIMING_SEQUENCE:

def encode_image_data(image) -> SignalGen:    height = LINE_COUNT    width = LINE_WIDTH     pixels = image.convert(COLOR).resize((width, height), Image.Resampling.LANCZOS).load()     y = 0    while y < height:        odd_line = y % 2         for tone in TIMING_SEQUENCE:            if isinstance(tone, Tone):                yield (freq, tone.time)             elif isinstance(tone, Channel):                for px in range(width):                    pixel = pixels[px, y]  # RGB order                    pixel = (pixel[0], pixel[2], pixel[1])  # YUV order                     yield (color_to_freq(pixel[_id]), tone.time)         y += 1 

Функция encode_image_data последовательно обходит по строкам в изображении и выполняет перевод каждого пиксела в строке согласно TIMING_SEQUENCE.

Если в TIMING_SEQUENCE указан импульс синхронизации, то выдаются параметры этого импульса. Если же в TIMING_SEQUENCE указан цветовой канал, тогда согласно параметрам извлекается уровень канала, происходит определение частоты согласно значению уровню канала, далее формируется соответствующий тон-сигнал заданной продолжительности.

Определение функции преобразования изображения в набор сэмплов, готовых к записи в wav-файл:

def encode(image) -> SignalGen:    spms = SAMPLE_RATE / 1000    offset = 0    samples = 0    factor = math.pi * 2 / SAMPLE_RATE  # math.tau -- 2pi    sample = 0     generators = chain(        encode_header(),        encode_vis(),        encode_image_data(image),    )     for freq, sec in generators:        samples += spms * sec * 1000        tx = int(samples)        freq_factor = freq * factor         for sample in range(tx):            yield math.sin(math.fmod(sample * freq_factor + offset, math.tau))         offset += (sample + 1) * freq_factor        samples -= tx 

В функции encode формируется сигнал на основе функции синуса (sin), происходит расчет фазы и выдается последовательность дискретных значений от -1 до 1 с частотой дискретизации SAMPLE_RATE.

Открытие файла с изображением и сохранение результирующего сигнала в wav-файл:

with Image.open("color-bars.png") as im:    amplitude = np.iinfo(np.int16).max    tones = np.fromiter(encode(im), dtype=np.float32) * amplitude  write("robot72-example.wav", SAMPLE_RATE, tones.astype(np.int16)) 

Исходное изображение из файла color-bars.png и запись в целевой файл с именем robot72-example.wav.

В качестве тестового изображения можно воспользоваться настроечной ТВ-таблицей:

Рисунок 6: Настроечная телевизионная таблица.

Спектрограмма получившегося аудиофайла (общий вид):

Рисунок 7: Общий вид спектра сигнала.

На общей спектрограмме можно заметить изменения в спектре, которые соответствуют резкой смене изображения, где у цветных столбцов инвертируется порядок цветов и в конце, где они переходят в столбики другой ширины, и цвета.

Спектрограмма начала файла:

Рисунок 8: Заголовок SSTV, VIS-код и начальные строки SSTV-сигнала.

Здесь можно увидеть ярко выраженные тона синхронизации длительностью 0.1 сек, импульсы калибровки и биты VIS-кода. Далее идут тона, соответствующие данным цветовых каналов.

Спектрограмма каналов:

Рисунок 9: Спектр первых строк SSTV-сигнала.

Каналы с цветоразностными значениями по времени в два раза короче, чем канал яркости. Также на спектрограмме видно импульсы синхронизации.

Декодирование SSTV сигнала

Импорт:

import statistics import typing from functools import reduce  import numpy as np from PIL import Image from scipy.io.wavfile import read from scipy.signal.windows import hann 

Определение типов:

Signal = typing.List[float] SignalGen = typing.Generator[float, None, None] Color = int  Bit = typing.Literal[0, 1] BitGen = typing.Generator[Bit, None, None]  Tone = typing.NamedTuple("Tone", [("freq", typing.Union[int, typing.Tuple[int, int]]), ("time", float)]) ToneSlice = typing.Tuple[slice, float] ToneSlices = typing.List[ToneSlice] Channel = typing.NamedTuple("Channel", [("id", typing.Union[int, typing.Tuple[int, int]]), ("time", float)]) 

Вспомогательные функции для работы с сигналом:

def bits_to_int(bits: typing.List[Bit]) -> int:    return reduce(lambda value, bit: (value << 1) | (bit & 1), bits[::-1])  def barycentric_peak_interp(bins, x):    y1 = bins[x] if x <= 0 else bins[x - 1]    y3 = bins[x] if x + 1 >= len(bins) else bins[x + 1]     denom = y3 + bins[x] + y1    if denom == 0:        return 0     return (y3 - y1) / denom + x  def peak_fft_freq(signal: Signal, sample_rate: float) -> float:    windowed_data = signal * hann(len(signal))    fft = np.abs(np.fft.rfft(windowed_data))     # Get index of bin with the highest magnitude    x = np.argmax(fft)    # Interpolated peak frequency    peak = barycentric_peak_interp(fft, x)     # Return frequency in hz    return peak * sample_rate / len(windowed_data) 

bits_to_int — функция свертки списка битов в число;

barycentric_peak_interp — функция интерполяции барицентрическим полиномом;

peak_fft_freq — функция определения частоты с максимальной амплитудой в отрезке сигнала (используется преобразование Фурье с оконной функцией Хеннинга).

Определение параметров формата Robot 72:

SAMPLE_RATE = None  FREQ_LOW = 1500 FREQ_HIGH = 2300  FREQ_SYNC_PULSE = 1200 FREQ_SYNC_PORCH = 1500 FREQ_SYNC_MEDIAN = statistics.median([FREQ_SYNC_PULSE, FREQ_SYNC_PORCH])  WINDOW_FACTOR = 4.88  VIS_CODE = 12  BIT_1_WIDE_FREQ = 1100 BIT_0_WIDE_FREQ = 1300  VIS_WIDE_BIT_SIZE = 0.030000 VIS_BIT_TONE_WIDE = Tone((BIT_0_WIDE_FREQ, BIT_1_WIDE_FREQ), VIS_WIDE_BIT_SIZE) VIS_BIT_TONE_MEDIAN_WIDE = Tone(statistics.median([BIT_0_WIDE_FREQ, BIT_1_WIDE_FREQ]), VIS_WIDE_BIT_SIZE)  CALIBRATION_WIDE = [    Tone(1900, 0.300000),    Tone(1200, 0.010000),    Tone(1900, 0.300000),    Tone(1200, 0.030000), ]  COLOR = "YCbCr"  LINE_WIDTH = 320 LINE_COUNT = 240  SCAN_TIME = 0.138000  PIXEL_TIME = SCAN_TIME / LINE_WIDTH HALF_SCAN_TIME = SCAN_TIME / 2 HALF_PIXEL_TIME = HALF_SCAN_TIME / LINE_WIDTH  SYNC_PULSE = 0.009000 SYNC_PORCH = 0.003000 SEP_PULSE = 0.004500 SEP_PORCH = 0.001500  CHAN_TIME = SEP_PULSE + SCAN_TIME HALF_CHAN_TIME = SEP_PULSE + HALF_SCAN_TIME  CHANNELS = 3 CHAN_SYNC = 0  CHAN_OFFSETS = [SYNC_PULSE + SYNC_PORCH] CHAN_OFFSETS.append(CHAN_OFFSETS[0] + CHAN_TIME + SEP_PORCH) CHAN_OFFSETS.append(CHAN_OFFSETS[1] + HALF_CHAN_TIME + SEP_PORCH)  LINE_TIME = CHAN_OFFSETS[2] + HALF_SCAN_TIME 

Вспомогательные функции декодирования сигналов:

def freq_to_color(freq: float) -> Color:    lum = int(round((freq - FREQ_LOW) / ((FREQ_HIGH - FREQ_LOW) / 255)))    return min(max(lum, 0), 255)  def read_bits(signal: Signal,              bit_count: int, bit_time: float,              freq_true: float, freq_false: float,              sample_rate: float,              offset: int = 0) -> BitGen:    bit_threshold = statistics.median([freq_true, freq_false])    bit_size = round(bit_time * sample_rate)     for bit_idx in range(bit_count):        bit_offset = offset + bit_idx * bit_size        section = signal[bit_offset:bit_offset + bit_size]        freq = peak_fft_freq(section, sample_rate)        yield int(freq <= bit_threshold)  def tones_to_slices(tones: typing.Iterable[Tone],                    sample_rate: float,                    window_size: typing.Optional[float] = None) -> typing.Tuple[int, ToneSlices]:    # The margin of error created here will be negligible when decoding the    # vis due to each bit having a length of 30ms. We fix this error margin    # when decoding the image by aligning each sync pulse    slices = []    time_acc = 0    for it in tones:        area = slice(            round(time_acc * sample_rate),            round((time_acc + (window_size or it.time)) * sample_rate)        )        slices.append((area, it.freq))        time_acc += it.time     return (round(time_acc * sample_rate), slices)  def match_frequencies(signal: Signal, slices: typing.List[typing.Tuple[slice, float]],                      sample_rate: float, threshold: float = 50.0) -> bool:    # Check they're the correct frequencies    return all(abs(peak_fft_freq(signal[part], sample_rate) - freq) < threshold for part, freq in slices) 

freq_to_color — функция переводящая частоту тона в соответствующее значение цветового канала;

read_bits — функция переводящая последовательность тонов в последовательность бит;

tones_to_slices — утилитарная функция, отображение списка тонов в список слайсов сигнала;

match_frequencies — функция-предикат, определяющая соответствие сигнала указанному списку тонов, если удалось найти все тона в сигнале, возвращает истинно (параметр threshold — порог расхождения частот, по умолчанию 50 Гц).

Поиск заголовка SSTV-сигнала:

def find_header(        header: typing.Iterable[Tone],        signal: Signal,        threshold: float = 50.0,        stride_time: float = 0.002,        window_size: float = 0.010 ) -> typing.Optional[typing.Tuple[int, int]]:    stride_len = round(stride_time * SAMPLE_RATE)     header_size, slices = tones_to_slices(header, SAMPLE_RATE, window_size)     for curr_sample in range(0, len(signal), stride_len):        if curr_sample + header_size >= len(signal):            continue         search_area = signal[curr_sample:curr_sample + header_size]         if match_frequencies(search_area, slices, SAMPLE_RATE, threshold=threshold):            return curr_sample, header_size     return None 

Функция find_header последовательно проходит по сигналу signal и определяет вхождение последовательности тонов из параметра header, в качестве результата выдает кортеж с данными о том, на каком семпле был найден заголовок и какая его продолжительность.

Декодирование VIS-кода:

def decode_vis(signal: Signal, vis_start: int, bit_time: float = VIS_WIDE_BIT_SIZE) -> int:    """Decodes the vis from the audio data and returns the SSTV mode"""    bit_count = 8    vis_bits = list(        read_bits(            signal, bit_count, bit_time,            freq_true=BIT_1_WIDE_FREQ, freq_false=BIT_0_WIDE_FREQ,            sample_rate=SAMPLE_RATE, offset=vis_start        )    )     # Check for even parity in last bit    vis = vis_bits[:bit_count]    if sum(vis) % 2:        raise ValueError("Error decoding VIS header (invalid parity bit)")     vis_value = bits_to_int(vis[:-1])    if vis_value != VIS_CODE:        raise ValueError(f"SSTV mode is unsupported (VIS: {vis_value})")     return vis_value 

Функция decode_vis переводит последовательность тонов в нули и единицы, дополнительно проверяя бит четности. В рамках примера используется в демонстрационных целях, т.к. результат не используется, а только проверяется, что код соответствует формату Robot 72.

Синхронизация:

def align_sync(signal: Signal, align_start: int, start_of_sync: bool = True):    sync_window = round(SYNC_PULSE * 1.4 * SAMPLE_RATE)    align_stop = len(signal) - sync_window     if align_stop <= align_start:        return None     current_sample = align_start    for current_sample in range(align_start, align_stop):        search_section = signal[current_sample:current_sample + sync_window]         if peak_fft_freq(search_section, SAMPLE_RATE) > FREQ_SYNC_MEDIAN:            break     end_sync = current_sample + sync_window // 2     if start_of_sync:        return end_sync - round(SYNC_PULSE * SAMPLE_RATE)    else:        return end_sync 

Функция align_sync определяет точное нахождение импульса синхронизации в сигнале. Возвращаемое значение — номер сэмпла в исходном сигнале.

Алгоритм работы:

1. выбрать часть данных из сигнала;

2. найти в этом участке сигнала частоту, соответствующую частоте синхроимпульса.

Перевод данных строк в изображение:

def decode_image_data(signal: Signal, image_start: int) -> typing.List[typing.List[typing.List[int]]]:    image_data = [[[0 for _ in range(LINE_WIDTH)] for _ in range(CHANNELS)] for _ in range(LINE_COUNT)]     seq_start = image_start    for line in range(LINE_COUNT):        for chan in range(CHANNELS):            if chan == CHAN_SYNC:                if line > 0 or chan > 0:                    # Set base offset to the next line                    seq_start += round(LINE_TIME * SAMPLE_RATE)                 # Align to start of sync pulse                seq_start = align_sync(signal, seq_start)                if seq_start is None:                    return image_data             pixel_time = PIXEL_TIME             if chan > 0:                pixel_time = HALF_PIXEL_TIME             centre_window_time = (pixel_time * WINDOW_FACTOR) / 2            pixel_window = round(centre_window_time * 2 * SAMPLE_RATE)             for px in range(LINE_WIDTH):                chan_offset = CHAN_OFFSETS[chan]                 px_pos = round(seq_start + (chan_offset + px * pixel_time - centre_window_time) * SAMPLE_RATE)                px_end = px_pos + pixel_window                 if px_end >= len(signal):                    return image_data                 pixel_area = signal[px_pos:px_end]                freq = peak_fft_freq(pixel_area, SAMPLE_RATE)                 image_data[line][chan][px] = freq_to_color(freq)     return image_data  def draw_image(image_data: typing.List[typing.List[typing.List[int]]]) -> Image:    image = Image.new(COLOR, (LINE_WIDTH, LINE_COUNT))    pixel_data = image.load()     for y in range(LINE_COUNT):        for x in range(LINE_WIDTH):            pixel_data[x, y] = (image_data[y][0][x], image_data[y][2][x], image_data[y][1][x])     image = image.convert("RGB")    return image 

Функция decode_image_data, в соответствии с форматом кодирования, формирует матрицу цветов. При прохождении канала, в котором необходимо выполнить синхронизацию, вызывается align_sync для точного позиционирования в сигнале. Определение значения канала осуществляется через нахождение тона с максимальной амплитудой (peak_fft_freq) и переводом частоты в значение цветового канала функцией freq_to_color.

Функция draw_image преобразует данные из decode_image_data в финальное графическое изображение в формате RGB.

Значение параметра WINDOW_FACTOR подбирается эмпирически.

Декодирование:

def decode(signal: Signal) -> Image:    if not (header := find_header(CALIBRATION_WIDE, signal)):        return None     hdr_start, hdr_len = header    hdr_end = hdr_start + hdr_len     print("Header start:", hdr_start)    print("Header end:", hdr_end)     bit_time = VIS_WIDE_BIT_SIZE     vis = decode_vis(signal, hdr_end)     print("VIS code:", vis)     if vis != VIS_CODE:        raise ValueError(f"Unsupported VIS code {vis}")     bit_len = 8 + 1  # 8 bits + 1 stub    vis_len = bit_time * bit_len * SAMPLE_RATE    vis_end = hdr_start + vis_len + hdr_len     image_data = decode_image_data(signal, round(vis_end))     return draw_image(image_data)  if __name__ == '__main__':    SAMPLE_RATE, signal = read("examples/robot72-example.wav")     img = decode(signal)    img.save("examples/robot72-example-out.png") 

Фцнкция decode собирает в себя всю вышеописанную логику воедино: поиск SSTV-заголовка, извлечение VIS-кода и декодирование сигнала в картинку.

Рисунок 10: изображение, полученное путем декодирования исходного сигнала.

На рисунке 10 приведен результат декодирования SSTV сигнала в формате Robot 72.

Примеры изображений

SSTV-сигналы, принятые R9FEU на диапазоне 20м.

Заключение

В статье был рассмотрен формат передачи изображений SSTV, принципы его работы, разобраны механизмы кодирования и декодирования сигнала на примере формата Robot 72.

Ссылки

1. Исходный код кодировщика Robot 72

2. Исходный код декодера Robot 72

3. Исходный код родительской программы, с которой были сформированы примеры

4. Исходный код программы, на базе которой были реализованы остальные форматы

5. Основной опорный документ по SSTV

6. Исходный код программы MMSSTV

7. Галерея изображений