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 encoder and class decoder, and discuss how to use them.

#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);

    // 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;

    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;
}