PySSTV 0.5.5__py3-none-any.whl

pysstv/examples/gimp-plugin.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+
+# copy to ~/.gimp-2.8/plug-ins/
+# dependencies: GIMP 2.8, python-imaging-tk, python-pyaudio
+
+from gimpfu import register, main, pdb, PF_BOOL, PF_STRING, PF_RADIO, CLIP_TO_IMAGE
+from PIL import Image, ImageTk
+from tkinter import Tk, Canvas, Button, Checkbutton, IntVar, Frame, LEFT, NW
+from pysstv import __main__ as pysstv_main
+from pysstv.examples.pyaudio_sstv import PyAudioSSTV
+from pysstv.sstv import SSTV
+from itertools import repeat
+from threading import Thread
+from queue import Queue, Empty
+from time import sleep
+import gimp, os
+
+MODULE_MAP = pysstv_main.build_module_map()
+
+class AudioThread(Thread):
+    def __init__(self, sstv, parent):
+        Thread.__init__(self)
+        self.pas = PyAudioSSTV(sstv)
+        self.parent = parent
+
+    def run(self):
+        self.pas.execute()
+        self.parent.audio_thread_ended()
+
+    def stop(self):
+        if self.pas is not None:
+            self.pas.sampler = []
+            self.pas = None
+
+
+class Sine1750(SSTV):
+    encode_line = None
+
+    def gen_freq_bits(self):
+        return repeat((1750, 1000))
+
+
+class Transmitter(object):
+    def __init__(self, sstv, root, progress, set_ptt_pin, ptt_state):
+        def encode_line_hooked(line):
+            progress.update_image(line)
+            return self.original_encode_line(line)
+        self.progress = progress
+        self.sstv = sstv
+        self.original_encode_line = sstv.encode_line
+        sstv.encode_line = encode_line_hooked
+        self.root = root
+        self.tx_enabled = IntVar()
+        self.audio_thread = None
+        self.stopping = False
+        self.set_ptt_pin = set_ptt_pin
+        self.ptt_state = ptt_state
+
+    def set_ptt(self, state):
+        if self.set_ptt_pin is None:
+            return
+        if not state:
+            sleep(0.2)
+        self.set_ptt_pin(state != self.ptt_state)
+        if state:
+            sleep(0.2)
+
+    def start_stop_tx(self):
+        if self.tx_enabled.get():
+            self.stopping = False
+            self.audio_thread = AudioThread(self.sstv, self)
+            self.set_ptt(True)
+            self.audio_thread.start()
+        else:
+            self.stop()
+            if self.progress is not None:
+                self.progress.update_image()
+
+    def stop(self):
+        if self.audio_thread is not None:
+            self.stopping = True
+            self.audio_thread.stop()
+            self.set_ptt(False)
+
+    def audio_thread_ended(self):
+        if not self.stopping:
+            self.set_ptt(False)
+            self.tx_enabled.set(0)
+
+    def close(self):
+        self.root.destroy()
+
+
+class CanvasUpdater(Thread):
+    def __init__(self, progress):
+        Thread.__init__(self)
+        self.progress = progress
+        self.queue = Queue()
+        self.should_run = True
+
+    def stop(self):
+        self.should_run = False
+
+    def update_image(self, line=None):
+        self.queue.put(line)
+
+    def run(self):
+        while self.should_run:
+            try:
+                self.progress.update_image(self.queue.get(timeout=0.5))
+            except Empty:
+                pass
+
+
+class ProgressCanvas(Canvas):
+    def __init__(self, master, image):
+        self.height_ratio = 1
+        width, height = image.size
+        pixels = image.load()
+        RED, GREEN, BLUE = list(range(3))
+        self.colors = ['#{0:02x}{1:02x}{2:02x}'.format(
+            contrast(sum(pixels[x, y][RED]   for x in range(width)) / width),
+            contrast(sum(pixels[x, y][GREEN] for x in range(width)) / width),
+            contrast(sum(pixels[x, y][BLUE]  for x in range(width)) / width))
+            for y in range(height)]
+        if height / float(width) > 1.5:
+            width *= 2
+        elif width < 200:
+            width *= 2
+            height *= 2
+            self.height_ratio = 2
+        if (width, height) != image.size:
+            image = image.resize((width, height))
+        Canvas.__init__(self, master, width=width, height=height)
+        self.tk_img = ImageTk.PhotoImage(image)
+        self.update_image()
+        self.pack()
+
+    def update_image(self, line=None):
+        image = self.tk_img
+        self.create_image(0, 0, anchor=NW, image=image)
+        if line is not None:
+            fill = self.colors[line]
+            line *= self.height_ratio
+            self.create_line(0, line, image.width(), line, fill=fill)
+
+
+def contrast(value):
+    if 80 < value < 160:
+        return value + (80 if value < 120 else -80)
+    else:
+        return 255 - value
+
+def transmit_current_image(image, drawable, mode, vox, fskid, ptt_port, ptt_pin, ptt_state):
+    sstv = MODULE_MAP[mode]
+    if ptt_port is not None:
+        from serial import Serial
+        set_ptt_pin = getattr(Serial(ptt_port), 'set' + ptt_pin)
+        set_ptt_pin(ptt_state)
+    else:
+        set_ptt_pin = None
+    pil_img = match_image_with_sstv_mode(image_gimp_to_pil(image), sstv)
+    root = Tk()
+    cu = CanvasUpdater(ProgressCanvas(root, pil_img))
+    cu.start()
+    tm = Transmitter(init_sstv(sstv, pil_img, vox, fskid), root, cu, set_ptt_pin, ptt_state)
+    tm1750 = Transmitter(Sine1750(None, 44100, 16), None, None, set_ptt_pin, ptt_state)
+    buttons = Frame(root)
+    for text, tram in (('TX', tm), ('1750 Hz', tm1750)):
+        Checkbutton(buttons, text=text, indicatoron=False, padx=5, pady=5,
+                variable=tram.tx_enabled, command=tram.start_stop_tx).pack(side=LEFT)
+    Button(buttons, text="Close", command=tm.close).pack(side=LEFT)
+    buttons.pack()
+    root.mainloop()
+    for obj in (tm, tm1750, cu):
+        obj.stop()
+
+def image_gimp_to_pil(image):
+    try:
+        sandbox = image.duplicate()
+        for layer in sandbox.layers:
+            if not layer.visible:
+                sandbox.remove_layer(layer)
+        sandbox.merge_visible_layers(CLIP_TO_IMAGE)
+        layer = sandbox.layers[0]
+        if not layer.is_rgb:
+            pdb.gimp_image_convert_rgb(sandbox)
+        if layer.has_alpha:
+            pdb.gimp_layer_flatten(layer)
+        w, h = layer.width, layer.height
+        pixels = layer.get_pixel_rgn(0, 0, w, h)[:, :] # all pixels
+        return Image.frombuffer('RGB', (w, h), pixels, 'raw', 'RGB', 0, 0)
+    finally:
+        gimp.delete(sandbox)
+
+def match_image_with_sstv_mode(image, mode):
+    mode_size = mode.WIDTH, mode.HEIGHT
+    if image.size != mode_size:
+        image = image.resize(mode_size, Image.ANTIALIAS)
+    if 'grayscale' in mode.__module__:
+        image = image.convert('LA').convert('RGB')
+    return image
+
+def init_sstv(mode, image, vox, fskid):
+    s = mode(image, 44100, 16)
+    s.vox_enabled = vox
+    if fskid:
+        s.add_fskid_text(fskid)
+    return s
+
+def get_serial_ports():
+    try:
+        if os.name == 'nt':
+            from serial.tools.list_ports_windows import comports
+        elif os.name == 'posix':
+            from serial.tools.list_ports_posix import comports
+        else:
+            raise ImportError("Sorry: no implementation for your"
+            "platform ('%s') available" % (os.name,))
+    except ImportError:
+        yield "(couldn't import PySerial)", None
+    else:
+        yield "(disabled)", None
+        for port, desc, _ in comports():
+            yield '{0} ({1})'.format(port, desc.strip()), port
+
+
+register(
+        "pysstv_for_gimp",
+        "PySSTV for GIMP",
+        "Transmits the current image using PySSTV",
+        "Andras Veres-Szentkiralyi",
+        "Andras Veres-Szentkiralyi",
+        "November 2013",
+        "<Image>/PySSTV/Transmit...",
+        "*",
+        [
+            (PF_RADIO, "mode", "SSTV mode", "MartinM1",
+                tuple((n, n) for n in sorted(MODULE_MAP.keys()))),
+            (PF_BOOL, "vox", "Include VOX tones", True),
+            (PF_STRING, "fskid", "FSK ID", ""),
+            (PF_RADIO, "ptt_port", "PTT port", None,
+                tuple(get_serial_ports())),
+            (PF_RADIO, "ptt_pin", "PTT pin", "RTS",
+                tuple((n, n) for n in ("RTS", "DTR"))),
+            (PF_BOOL, "ptt_state", "PTT inversion", False),
+        ],
+        [],
+        transmit_current_image
+        )
+
+main()

pysstv/examples/overlay.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python
+
+"""
+Demonstrates adding text overlay (callsign, RSV, etc.) using PIL
+See example output received by slowrx at the following URL:
+http://vsza.hu/c6fa52b2c7b20320bdab2da15877f0efbd466e67d37c8d124a557367de9380da.png
+"""
+
+from PIL import Image, ImageFont, ImageDraw
+from pysstv.grayscale import Robot8BW
+
+img = Image.open("160x120bw.png")
+font = ImageFont.load_default()
+draw = ImageDraw.Draw(img)
+draw.text((0, 0), "HA5VSA", (255,255,255), font=font)
+sstv = Robot8BW(img, 44100, 16)
+sstv.write_wav("overlay.wav")

pysstv/examples/pyaudio_sstv.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python
+
+"""
+Demonstrates playing the generated samples directly using PyAudio
+Tested on PyAudio 0.2.7 http://people.csail.mit.edu/hubert/pyaudio/
+"""
+
+
+from pysstv.sstv import SSTV
+from time import sleep
+from itertools import islice
+import struct, pyaudio
+
+class PyAudioSSTV(object):
+    def __init__(self, sstv):
+        self.pa = pyaudio.PyAudio()
+        self.sstv = sstv
+        self.fmt = '<' + SSTV.BITS_TO_STRUCT[sstv.bits]
+
+    def __del__(self):
+        self.pa.terminate()
+
+    def execute(self):
+        self.sampler = self.sstv.gen_samples()
+        stream = self.pa.open(
+                format=self.pa.get_format_from_width(self.sstv.bits // 8),
+                channels=1, rate=self.sstv.samples_per_sec, output=True,
+                stream_callback=self.callback)
+        stream.start_stream()
+        while stream.is_active():
+            sleep(0.5)
+        stream.stop_stream()
+        stream.close()
+
+    def callback(self, in_data, frame_count, time_info, status):
+        frames = ''.join(struct.pack(self.fmt, b)
+                for b in islice(self.sampler, frame_count))
+        return frames, pyaudio.paContinue
+
+
+def main():
+    from PIL import Image
+    from pysstv.grayscale import Robot8BW
+
+    img = Image.open("160x120bw.png")
+    sstv = Robot8BW(img, 44100, 16)
+    sstv.vox_enabled = True
+    PyAudioSSTV(sstv).execute()
+
+if __name__ == '__main__':
+    main()

pysstv/examples/repeater.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+
+"""
+Simple repeater that monitors a single directory using inotify, and if
+an image appears, it tries to repeat it on using the PyAudio example,
+trying to match the mode used for receiving it. It can be tested by
+simply copying/linking images to the directory or suing an SSTV
+receiver such as slowrx or QSSTV.
+"""
+
+
+from pyinotify import WatchManager, Notifier, ProcessEvent, IN_CREATE
+from .pyaudio_sstv import PyAudioSSTV
+from pysstv.color import MartinM1, MartinM2, ScottieS1, ScottieS2
+from pysstv.grayscale import Robot8BW, Robot24BW
+from PIL import Image
+from os import path
+
+# matches the abbreviations used by slowrx and QSSTV
+MODE_MAP = {
+        'M1': MartinM1,
+        'M2': MartinM2,
+        'S1': ScottieS1,
+        'S2': ScottieS2,
+        'R8BW': Robot8BW,
+        'R24BW': Robot24BW,
+        }
+
+class EventHandler(ProcessEvent):
+    def process_IN_CREATE(self, event):
+        filename = event.pathname
+        print('Found image', filename)
+        mode = get_module_for_filename(filename)
+        img = Image.open(filename)
+        if mode is None:
+            mode = get_module_for_image(img)
+        if mode is None:
+            print('No suitable mode found to repeat', filename)
+            return
+        print('Repeating image using', mode.__name__)
+        sstv = mode(img, 44100, 16)
+        sstv.vox_enabled = True
+        PyAudioSSTV(sstv).execute()
+
+def get_module_for_filename(filename):
+    basename, _ = path.splitext(path.basename(filename))
+    for mode, module in MODE_MAP.items():
+        if mode in basename:
+            return module
+
+def get_module_for_image(image):
+    size = image.size
+    for mode in MODE_MAP.values():
+        if all(i >= m for i, m in zip(size, (mode.WIDTH, mode.HEIGHT))):
+            return mode
+
+def main():
+    from sys import argv, stderr
+    try:
+        directory = argv[1]
+    except IndexError:
+        print("Usage: {0} <directory>".format(argv[0]), file=stderr)
+    else:
+        watch(directory)
+
+def watch(directory):
+    wm = WatchManager()
+    notifier = Notifier(wm, EventHandler())
+    wm.add_watch(directory, IN_CREATE)
+    notifier.loop()
+
+if __name__ == '__main__':
+    main()

pysstv/grayscale.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+
+from __future__ import division
+from pysstv.sstv import SSTV, byte_to_freq
+
+
+class GrayscaleSSTV(SSTV):
+    def on_init(self):
+        self.pixels = self.image.convert('LA').load()
+
+    def gen_image_tuples(self):
+        for line in range(self.HEIGHT):
+            yield from self.horizontal_sync()
+            yield from self.encode_line(line)
+
+    def encode_line(self, line):
+        msec_pixel = self.SCAN / self.WIDTH
+        image = self.pixels
+        for col in range(self.WIDTH):
+            pixel = image[col, line]
+            freq_pixel = byte_to_freq(pixel[0])
+            yield freq_pixel, msec_pixel
+
+
+class Robot8BW(GrayscaleSSTV):
+    VIS_CODE = 0x02
+    WIDTH = 160
+    HEIGHT = 120
+    SYNC = 7
+    SCAN = 60
+
+
+class Robot24BW(GrayscaleSSTV):
+    VIS_CODE = 0x0A
+    WIDTH = 320
+    HEIGHT = 240
+    SYNC = 7
+    SCAN = 93
+
+MODES = (Robot8BW, Robot24BW)

pysstv/sstv.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python
+
+from __future__ import division, with_statement
+from math import sin, pi
+from random import random
+from contextlib import closing
+from itertools import cycle, chain
+from array import array
+import wave
+
+FREQ_VIS_BIT1 = 1100
+FREQ_SYNC = 1200
+FREQ_VIS_BIT0 = 1300
+FREQ_BLACK = 1500
+FREQ_VIS_START = 1900
+FREQ_WHITE = 2300
+FREQ_RANGE = FREQ_WHITE - FREQ_BLACK
+FREQ_FSKID_BIT1 = 1900
+FREQ_FSKID_BIT0 = 2100
+
+MSEC_VIS_START = 300
+MSEC_VIS_SYNC = 10
+MSEC_VIS_BIT = 30
+MSEC_FSKID_BIT = 22
+
+
+class SSTV(object):
+
+    def __init__(self, image, samples_per_sec, bits):
+        self.image = image
+        self.samples_per_sec = samples_per_sec
+        self.bits = bits
+        self.vox_enabled = False
+        self.fskid_payload = ''
+        self.nchannels = 1
+        self.on_init()
+
+    def on_init(self):
+        pass
+
+    BITS_TO_STRUCT = {8: 'b', 16: 'h'}
+
+    def write_wav(self, filename):
+        """writes the whole image to a Microsoft WAV file"""
+        fmt = self.BITS_TO_STRUCT[self.bits]
+        data = array(fmt, self.gen_samples())
+        if self.nchannels != 1:
+            data = array(fmt, chain.from_iterable(
+                zip(*([data] * self.nchannels))))
+        with closing(wave.open(filename, 'wb')) as wav:
+            wav.setnchannels(self.nchannels)
+            wav.setsampwidth(self.bits // 8)
+            wav.setframerate(self.samples_per_sec)
+            wav.writeframes(data)
+
+    def gen_samples(self):
+        """generates discrete samples from gen_values()
+
+           performs quantization according to
+           the bits per sample value given during construction
+        """
+        max_value = 2 ** self.bits
+        alias = 1 / max_value
+        amp = max_value // 2
+        lowest = -amp
+        highest = amp - 1
+        alias_cycle = cycle((alias * (random() - 0.5) for _ in range(1024)))
+        for value, alias_item in zip(self.gen_values(), alias_cycle):
+            sample = int(value * amp + alias_item)
+            yield (lowest if sample <= lowest else
+                sample if sample <= highest else highest)
+
+    def gen_values(self):
+        """generates samples between -1 and +1 from gen_freq_bits()
+
+           performs sampling according to
+           the samples per second value given during construction
+        """
+        spms = self.samples_per_sec / 1000
+        offset = 0
+        samples = 0
+        factor = 2 * pi / self.samples_per_sec
+        sample = 0
+        for freq, msec in self.gen_freq_bits():
+            samples += spms * msec
+            tx = int(samples)
+            freq_factor = freq * factor
+            for sample in range(tx):
+                yield sin(sample * freq_factor + offset)
+            offset += (sample + 1) * freq_factor
+            samples -= tx
+
+    def gen_freq_bits(self):
+        """generates tuples (freq, msec) that describe a sine wave segment
+
+           frequency "freq" in Hz and duration "msec" in ms
+        """
+        if self.vox_enabled:
+            for freq in (1900, 1500, 1900, 1500, 2300, 1500, 2300, 1500):
+                yield freq, 100
+        yield FREQ_VIS_START, MSEC_VIS_START
+        yield FREQ_SYNC, MSEC_VIS_SYNC
+        yield FREQ_VIS_START, MSEC_VIS_START
+        yield FREQ_SYNC, MSEC_VIS_BIT  # start bit
+        vis = self.VIS_CODE
+        num_ones = 0
+        for _ in range(7):
+            bit = vis & 1
+            vis >>= 1
+            num_ones += bit
+            bit_freq = FREQ_VIS_BIT1 if bit == 1 else FREQ_VIS_BIT0
+            yield bit_freq, MSEC_VIS_BIT
+        parity_freq = FREQ_VIS_BIT1 if num_ones % 2 == 1 else FREQ_VIS_BIT0
+        yield parity_freq, MSEC_VIS_BIT
+        yield FREQ_SYNC, MSEC_VIS_BIT  # stop bit
+        yield from self.gen_image_tuples()
+        for fskid_byte in map(ord, self.fskid_payload):
+            for _ in range(6):
+                bit = fskid_byte & 1
+                fskid_byte >>= 1
+                bit_freq = FREQ_FSKID_BIT1 if bit == 1 else FREQ_FSKID_BIT0
+                yield bit_freq, MSEC_FSKID_BIT
+
+    def gen_image_tuples(self):
+        return []
+
+    def add_fskid_text(self, text):
+        self.fskid_payload += '\x20\x2a{0}\x01'.format(
+                ''.join(chr(ord(c) - 0x20) for c in text))
+
+    def horizontal_sync(self):
+        yield FREQ_SYNC, self.SYNC
+
+
+def byte_to_freq(value):
+    return FREQ_BLACK + FREQ_RANGE * value / 255

pysstv/tests/__init__.py

@@ -0,0 +1,3 @@
+#!/usr/bin/env python
+
+__all__ = ['common', 'test_color', 'test_sstv']

pysstv/tests/common.py

@@ -0,0 +1,9 @@
+from os import path
+import pickle
+
+def get_asset_filename(filename):
+    return path.join(path.dirname(__file__), 'assets', filename)
+
+def load_pickled_asset(filename):
+    with open(get_asset_filename(filename + '.p'), 'rb') as f:
+        return pickle.load(f)

pysstv/tests/test_color.py

@@ -0,0 +1,44 @@
+import unittest
+from itertools import islice
+
+from PIL import Image
+
+from pysstv import color
+from pysstv.tests.common import get_asset_filename, load_pickled_asset
+
+
+class TestMartinM1(unittest.TestCase):
+
+    def setUp(self):
+        self.image = Image.new('RGB', (320, 256))
+        self.s = color.MartinM1(self.image, 48000, 16)
+        lena = Image.open(get_asset_filename('320x256.png'))
+        self.lena = color.MartinM1(lena, 48000, 16)
+
+    def test_gen_freq_bits(self):
+        expected = load_pickled_asset("MartinM1_freq_bits")
+        actual = list(islice(self.s.gen_freq_bits(), 0, 1000))
+        self.assertEqual(expected, actual)
+
+    def test_gen_freq_bits_lena(self):
+        expected = load_pickled_asset("MartinM1_freq_bits_lena")
+        actual = list(islice(self.lena.gen_freq_bits(), 0, 1000))
+        self.assertEqual(expected, actual)
+
+    def test_encode_line(self):
+        zeroth = list(self.s.encode_line(0))
+        first = list(self.s.encode_line(1))
+        tenth = list(self.s.encode_line(10))
+        eleventh = list(self.s.encode_line(11))
+
+        self.assertEqual(zeroth, first)
+        self.assertEqual(tenth, eleventh)
+        self.assertEqual(zeroth, eleventh)
+
+    def test_encode_line_lena(self):
+        self.maxDiff = None
+        line_numbers = [1, 10, 100]
+        for line in line_numbers:
+            expected = load_pickled_asset("MartinM1_encode_line_lena{0}".format(line))
+            actual = list(self.lena.encode_line(line))
+            self.assertEqual(expected, actual)