Code Example: Encode and Decode

In this example shows how to use the API of otacast to implement encoding and decoding.

The example will walk through the basic functionality of class otacast::encoder and class otacast::decoder, and discuss how to use them.

// Copyright (c) Steinwurf ApS 2023.
// This file is licensed under the terms of the accompanying LICENSE.rst file.

#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>

#include <otacast/decoder.hpp>
#include <otacast/encoder.hpp>
#include <otacast/version.hpp>

int main()
{
    // Create the encoder/decoder objects with a specific finite field
    otacast::encoder encoder;
    otacast::decoder decoder;

    std::size_t block_bytes = 1024 * 1000 * 500; // 500 MB
    std::size_t symbol_bytes = 1500;             // 1.5 kB
    auto width = otacast::codec_width::_32;

    encoder.configure(width, block_bytes, symbol_bytes);
    decoder.configure(width, block_bytes, symbol_bytes);

    std::cout << "Preparing some random test data..." << std::endl;

    // Allocate some data to decode
    std::vector<uint8_t> data_in(encoder.block_bytes());

    // For the example - fill data_in with random data
    std::generate(data_in.begin(), data_in.end(), rand);

    // Assign the data buffer to the encoder so that we may start
    // to produce encoded symbols from it
    encoder.set_symbols_storage(data_in.data());

    // Define a data buffer where the symbols should be decoded
    std::vector<uint8_t> data_out(decoder.block_bytes());
    decoder.set_symbols_storage(data_out.data());

    // Initiate a zero-vector for the offset
    std::vector<uint8_t> symbol(encoder.symbol_bytes());

    // The seed can be anything, here it's basically a packet sequence number.
    // Will be used to count transmissions as well
    std::size_t transmissions = 0;

    // Count number of packets received
    std::size_t received = 0;

    // Set up some packet loss
    auto loss_probability = 10;

    std::cout << "Encoding/decoding..." << std::endl;

    while (!decoder.is_complete())
    {
        // Generate an encoded packet using the number of transmissions as seed
        auto offset = encoder.encode(symbol.data(), transmissions);

        // We see if the packet is lost
        if (rand() % 100 >= loss_probability)
        {
            // Decode the encoded packet using the number of transmissions as
            // seed
            decoder.decode(symbol.data(), transmissions, offset);
            received++;
        }
        transmissions++;
    }

    // Calculate the overhead
    auto data_received = received * decoder.symbol_bytes();
    auto overhead = (data_received / (double)decoder.block_bytes()) - 1;

    // Check if everything went as it should
    if (data_in == data_out)
    {
        std::cout << "Decoding finished successfully!" << std::endl;
        std::cout << "Overhead: " << overhead * 100 << "%" << std::endl;
    }
    else
    {
        std::cout << "Something went wrong!" << std::endl;
    }

    return 0;
}