PySSTV 0.5.5__py3-none-any.whl

PySSTV-0.5.5.dist-info/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Andras Veres-Szentkiralyi
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

PySSTV-0.5.5.dist-info/METADATA

@@ -0,0 +1,95 @@
+Metadata-Version: 2.1
+Name: PySSTV
+Version: 0.5.5
+Summary: Python classes for generating Slow-scan Television transmissions
+Home-page: https://github.com/dnet/pySSTV
+Author: András Veres-Szentkirályi
+Author-email: vsza@vsza.hu
+License: MIT
+Keywords: HAM SSTV slow-scan television Scottie Martin Robot Pasokon
+Classifier: Development Status :: 4 - Beta
+Classifier: Topic :: Communications :: Ham Radio
+Classifier: Topic :: Multimedia :: Video :: Conversion
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: Pillow
+
+SSTV generator in pure Python
+=============================
+
+PySSTV generates SSTV modulated WAV files from any image that PIL can open
+(PNG, JPEG, GIF, and many others). These WAV files then can be played by any
+audio player connected to a shortwave radio for example.
+
+My main motivation was to understand the internals of SSTV in practice, so
+performance is far from optimal. I tried keeping the code readable, and only
+performed such optimizations that wouldn't have complicated the codebase.
+
+Command line usage
+------------------
+
+    $ python -m pysstv -h
+    usage: __main__.py [-h]
+                  [--mode {MartinM1,MartinM2,ScottieS1,ScottieS2,Robot36,PasokonP3,PasokonP5,PasokonP7,PD90,PD120,PD160,PD180,PD240,PD290,Robot8BW,Robot24BW}]
+                  [--rate RATE] [--bits BITS] [--vox] [--fskid FSKID]
+                  [--chan CHAN]
+                  image.png output.wav
+
+    Converts an image to an SSTV modulated WAV file.
+
+    positional arguments:
+      image.png             input image file name
+      output.wav            output WAV file name
+
+    optional arguments:
+      -h, --help            show this help message and exit
+      --mode {MartinM1,MartinM2,ScottieS1,ScottieS2,Robot36,PasokonP3,PasokonP5,PasokonP7,PD90,PD120D160,PD180,PD240,Robot8BW,Robot24BW}
+                            image mode (default: Martin M1)
+      --rate RATE           sampling rate (default: 48000)
+      --bits BITS           bits per sample (default: 16)
+      --vox                 add VOX tones at the beginning
+      --fskid FSKID         add FSKID at the end
+      --chan CHAN           number of channels (default: mono)
+
+Python interface
+----------------
+
+The `SSTV` class in the `sstv` module implements basic SSTV-related
+functionality, and the classes of other modules such as `grayscale` and
+`color` extend this. Most instances implement the following methods:
+
+ - `__init__` takes a PIL image, the samples per second, and the bits per
+   sample as a parameter, but doesn't perform any hard calculations
+ - `gen_freq_bits` generates tuples that describe a sine wave segment with
+   frequency in Hz and duration in ms
+ - `gen_values` generates samples between -1 and +1, performing sampling
+   according to the samples per second value given during construction
+ - `gen_samples` generates discrete samples, performing quantization
+   according to the bits per sample value given during construction
+ - `write_wav` writes the whole image to a Microsoft WAV file
+
+The above methods all build upon those above them, for example `write_wav`
+calls `gen_samples`, while latter calls `gen_values`, so typically, only
+the first and the last, maybe the last two should be called directly, the
+others are just listed here for the sake of completeness and to make the
+flow easier to understand.
+
+License
+-------
+
+The whole project is available under MIT license.
+
+Useful links
+------------
+
+ - receive-only "counterpart": https://github.com/windytan/slowrx
+ - free SSTV handbook: http://www.sstv-handbook.com/
+ - robot 36 encoder/decoder in C: https://github.com/xdsopl/robot36/
+
+Dependencies
+------------
+
+ - Python 3.5 or later
+ - Python Imaging Library (Debian/Ubuntu package: `python3-pil`)

PySSTV-0.5.5.dist-info/RECORD

@@ -0,0 +1,23 @@
+pysstv/__init__.py,sha256=v25SUBx1XfOlGVF9AQfXaLhs3tfIrfqHMUFJuPYjFBk,85
+pysstv/__main__.py,sha256=npynfJzxvB22YQkznDluVwLGqsU6qkKqelX2y5F6b5M,3726
+pysstv/color.py,sha256=xR_yJR3spFVIJ6ZMgVpHlITqdMih1c7_uPYg_ifYChM,5396
+pysstv/grayscale.py,sha256=sKYj7pR9mzhekiwp_16aBysUWuDe5woLaAHZsIM0i3k,897
+pysstv/sstv.py,sha256=5GflGizPnthvbt6c5r4WEROniLgYqUdDTG2zyuzatLc,4354
+pysstv/examples/__init__.py,sha256=eYhYvkC9jXkgZDJD1V1jffApef6mXZM18M1CusgfM_Q,73
+pysstv/examples/codegen.py,sha256=BFTX3virfnrjKll99JbVVLMRk23B6iOv_bnUleTTJqc,5936
+pysstv/examples/get_floats.py,sha256=NT3NE2L9xAZCM0W3cChd0bDr39YuVTpda9Rzhi5wReE,559
+pysstv/examples/get_freq_bits.py,sha256=yctUehsXgshxQ_vd27c9jxzBaUMV0N6JYc98NBD9uxg,622
+pysstv/examples/gimp-plugin.py,sha256=n5exX47Gklq6aKtWQfk3YnANiZV0lcHtRfrMP0gKGkY,8073
+pysstv/examples/overlay.py,sha256=FSldscCI9sTFwrCe-Nl0y6cC346kx_GZ7G2uMI0VL7k,533
+pysstv/examples/pyaudio_sstv.py,sha256=3gAqRTKRd-_4U2oiPvUMG5Wd8vW5olMhYs0pFWfaA1k,1408
+pysstv/examples/repeater.py,sha256=W1t0yOr-YRSK9sO5HVw8l_DqTg-xj7mHaWbGxbeWZok,2183
+pysstv/tests/__init__.py,sha256=liZwqN9naCqnQviykDjSLoogdvPUP14wXtvAvaeylvM,71
+pysstv/tests/common.py,sha256=EaO7eJQ4YvO0b70I3WdWk79G6TX90Gbuezcvbo3-5mA,262
+pysstv/tests/test_color.py,sha256=MJomuWvuF3fTroThwAcdyFiFavt8_j8b7yrKQLvl1Hk,1527
+pysstv/tests/test_sstv.py,sha256=SDkzdbIMpaeWfkqzZuh7k3pHyc6-cLV8tSbxLLvraec,2807
+PySSTV-0.5.5.dist-info/LICENSE.txt,sha256=3QTt5CrsmuUm5urLjdgxk2aHj9T_KreABJzDefftcQc,1069
+PySSTV-0.5.5.dist-info/METADATA,sha256=1bxesFyRZY_G-L7DwHcRNZUhFuFPv16zNXvgmVLyWm8,3853
+PySSTV-0.5.5.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
+PySSTV-0.5.5.dist-info/entry_points.txt,sha256=o1t-uDYe9lprOoofUauxJAcSUth5ImaV2d0W2NI7Yfw,48
+PySSTV-0.5.5.dist-info/top_level.txt,sha256=PrRHl9SFiJU71r-_iI4MnyK62MkbuLghNLAlxW2jMWM,7
+PySSTV-0.5.5.dist-info/RECORD,,

PySSTV-0.5.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.3)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

PySSTV-0.5.5.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pysstv = pysstv.__main__:main

PySSTV-0.5.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+pysstv

pysstv/__init__.py

@@ -0,0 +1,3 @@
+#!/usr/bin/env python
+
+__all__ = ['color', 'grayscale', 'sstv', 'tests', 'examples']

pysstv/__main__.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python
+
+from __future__ import print_function, division
+from PIL import Image
+from argparse import ArgumentParser
+from sys import stderr
+from pysstv import color, grayscale
+
+SSTV_MODULES = [color, grayscale]
+
+
+def main():
+    module_map = build_module_map()
+    parser = ArgumentParser(
+        description='Converts an image to an SSTV modulated WAV file.')
+    parser.add_argument('img_file', metavar='image.png',
+                        help='input image file name')
+    parser.add_argument('wav_file', metavar='output.wav',
+                        help='output WAV file name')
+    parser.add_argument(
+        '--mode', dest='mode', default='MartinM1', choices=module_map,
+        help='image mode (default: Martin M1)')
+    parser.add_argument('--rate', dest='rate', type=int, default=48000,
+                        help='sampling rate (default: 48000)')
+    parser.add_argument('--bits', dest='bits', type=int, default=16,
+                        help='bits per sample (default: 16)')
+    parser.add_argument('--vox', dest='vox', action='store_true',
+                        help='add VOX tones at the beginning')
+    parser.add_argument('--fskid', dest='fskid',
+                        help='add FSKID at the end')
+    parser.add_argument('--chan', dest='chan', type=int,
+                        help='number of channels (default: mono)')
+    parser.add_argument('--resize', dest='resize', action='store_true',
+                        help='resize the image to the correct size')
+    parser.add_argument('--keep-aspect-ratio', dest='keep_aspect_ratio', action='store_true',
+                        help='keep the original aspect ratio when resizing (and cut off excess pixels)')
+    parser.add_argument('--resample', dest='resample', default='lanczos',
+                        choices=('nearest', 'bicubic', 'lanczos'),
+                        help='which resampling filter to use for resizing (see Pillow documentation)')
+    args = parser.parse_args()
+    image = Image.open(args.img_file)
+    mode = module_map[args.mode]
+    if args.resize and any(i != m for i, m in zip(image.size, (mode.WIDTH, mode.HEIGHT))):
+        resample = getattr(Image, args.resample.upper())
+        if args.keep_aspect_ratio:
+            orig_ratio = image.width / image.height
+            mode_ratio = mode.WIDTH / mode.HEIGHT
+            crop = orig_ratio != mode_ratio
+        else:
+            crop = False
+        if crop:
+            if orig_ratio < mode_ratio:
+                w = mode.WIDTH
+                h = int(w / orig_ratio)
+            else:
+                h = mode.HEIGHT
+                w = int(orig_ratio * h)
+        else:
+            w = mode.WIDTH
+            h = mode.HEIGHT
+        image = image.resize((w, h), resample)
+        if crop:
+            x = (image.width - mode.WIDTH) / 2
+            y = (image.height - mode.HEIGHT) / 2
+            image = image.crop((x, y, mode.WIDTH + x, mode.HEIGHT + y))
+    elif not all(i >= m for i, m in zip(image.size, (mode.WIDTH, mode.HEIGHT))):
+        print(('Image must be at least {m.WIDTH} x {m.HEIGHT} pixels '
+               'for mode {m.__name__}').format(m=mode), file=stderr)
+        raise SystemExit(1)
+    s = mode(image, args.rate, args.bits)
+    s.vox_enabled = args.vox
+    if args.fskid:
+        s.add_fskid_text(args.fskid)
+    if args.chan:
+        s.nchannels = args.chan
+    s.write_wav(args.wav_file)
+
+
+def build_module_map():
+    try:
+        from collections import OrderedDict
+        module_map = OrderedDict()
+    except ImportError:
+        module_map = {}
+    for module in SSTV_MODULES:
+        for mode in module.MODES:
+            module_map[mode.__name__] = mode
+    return module_map
+
+
+if __name__ == '__main__':
+    main()

pysstv/color.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python
+from __future__ import division
+from pysstv.sstv import byte_to_freq, FREQ_BLACK, FREQ_WHITE, FREQ_VIS_START
+from pysstv.grayscale import GrayscaleSSTV
+from itertools import chain
+from enum import Enum
+
+
+class Color(Enum):
+    red = 0
+    green = 1
+    blue = 2
+
+
+class ColorSSTV(GrayscaleSSTV):
+    def on_init(self):
+        self.pixels = self.image.convert('RGB').load()
+
+    def encode_line(self, line):
+        msec_pixel = self.SCAN / self.WIDTH
+        image = self.pixels
+        for color in self.COLOR_SEQ:
+            yield from self.before_channel(color)
+            for col in range(self.WIDTH):
+                pixel = image[col, line]
+                freq_pixel = byte_to_freq(pixel[color.value])
+                yield freq_pixel, msec_pixel
+            yield from self.after_channel(color)
+
+    def before_channel(self, color):
+        return []
+
+    after_channel = before_channel
+
+
+class MartinM1(ColorSSTV):
+    COLOR_SEQ = (Color.green, Color.blue, Color.red)
+    VIS_CODE = 0x2c
+    WIDTH = 320
+    HEIGHT = 256
+    SYNC = 4.862
+    SCAN = 146.432
+    INTER_CH_GAP = 0.572
+
+    def before_channel(self, color):
+        if color is Color.green:
+            yield FREQ_BLACK, self.INTER_CH_GAP
+
+    def after_channel(self, color):
+        yield FREQ_BLACK, self.INTER_CH_GAP
+
+
+class MartinM2(MartinM1):
+    VIS_CODE = 0x28
+    WIDTH = 160
+    SCAN = 73.216
+
+
+class ScottieS1(MartinM1):
+    VIS_CODE = 0x3c
+    SYNC = 9
+    INTER_CH_GAP = 1.5
+    SCAN = 138.24 - INTER_CH_GAP
+
+    def horizontal_sync(self):
+        return []
+
+    def before_channel(self, color):
+        if color is Color.red:
+            yield from MartinM1.horizontal_sync(self)
+        yield FREQ_BLACK, self.INTER_CH_GAP
+
+
+class ScottieS2(ScottieS1):
+    VIS_CODE = 0x38
+    SCAN = 88.064 - ScottieS1.INTER_CH_GAP
+    WIDTH = 160
+
+
+class Robot36(ColorSSTV):
+    VIS_CODE = 0x08
+    WIDTH = 320
+    HEIGHT = 240
+    SYNC = 9
+    INTER_CH_GAP = 4.5
+    Y_SCAN = 88
+    C_SCAN = 44
+    PORCH = 1.5
+    SYNC_PORCH = 3
+    INTER_CH_FREQS = [None, FREQ_WHITE, FREQ_BLACK]
+
+    def on_init(self):
+        self.yuv = self.image.convert('YCbCr').load()
+
+    def encode_line(self, line):
+        pixels = [self.yuv[col, line] for col in range(self.WIDTH)]
+        channel = 2 - (line % 2)
+        y_pixel_time = self.Y_SCAN / self.WIDTH
+        uv_pixel_time = self.C_SCAN / self.WIDTH
+        return chain(
+                [(FREQ_BLACK, self.SYNC_PORCH)],
+                ((byte_to_freq(p[0]), y_pixel_time) for p in pixels),
+                [(self.INTER_CH_FREQS[channel], self.INTER_CH_GAP),
+                    (FREQ_VIS_START, self.PORCH)],
+                ((byte_to_freq(p[channel]), uv_pixel_time) for p in pixels))
+
+
+class PasokonP3(ColorSSTV):
+    """
+    [ VIS code or horizontal sync here ]
+    Back porch - 5 time units of black (1500 Hz).
+    Red component - 640 pixels of 1 time unit each.
+    Gap - 5 time units of black.
+    Green component - 640 pixels of 1 time unit each.
+    Gap - 5 time units of black.
+    Blue component - 640 pixels of 1 time unit each.
+    Front porch - 5 time units of black.
+    Horizontal Sync - 25 time units of 1200 Hz.
+    """
+    TIMEUNIT = 1000/4800. # ms
+    COLOR_SEQ = (Color.red, Color.green, Color.blue)
+    VIS_CODE = 0x71
+    WIDTH = 640
+    HEIGHT = 480+16
+    SYNC = 25 * TIMEUNIT
+    SCAN = WIDTH * TIMEUNIT
+    INTER_CH_GAP = 5 * TIMEUNIT
+    
+    def before_channel(self, color):
+        if color is Color.red:
+            yield FREQ_BLACK, self.INTER_CH_GAP
+
+    def after_channel(self, color):
+        yield FREQ_BLACK, self.INTER_CH_GAP
+        
+        
+class PasokonP5(PasokonP3):
+    TIMEUNIT = 1000/3200. # ms
+    VIS_CODE = 0x72
+    SYNC = 25 * TIMEUNIT
+    SCAN = PasokonP3.WIDTH * TIMEUNIT
+    INTER_CH_GAP = 5 * TIMEUNIT
+        
+class PasokonP7(PasokonP3):
+    TIMEUNIT = 1000/2400. # ms
+    VIS_CODE = 0xF3
+    SYNC = 25 * TIMEUNIT
+    SCAN = PasokonP3.WIDTH * TIMEUNIT
+    INTER_CH_GAP = 5 * TIMEUNIT
+
+
+class PD90(ColorSSTV):
+    VIS_CODE = 0x63
+    WIDTH = 320
+    HEIGHT = 256
+    SYNC = 20
+    PORCH = 2.08
+    PIXEL = 0.532
+
+    def gen_image_tuples(self):
+        yuv = self.image.convert('YCbCr').load()
+        for line in range(0, self.HEIGHT, 2):
+            yield from self.horizontal_sync()
+            yield FREQ_BLACK, self.PORCH
+            pixels0 = [yuv[col, line] for col in range(self.WIDTH)]
+            pixels1 = [yuv[col, line + 1] for col in range(self.WIDTH)]
+            for p in pixels0:
+                yield byte_to_freq(p[0]), self.PIXEL
+            for p0, p1 in zip(pixels0, pixels1):
+                yield byte_to_freq((p0[2] + p1[2]) / 2), self.PIXEL
+            for p0, p1 in zip(pixels0, pixels1):
+                yield byte_to_freq((p0[1] + p1[1]) / 2), self.PIXEL
+            for p in pixels1:
+                yield byte_to_freq(p[0]), self.PIXEL
+
+
+class PD120(PD90):
+    VIS_CODE = 0x5f
+    WIDTH = 640
+    HEIGHT = 496
+    PIXEL = 0.19
+
+class PD160(PD90):
+    VIS_CODE = 0x62
+    WIDTH = 512
+    HEIGHT = 400
+    PIXEL = 0.382
+
+class PD180(PD120):
+    VIS_CODE = 0x60
+    PIXEL = 0.286
+
+class PD240(PD120):
+    VIS_CODE = 0x61
+    PIXEL = 0.382
+
+class PD290(PD240):
+    VIS_CODE = 0x5e
+    WIDTH = 800
+    HEIGHT = 616
+    PIXEL = 0.286
+
+
+MODES = (MartinM1, MartinM2, ScottieS1, ScottieS2, Robot36,
+        PasokonP3, PasokonP5, PasokonP7, PD90, PD120, PD160, PD180, PD240, PD290)

pysstv/examples/__init__.py

@@ -0,0 +1,3 @@
+#!/usr/bin/env python
+
+__all__ = ['overlay', 'pyaudio_sstv', 'repeater']

pysstv/examples/codegen.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python
+
+class Image(object):
+    def __init__(self, content):
+        self.content = content
+
+    def load(self):
+        return self
+
+    def __getitem__(self, item):
+        if isinstance(item, tuple):
+            x, y = item
+            return Image('{0}[(ROW({1}) + COL({2})) * 3'.format(self.content, y, x))
+        elif isinstance(item, int):
+            return Image('{0} + RGB({1})]'.format(self.content, item))
+        else:
+            raise NotImplementedError()
+
+    def __rmul__(self, n):
+        return Image('({1} * {0})'.format(self.content, float(n)))
+
+    def __mul__(self, n):
+        return Image('({0} * {1})'.format(self.content, float(n)))
+
+    def __rtruediv__(self, n):
+        return Image('({1} / {0})'.format(self.content, n))
+
+    def __truediv__(self, n):
+        return Image('({0} / {1})'.format(self.content, n))
+
+    def __radd__(self, n):
+        return Image('({1} + {0})'.format(self.content, n))
+
+    def __add__(self, n):
+        return Image('({0} + {1})'.format(self.content, n))
+
+    def __str__(self):
+        return self.content
+
+from pysstv.color import MartinM1, MartinM2, PasokonP3, PasokonP5, PasokonP7
+import re
+
+supported = [MartinM1, MartinM2, PasokonP3, PasokonP5, PasokonP7]
+ROW_RE = re.compile(r'ROW\(\d+\)')
+
+def main(sstv_class=None):
+    if sstv_class is None:
+        sstv_class = MartinM1
+    elif sstv_class not in supported:
+        raise NotImplementedError()
+    sstv = sstv_class(Image('img'), 44100, 16)
+    n = 0
+    yield '#define ROW(x) x'
+    yield '#define COL(x) x'
+    yield '#define RGB(x) x'
+    yield 'void convert(unsigned char *img, float *freqs, float *msecs, const int width) {\nint frq = 0;'
+    history = []
+    lut = {}
+    same_as = {}
+    for freq, msec in sstv.gen_freq_bits():
+        printed = 'freqs[frq] = {1}; msecs[frq++] = {2};'.format(n, freq, msec)
+        key = ROW_RE.sub('row', printed)
+        old = lut.get(key)
+        if old is not None:
+            same_as[n] = old
+        else:
+            lut[key] = n
+        history.append((printed, key))
+        n += 1
+    del lut
+    m_start, m_len = gen_matches(same_as, history, n)
+    for i in range(same_as[m_start]):
+        yield history[i][0]
+    yield 'for (int row = 0; row < width * {0}; row += width) {{'.format(sstv.HEIGHT)
+    for i in range(same_as[m_start], same_as[m_start] + m_len - 1):
+        yield ' ' + history[i][1]
+    yield '}'
+    yield '}}\n\n#define FREQ_COUNT {0}'.format(n)
+
+
+
+def gen_matches(same_as, history, n):
+    cur_start = None
+    cur_len = None
+    cur_end = None
+    for i in range(n):
+        if cur_start is None:
+            tmp = same_as.get(i)
+            if tmp is not None:
+                cur_len = 1
+                cur_start = i
+                cur_end = tmp
+        else:
+            tmp = same_as.get(i)
+            if tmp is not None and history[tmp][1] == history[cur_end + 1][1] and cur_start > cur_end:
+                cur_len += 1
+                cur_end += 1
+            else:
+                if tmp is not None and history[tmp][1] == history[cur_end + 1][1]:
+                    return cur_start, cur_len
+                tmp = same_as.get(i)
+                if tmp is None:
+                    cur_start = None
+                else:
+                    cur_len = 1
+                    cur_start = i
+                    cur_end = tmp
+
+def test(img_file):
+    from subprocess import Popen, PIPE, check_output
+    from os import remove, path
+    from PIL import Image
+    from datetime import datetime
+    import struct
+    exe = './codegen-test-executable'
+    if not path.exists('stb_image.h'):
+        from urllib.request import urlretrieve
+        urlretrieve('https://raw.githubusercontent.com/nothings/stb/master/stb_image.h', 'stb_image.h')
+    try:
+        for sstv_class in supported:
+            print('Testing', sstv_class)
+            gcc = Popen(['gcc', '-xc', '-lm', '-o', exe, '-'], stdin=PIPE)
+            start = datetime.now()
+            with open(path.join(path.dirname(__file__), 'codeman.c')) as cm:
+                c_src = cm.read().replace('#include "codegen.c"', '\n'.join(main(sstv_class)))
+                gcc.communicate(c_src)
+            gen_elapsed = datetime.now() - start
+            print(' - gengcc took', gen_elapsed)
+            start = datetime.now()
+            gen = check_output([exe, img_file])
+            native_elapsed = datetime.now() - start
+            print(' - native took', native_elapsed)
+            img = Image.open(img_file)
+            sstv = sstv_class(img, 44100, 16)
+            start = datetime.now()
+            try:
+                for n, (freq, msec) in enumerate(sstv.gen_freq_bits()):
+                    assert gen[n * 8:(n + 1) * 8] == struct.pack('ff', freq, msec)
+            except AssertionError:
+                mode_name = sstv_class.__name__
+                with open('/tmp/{0}-c.bin'.format(mode_name), 'wb') as f:
+                    f.write(gen)
+                with open('/tmp/{0}-py.bin'.format(mode_name), 'wb') as f:
+                    for n, (freq, msec) in enumerate(sstv.gen_freq_bits()):
+                        f.write(struct.pack('ff', freq, msec))
+                with open('/tmp/{0}.c'.format(mode_name), 'w') as f:
+                    f.write(c_src)
+                print((" ! Outputs are different, they've been saved to "
+                    "/tmp/{0}-{{c,py}}.bin, along with the C source code "
+                    "in /tmp/{0}.c").format(mode_name))
+            python_elapsed = datetime.now() - start
+            print(' - python took', python_elapsed)
+            print(' - speedup:', python_elapsed.total_seconds() / native_elapsed.total_seconds())
+        print('OK')
+    finally:
+        try:
+            remove(exe)
+        except OSError:
+            pass
+
+
+if __name__ == '__main__':
+    from sys import argv
+    if len(argv) > 2 and argv[1] == 'test':
+        test(argv[2])
+    else:
+        print('\n'.join(main()))

pysstv/examples/get_floats.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+
+"""
+This example streams the raw floating point samples to stdout in 4-byte
+single precision format, so that it can be processed outside PySSTV.
+
+Usage example: get_floats.py | play -r 44100 -t f32 -c 1 --norm -
+"""
+
+from PIL import Image
+from pysstv.grayscale import Robot8BW
+import struct, sys
+
+def main():
+    img = Image.open("160x120bw.png")
+    sstv = Robot8BW(img, 44100, 16)
+    sstv.vox_enabled = True
+    for value in sstv.gen_values():
+        sys.stdout.write(struct.pack('f', value))
+
+if __name__ == '__main__':
+    main()

pysstv/examples/get_freq_bits.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+
+"""
+This example streams the raw floating point (freq, msec) tuples to stdout
+in 4-byte single precision format (8 bytes per tuple), so that it can be
+processed outside PySSTV.
+
+Usage example using unixsstv/gen_values:
+get_freq_bits.py | gen_values 44100 | play -r 44100 -t f32 -c 1 --norm -
+"""
+
+from PIL import Image
+from pysstv.color import MartinM1
+import struct, sys
+
+def main():
+    img = Image.open("320x256rgb.png")
+    sstv = MartinM1(img, 44100, 16)
+    for freq, msec in sstv.gen_freq_bits():
+        sys.stdout.write(struct.pack('ff', freq, msec))
+
+if __name__ == '__main__':
+    main()