SSDV.h

#if !defined(RADIOLIB_SSDV_H)
#define RADIOLIB_SSDV_H
 
#include "../../TypeDef.h"
 
#if !RADIOLIB_EXCLUDE_SSDV
 
#include "../PhysicalLayer/PhysicalLayer.h"
 
/*
  SSDV (Slow Scan Digital Video) packet layout, see https://ukhas.org.uk/doku.php?id=guides:ssdv
 
  Byte     Normal (FEC)       No-FEC            Content
  0        0x55               0x55              sync
  1        0x66               0x67              packet type
  2-5                                           callsign, base-40 encoded, MSB first
  6                                             image ID
  7-8                                           packet ID, MSB first
  9                                             image width / 16
  10                                            image height / 16
  11                                            [7:6] 0, [5:3] quality XOR 4, [2] EOI, [1:0] MCU mode
  12                                            offset of first MCU in payload (0xFF = none)
  13-14                                         index of first MCU, MSB first (0xFFFF = none)
  15-...   205 B payload      237 B payload     re-encoded JPEG scan data
  ...      CRC-32             CRC-32            over bytes 1 to end of payload
  224-255  RS(255,223) parity -                 over bytes 1-223
*/
 
#ifndef RADIOLIB_SSDV_MAX_PACKETS
#define RADIOLIB_SSDV_MAX_PACKETS                               (512)
#endif
 
// packet sizes in bytes
#define RADIOLIB_SSDV_PACKET_LEN                                (256)
#define RADIOLIB_SSDV_HEADER_LEN                                (15)
#define RADIOLIB_SSDV_CRC_LEN                                   (4)
#define RADIOLIB_SSDV_RS_LEN                                    (32)
#define RADIOLIB_SSDV_PAYLOAD_LEN_FEC                           (RADIOLIB_SSDV_PACKET_LEN - RADIOLIB_SSDV_HEADER_LEN - RADIOLIB_SSDV_CRC_LEN - RADIOLIB_SSDV_RS_LEN)
#define RADIOLIB_SSDV_PAYLOAD_LEN_NOFEC                         (RADIOLIB_SSDV_PACKET_LEN - RADIOLIB_SSDV_HEADER_LEN - RADIOLIB_SSDV_CRC_LEN)
 
// packet fields
#define RADIOLIB_SSDV_SYNC_WORD                                 (0x55)
#define RADIOLIB_SSDV_TYPE_OFFSET                               (0x66)
#define RADIOLIB_SSDV_TYPE_NORMAL                               (0x00)
#define RADIOLIB_SSDV_TYPE_NOFEC                                (0x01)
#define RADIOLIB_SSDV_TYPE_INVALID                              (0xFF)
#define RADIOLIB_SSDV_MCU_NONE                                  (0xFFFF)
 
// maximum callsign length in characters
#define RADIOLIB_SSDV_CALLSIGN_MAX_LEN                          (6)
 
// maximum quality level
#define RADIOLIB_SSDV_QUALITY_MAX                               (7)

#define RADIOLIB_SSDV_EOI                                       (1)

struct SSDVPacketInfo_t {
  uint8_t type;

  uint32_t callsignCode;

  char callsign[RADIOLIB_SSDV_CALLSIGN_MAX_LEN + 1];

  uint8_t imageId;

  uint16_t packetId;

  uint16_t width;

  uint16_t height;

  bool eoi;

  uint8_t quality;

  uint8_t mcuMode;

  uint8_t mcuOffset;

  uint16_t mcuId;

  uint16_t mcuCount;
};
 
// internal encoder/decoder state
// maximum size of the DQT and DHT tables, plus room for marker data
#define RADIOLIB_SSDV_TBL_LEN                                   (546)
#define RADIOLIB_SSDV_HBUFF_LEN                                 (16)
 
struct SSDVState_t {
  // packet configuration
  uint8_t type;
  uint16_t payloadLen;
  uint16_t crcDataLen;
 
  // image information
  uint16_t width;
  uint16_t height;
  uint32_t callsign;
  uint8_t imageId;
  uint16_t packetId;
  uint8_t mcuMode;
  uint16_t mcuId;
  uint16_t mcuCount;
  uint8_t quality;
  uint16_t packetMcuId;
  uint8_t packetMcuOffset;
 
  // input bytes and bits
  const uint8_t* inp;
  size_t inLen;
  size_t inSkip;
  uint32_t workBits;
  uint8_t workLen;
 
  // output bytes and bits
  uint8_t* out;
  uint8_t* outp;
  size_t outLen;
  bool outStuff;
  uint64_t outBits;
  uint8_t outBitsLen;
  bool outOverflow;       // bits were dropped because the output buffer was full
 
  // JPEG state machine
  uint8_t state;
  bool encoding;
  uint16_t marker;
  uint16_t markerLen;
  uint8_t* markerData;
  uint16_t markerDataLen;
  bool greyscale;
  uint8_t component;      // 0 = Y, 1 = Cb, 2 = Cr
  uint8_t ycParts;        // number of Y blocks per MCU
  uint8_t mcuPart;        // 0 - 3 = Y, then Cb, Cr
  uint8_t acPart;         // 0 = DC, 1 - 63 = AC
  int32_t dc[3];
  int32_t adc[3];
  uint8_t acRle;
  uint8_t acAccRle;
  uint16_t dri;
  uint32_t resetMcu;
  uint32_t nextResetMcu;
  uint8_t needBits;
 
  // source (input) and destination (output) Huffman and quantisation tables
  uint8_t srcTbls[RADIOLIB_SSDV_TBL_LEN + RADIOLIB_SSDV_HBUFF_LEN];
  uint8_t* srcDht[2][2];
  uint8_t* srcDqt[2];
  uint16_t srcTblLen;
  uint8_t dstTbls[RADIOLIB_SSDV_TBL_LEN];
  uint8_t* dstDht[2][2];
  uint8_t* dstDqt[2];
  uint16_t dstTblLen;
};

class SSDVClient {
  public:
    explicit SSDVClient(PhysicalLayer* phy, bool fec = true);

    ~SSDVClient();

    int16_t begin(const char* callsign);
 
    // transmit methods

    int16_t setImage(const uint8_t* jpegData, size_t jpegLen, uint8_t quality = 4, int16_t imageId = -1);

    uint16_t numPackets();

    bool isDone();

    uint16_t currentPacketIndex();

    int16_t transmit(uint16_t* packetId = NULL);

    int16_t transmitLoRa(uint16_t* packetId = NULL);

    void clearImage();
 
    // receive methods

    int16_t read(uint8_t* packet);

    static int16_t isValidPacket(uint8_t* packet, int16_t* errors = NULL);

    static void parseHeader(const uint8_t* packet, SSDVPacketInfo_t* info);

    int16_t beginDecoder(uint8_t* jpegBuf, size_t jpegBufLen);

    int16_t feedPacket(const uint8_t* packet);

    int16_t getJpeg(uint8_t** jpegPtr, size_t* jpegLen);

    int16_t resetDecoder();

    void endDecoder();
 
#if !RADIOLIB_GODMODE
  private:
#endif
    PhysicalLayer* phyLayer;
    bool fec;
    bool initialized;
    char callsign[RADIOLIB_SSDV_CALLSIGN_MAX_LEN + 1];
    uint8_t imageId;
 
    // transmitter, the packet buffer is owned by this instance
    SSDVState_t encoder;
    uint8_t* txBuf;
    uint16_t packetCount;
    uint16_t packetIndex;
 
    // receiver, the JPEG buffer is owned by the caller
    SSDVState_t decoder;
    uint8_t* rxBuf;
    size_t jpegBufLen;
    size_t jpegLen;
    bool jpegReady;
 
    SSDVClient(const SSDVClient&);
    SSDVClient& operator=(const SSDVClient&);
 
    int32_t encode(const uint8_t* jpegData, size_t jpegLen, uint8_t quality, uint8_t* dst, uint16_t maxPackets);
    int16_t transmitPacket(uint8_t offset, uint16_t* packetId);
};
 
#endif
 
#endif