Beispiel #1
0
static void test_encoder_factory(uint32_t max_symbols, uint32_t max_symbol_size,
                                 int32_t codec, int32_t finite_field)
{
    kodoc_factory_t encoder_factory =
        kodoc_new_encoder_factory(codec, finite_field,
                                  max_symbols, max_symbol_size);

    // Test the max_* properties
    EXPECT_EQ(max_symbols, kodoc_factory_max_symbols(encoder_factory));
    EXPECT_EQ(max_symbol_size, kodoc_factory_max_symbol_size(encoder_factory));
    EXPECT_EQ(max_symbol_size * max_symbols,
              kodoc_factory_max_block_size(encoder_factory));
    EXPECT_GT(kodoc_factory_max_payload_size(encoder_factory), max_symbol_size);

    // Build an encoder with the default settings
    kodoc_coder_t encoder = kodoc_factory_build_coder(encoder_factory);

    EXPECT_EQ(max_symbols, kodoc_symbols(encoder));
    EXPECT_EQ(max_symbol_size, kodoc_symbol_size(encoder));

    // Lower the number of symbols and the symbol_size
    uint32_t new_symbols = max_symbols / 2;
    kodoc_factory_set_symbols(encoder_factory, new_symbols);

    uint32_t new_symbol_size = max_symbol_size - 4;
    kodoc_factory_set_symbol_size(encoder_factory, new_symbol_size);

    // Test that the max_* properties are not changed
    EXPECT_EQ(max_symbols, kodoc_factory_max_symbols(encoder_factory));
    EXPECT_EQ(max_symbol_size, kodoc_factory_max_symbol_size(encoder_factory));
    EXPECT_EQ(max_symbol_size * max_symbols,
              kodoc_factory_max_block_size(encoder_factory));
    EXPECT_GT(kodoc_factory_max_payload_size(encoder_factory), max_symbol_size);

    // Build an encoder with the changed settings
    kodoc_coder_t encoder2 = kodoc_factory_build_coder(encoder_factory);

    EXPECT_EQ(new_symbols, kodoc_symbols(encoder2));
    EXPECT_EQ(new_symbol_size, kodoc_symbol_size(encoder2));

    kodoc_delete_coder(encoder);
    kodoc_delete_coder(encoder2);
    kodoc_delete_factory(encoder_factory);
}
Beispiel #2
0
static void test_decoder(uint32_t symbols, uint32_t symbol_size,
                         int32_t codec, int32_t finite_field)
{
    kodoc_factory_t decoder_factory = kodoc_new_decoder_factory(
        codec, finite_field, symbols, symbol_size);

    kodoc_coder_t decoder = kodoc_factory_build_coder(decoder_factory);

    // Coder methods
    test_coder(decoder, symbols, symbol_size, codec);

    // Decoder methods
    // Some codecs do not provide write_payload, i.e. recoding
    if (codec == kodoc_seed || codec == kodoc_sparse_seed ||
        codec == kodoc_fulcrum || codec == kodoc_reed_solomon)
    {
        EXPECT_TRUE(kodoc_has_write_payload(decoder) == 0);
    }
    else
    {
        EXPECT_TRUE(kodoc_has_write_payload(decoder) != 0);
    }

    EXPECT_EQ(0U, kodoc_symbols_uncoded(decoder));
    EXPECT_EQ(0U, kodoc_symbols_partially_decoded(decoder));

    if (codec == kodoc_on_the_fly ||
        codec == kodoc_sliding_window)
    {
        EXPECT_TRUE(kodoc_has_partial_decoding_interface(decoder) != 0);
    }
    else if (codec == kodoc_full_vector)
    {
        EXPECT_TRUE(kodoc_has_partial_decoding_interface(decoder) == 0);
    }

    kodoc_delete_coder(decoder);
    kodoc_delete_factory(decoder_factory);
}
Beispiel #3
0
inline void test_decoder_symbol_status_api(int32_t decoder_type)
{
    uint32_t symbols = 4;
    uint32_t symbol_size = 40;
    kodoc_factory_t decoder_factory = kodoc_new_decoder_factory(
        decoder_type, kodoc_binary8, symbols, symbol_size);

    kodoc_coder_t decoder = kodoc_factory_build_coder(decoder_factory);

    std::vector<uint8_t> data_out(kodoc_block_size(decoder), '\0');
    kodoc_set_mutable_symbols(decoder, data_out.data(), data_out.size());

    std::vector<uint8_t> symbol(kodoc_symbol_size(decoder));
    std::vector<uint8_t> coefficients(kodoc_coefficient_vector_size(decoder));

    coefficients = {1, 0, 0, 0};
    kodoc_read_symbol(decoder, symbol.data(), coefficients.data());

    EXPECT_EQ(0U, kodoc_symbols_uncoded(decoder));

    kodoc_update_symbol_status(decoder);

    EXPECT_EQ(1U, kodoc_symbols_uncoded(decoder));

    kodoc_set_status_updater_on(decoder);

    coefficients = {0, 1, 0, 0};
    kodoc_read_symbol(decoder, symbol.data(), coefficients.data());

    EXPECT_EQ(2U, kodoc_symbols_uncoded(decoder));

    kodoc_set_status_updater_off(decoder);

    kodoc_delete_coder(decoder);
    kodoc_delete_factory(decoder_factory);
}
Beispiel #4
0
int main()
{
    // Seed the random number generator to produce different data every time
    srand(time(NULL));

    // Set the number of symbols and the symbol size
    uint32_t max_symbols = 10;
    uint32_t max_symbol_size = 100;

    // Here we select the codec we wish to use
    int32_t codec = kodoc_reed_solomon;

    // Here we select the finite field to use.
    // For the Reed-Solomon codec, we need to choose kodoc_binary8
    int32_t finite_field = kodoc_binary8;

    kodoc_factory_t encoder_factory =
        kodoc_new_encoder_factory(codec, finite_field,
                                 max_symbols, max_symbol_size);

    kodoc_factory_t decoder_factory =
        kodoc_new_decoder_factory(codec, finite_field,
                                 max_symbols, max_symbol_size);

    kodoc_coder_t encoder = kodoc_factory_build_coder(encoder_factory);
    kodoc_coder_t decoder = kodoc_factory_build_coder(decoder_factory);

    // Allocate some storage for a "payload". The payload is what we would
    // eventually send over a network.
    uint32_t bytes_used;
    uint32_t payload_size = kodoc_payload_size(encoder);
    uint8_t* payload = (uint8_t*) malloc(payload_size);

    // Allocate input and output data buffers
    uint32_t block_size = kodoc_block_size(encoder);
    uint8_t* data_in = (uint8_t*) malloc(block_size);
    uint8_t* data_out = (uint8_t*) malloc(block_size);

    // Fill the input buffer with random data
    uint32_t i = 0;
    for(; i < block_size; ++i)
        data_in[i] = rand() % 256;

    // Assign the data buffers to the encoder and decoder
    kodoc_set_const_symbols(encoder, data_in, block_size);
    kodoc_set_mutable_symbols(decoder, data_out, block_size);

    // Install a custom trace function for the decoder
    kodoc_set_trace_callback(decoder, trace_callback, NULL);

    uint32_t lost_payloads = 0;
    uint32_t received_payloads = 0;
    while (!kodoc_is_complete(decoder))
    {
        // The encoder will use a certain amount of bytes of the payload buffer
        bytes_used = kodoc_write_payload(encoder, payload);
        printf("Payload generated by encoder, bytes used = %d\n", bytes_used);

        // Simulate a channel with a 50% loss rate
        if (rand() % 2)
        {
            lost_payloads++;
            printf("Symbol lost on channel\n\n");
            continue;
        }

        // Pass the generated packet to the decoder
        received_payloads++;
        kodoc_read_payload(decoder, payload);
        printf("Payload processed by decoder, current rank = %d\n\n",
               kodoc_rank(decoder));
    }

    printf("Number of lost payloads: %d\n", lost_payloads);
    printf("Number of received payloads: %d\n", received_payloads);

    // Check that we properly decoded the data
    if (memcmp(data_in, data_out, block_size) == 0)
    {
        printf("Data decoded correctly\n");
    }
    else
    {
        printf("Unexpected failure to decode, please file a bug report :)\n");
    }

    // Free the allocated buffers and the kodo objects
    free(data_in);
    free(data_out);
    free(payload);

    kodoc_delete_coder(encoder);
    kodoc_delete_coder(decoder);

    kodoc_delete_factory(encoder_factory);
    kodoc_delete_factory(decoder_factory);

    return 0;
}
Beispiel #5
0
inline void run_test_basic_api(int32_t encoder_type, int32_t decoder_type,
                               int32_t finite_field, uint32_t symbols,
                               uint32_t symbol_size)
{
    kodoc_factory_t encoder_factory = kodoc_new_encoder_factory(
        encoder_type, finite_field, symbols, symbol_size);

    kodoc_factory_t decoder_factory = kodoc_new_decoder_factory(
        decoder_type, finite_field, symbols, symbol_size);

    kodoc_coder_t encoder = kodoc_factory_build_coder(encoder_factory);
    kodoc_coder_t decoder = kodoc_factory_build_coder(decoder_factory);

    EXPECT_EQ(symbols, kodoc_factory_max_symbols(encoder_factory));
    EXPECT_EQ(symbol_size, kodoc_factory_max_symbol_size(encoder_factory));
    EXPECT_EQ(symbols, kodoc_symbols(encoder));
    EXPECT_EQ(symbol_size, kodoc_symbol_size(encoder));

    EXPECT_EQ(symbols, kodoc_factory_max_symbols(decoder_factory));
    EXPECT_EQ(symbol_size, kodoc_factory_max_symbol_size(decoder_factory));
    EXPECT_EQ(symbols, kodoc_symbols(decoder));
    EXPECT_EQ(symbol_size, kodoc_symbol_size(decoder));

    EXPECT_EQ(symbols * symbol_size, kodoc_block_size(encoder));
    EXPECT_EQ(symbols * symbol_size, kodoc_block_size(decoder));

    EXPECT_TRUE(kodoc_factory_max_payload_size(encoder_factory) >=
                kodoc_payload_size(encoder));

    EXPECT_TRUE(kodoc_factory_max_payload_size(decoder_factory) >=
                kodoc_payload_size(decoder));

    EXPECT_EQ(kodoc_factory_max_payload_size(encoder_factory),
              kodoc_factory_max_payload_size(decoder_factory));

    if (encoder_type == kodoc_sparse_full_vector ||
        encoder_type == kodoc_sparse_seed)
    {
        // Set the coding vector density on the encoder
        kodoc_set_density(encoder, 0.2);
        EXPECT_EQ(0.2, kodoc_density(encoder));
    }

    uint32_t payload_size = kodoc_payload_size(encoder);
    uint8_t* payload = (uint8_t*) malloc(payload_size);

    uint8_t** input_symbols = NULL;
    uint8_t** output_symbols = NULL;

    // Allocate symbols in non-contiguous buffers
    input_symbols = (uint8_t**) malloc(symbols * sizeof(uint8_t*));
    output_symbols = (uint8_t**) malloc(symbols * sizeof(uint8_t*));

    for (uint32_t i = 0; i < symbols; ++i)
    {
        // Create the individual symbols for the encoder
        input_symbols[i] = (uint8_t*) malloc(symbol_size);

        // Randomize input data
        for (uint32_t j = 0; j < symbol_size; ++j)
            input_symbols[i][j] = rand() % 256;

        // Store the symbol pointer in the encoder
        kodoc_set_const_symbol(encoder, i, input_symbols[i], symbol_size);

        // Create the output symbol buffers for the decoder
        output_symbols[i] = (uint8_t*) malloc(symbol_size);

        // Specify the output buffers used for decoding
        kodoc_set_mutable_symbol(decoder, i, output_symbols[i], symbol_size);
    }

    if (kodoc_has_symbol_decoding_status_updater_interface(decoder))
    {
        EXPECT_FALSE(kodoc_is_status_updater_enabled(decoder));
        kodoc_set_status_updater_on(decoder);
        EXPECT_TRUE(kodoc_is_status_updater_enabled(decoder));
        kodoc_set_status_updater_off(decoder);
        EXPECT_FALSE(kodoc_is_status_updater_enabled(decoder));
    }
    else
    {
        EXPECT_TRUE(
            decoder_type == kodoc_fulcrum ||
            decoder_type == kodoc_reed_solomon
        );
    }

    EXPECT_TRUE(kodoc_is_complete(decoder) == 0);

    while (!kodoc_is_complete(decoder))
    {
        kodoc_write_payload(encoder, payload);
        kodoc_read_payload(decoder, payload);
    }

    EXPECT_TRUE(kodoc_is_complete(decoder) != 0);
    EXPECT_EQ(symbols, kodoc_rank(decoder));
    EXPECT_EQ(symbols, kodoc_symbols_uncoded(decoder));
    EXPECT_EQ(0U, kodoc_symbols_partially_decoded(decoder));
    EXPECT_EQ(0U, kodoc_symbols_missing(decoder));

    assert(input_symbols);
    assert(output_symbols);
    // Compare the input and output symbols one-by-one
    for (uint32_t i = 0; i < symbols; ++i)
    {
        EXPECT_EQ(memcmp(input_symbols[i], output_symbols[i], symbol_size), 0);

        free(input_symbols[i]);
        free(output_symbols[i]);
    }

    free(input_symbols);
    free(output_symbols);

    free(payload);

    kodoc_delete_coder(encoder);
    kodoc_delete_coder(decoder);

    kodoc_delete_factory(encoder_factory);
    kodoc_delete_factory(decoder_factory);
}
Beispiel #6
0
int main()
{
    // Seed random number generator to produce different results every time
    srand(time(NULL));

    // Set the number of symbols (i.e. the generation size in RLNC
    // terminology) and the size of a symbol in bytes
    uint8_t max_symbols = 10;
    uint8_t max_symbol_size = 100;

    int32_t codec = kodoc_full_vector;
    int32_t finite_field = kodoc_binary8;

    // In the following we will make an encoder/decoder factory.
    // The factories are used to build actual encoders/decoder
    kodoc_factory_t encoder_factory =
        kodoc_new_encoder_factory(codec, finite_field,
                                  max_symbols, max_symbol_size);

    kodoc_factory_t decoder_factory =
        kodoc_new_decoder_factory(codec, finite_field,
                                  max_symbols, max_symbol_size);

    // If we wanted to build an encoder or decoder with a smaller number of
    // symbols or a different symbol size, then this can be adjusted using the
    // following functions:
    //      kodoc_factory_set_symbols(...)
    //      kodoc_factory_set_symbol_size(...)
    // We cannot exceed the maximum values which was used when building
    // the factory.
    kodoc_coder_t encoder = kodoc_factory_build_coder(encoder_factory);
    kodoc_coder_t decoder = kodoc_factory_build_coder(decoder_factory);

    // Allocate some storage for a "payload" the payload is what we would
    // eventually send over a network
    uint32_t payload_size = kodoc_payload_size(encoder);
    uint8_t* payload = (uint8_t*) malloc(payload_size);

    // Allocate some data to encode. In this case we make a buffer
    // with the same size as the encoder's block size (the max.
    // amount a single encoder can encode)
    uint32_t block_size = kodoc_block_size(encoder);
    uint8_t* data_in = (uint8_t*) malloc(block_size);

    // Just for fun - fill the data with random data
    uint32_t i = 0;
    for (; i < block_size; ++i)
    {
        data_in[i] = rand() % 256;
    }

    kodoc_set_const_symbols(encoder, data_in, block_size);

    uint8_t* data_out = (uint8_t*) malloc(block_size);
    kodoc_set_mutable_symbols(decoder, data_out, block_size);

    printf("Starting encoding / decoding\n");
    while (!kodoc_is_complete(decoder))
    {
        // If the chosen codec stack supports systematic coding
        if (kodoc_has_systematic_interface(encoder))
        {
            // With 50% probability toggle systematic
            if ((rand() % 2) == 0)
            {
                if (kodoc_is_systematic_on(encoder))
                {
                    printf("Turning systematic OFF\n");
                    kodoc_set_systematic_off(encoder);
                }
                else
                {
                    printf("Turn systematic ON\n");
                    kodoc_set_systematic_on(encoder);
                }
            }
        }

        // Encode a packet into the payload buffer
        kodoc_write_payload(encoder, payload);

        if ((rand() % 2) == 0)
        {
            printf("Drop packet\n");
            continue;
        }

        // Pass that packet to the decoder
        kodoc_read_payload(decoder, payload);

        printf("Rank of decoder %d\n", kodoc_rank(decoder));

        // Symbols that were received in the systematic phase correspond
        // to the original source symbols and are therefore marked as
        // decoded
        printf("Symbols decoded %d\n", kodoc_symbols_uncoded(decoder));
    }

    if (memcmp(data_in, data_out, block_size) == 0)
    {
        printf("Data decoded correctly\n");
    }
    else
    {
        printf("Unexpected failure to decode, please file a bug report :)\n");
    }

    free(data_in);
    free(payload);

    kodoc_delete_coder(encoder);
    kodoc_delete_coder(decoder);

    kodoc_delete_factory(encoder_factory);
    kodoc_delete_factory(decoder_factory);

    return 0;
}
int main()
{
    // Seed the random number generator to produce different data every time
    srand(time(NULL));

    // Set the number of symbols (i.e. the generation size in RLNC
    // terminology) and the size of a symbol in bytes
    uint32_t max_symbols = 10;
    uint32_t max_symbol_size = 100;

    // Here we select the codec we wish to use
    int32_t codec = kodoc_full_vector;

    // Here we select the finite field to use.
    // Some common choices are: kodoc_binary, kodoc_binary4, kodoc_binary8
    int32_t finite_field = kodoc_binary;

    // First, we create an encoder & decoder factory.
    // The factories are used to build actual encoders/decoders
    kodoc_factory_t encoder_factory =
        kodoc_new_encoder_factory(codec, finite_field,
                                 max_symbols, max_symbol_size);

    kodoc_factory_t decoder_factory =
        kodoc_new_decoder_factory(codec, finite_field,
                                 max_symbols, max_symbol_size);

    // If we wanted to build an encoder or decoder with a smaller number of
    // symbols or a different symbol size, then this can be adjusted using the
    // following functions:
    // kodoc_factory_set_symbols(...) and kodoc_factory_set_symbol_size(...)
    // We can however not exceed the maximum values that were used when
    // creating the factory.

    kodoc_coder_t encoder = kodoc_factory_build_coder(encoder_factory);
    kodoc_coder_t decoder = kodoc_factory_build_coder(decoder_factory);

    uint32_t bytes_used;
    uint32_t payload_size = kodoc_payload_size(encoder);
    uint8_t* payload = (uint8_t*) malloc(payload_size);

    uint32_t block_size = kodoc_block_size(encoder);
    uint8_t* data_in = (uint8_t*) malloc(block_size);
    uint8_t* data_out = (uint8_t*) malloc(block_size);

    uint32_t i = 0;
    for(; i < block_size; ++i)
        data_in[i] = rand() % 256;

    kodoc_set_const_symbols(encoder, data_in, block_size);
    kodoc_set_mutable_symbols(decoder, data_out, block_size);

    // Most of the network coding algorithms supports a mode of operation
    // which is known as systematic coding. This basically means that
    // initially all symbols are sent once un-coded. The rational behind this
    // is that if no errors occur during the transmission we will not have
    // performed any unnecessary coding operations. An encoder will exit the
    // systematic phase automatically once all symbols have been sent un-coded
    // once.
    //
    // With Kodo we can ask an encoder whether it supports systematic encoding
    // or not using the following functions:

    if (kodoc_is_systematic_on(encoder))
    {
        printf("Systematic encoding enabled\n");
    }
    else
    {
        printf("Systematic encoding disabled\n");
    }

    // If we do not wish to use systematic encoding, but to do full coding
    // from the beginning we can turn systematic coding off using the following
    // API:
    //
    // if (kodoc_has_set_systematic_off(encoder))
    // {
    //    kodoc_set_systematic_off(encoder);
    // }

    // Install a custom trace function for the decoder
    kodoc_set_trace_callback(decoder, trace_callback, NULL);

    while (!kodoc_is_complete(decoder))
    {
        // The encoder will use a certain amount of bytes of the payload
        // buffer. It will never use more than payload_size, but it might
        // use less.
        bytes_used = kodoc_write_payload(encoder, payload);
        printf("Payload generated by encoder, rank = %d, bytes used = %d\n",
               kodoc_rank(encoder), bytes_used);

        // Pass the generated packet to the decoder
        kodoc_read_payload(decoder, payload);
        printf("Payload processed by decoder, current rank = %d\n",
               kodoc_rank(decoder));
    }

    if (memcmp(data_in, data_out, block_size) == 0)
    {
        printf("Data decoded correctly\n");
    }
    else
    {
        printf("Unexpected failure to decode, please file a bug report :)\n");
    }

    free(data_in);
    free(data_out);
    free(payload);

    kodoc_delete_coder(encoder);
    kodoc_delete_coder(decoder);

    kodoc_delete_factory(encoder_factory);
    kodoc_delete_factory(decoder_factory);

    return 0;
}
Beispiel #8
0
int main()
{
    // Seed random number generator to produce different results every time
    srand(time(NULL));

    // Set the number of symbols (i.e. the generation size in RLNC
    // terminology) and the size of a symbol in bytes
    uint8_t max_symbols = 6;
    uint8_t max_symbol_size = 100;

    int32_t codec = kodoc_sliding_window;
    int32_t finite_field = kodoc_binary8;

    // In the following we will make an encoder/decoder factory.
    // The factories are used to build actual encoders/decoders
    kodoc_factory_t encoder_factory =
        kodoc_new_encoder_factory(codec, finite_field,
                                  max_symbols, max_symbol_size);

    kodoc_factory_t decoder_factory =
        kodoc_new_decoder_factory(codec, finite_field,
                                  max_symbols, max_symbol_size);

    // If we wanted to build an encoder or decoder with a smaller number of
    // symbols or a different symbol size, then this can be adjusted using the
    // following functions:
    //      kodoc_factory_set_symbols(...)
    //      kodoc_factory_set_symbol_size(...)
    // We cannot exceed the maximum values which was used when building
    // the factory.
    kodoc_coder_t encoder = kodoc_factory_build_coder(encoder_factory);
    kodoc_coder_t decoder = kodoc_factory_build_coder(decoder_factory);

    // Allocate some storage for a "payload" the payload is what we would
    // eventually send over a network
    uint32_t payload_size = kodoc_payload_size(encoder);
    uint8_t* payload = (uint8_t*) malloc(payload_size);

    // Allocate some data to encode. In this case we make a buffer
    // with the same size as the encoder's block size (the max.
    // amount a single encoder can encode)
    uint32_t block_size = kodoc_block_size(encoder);
    uint8_t* data_in = (uint8_t*) malloc(block_size);

    uint8_t* data_out = (uint8_t*) malloc(block_size);
    kodoc_set_mutable_symbols(decoder, data_out, block_size);

    uint8_t feedback_size = (uint8_t) kodoc_feedback_size(encoder);
    uint8_t* feedback = (uint8_t*) malloc(feedback_size);

    uint32_t i = 0;

    //Just for fun - fill data_in with random data
    for (; i < block_size; ++i)
    {
        data_in[i] = rand() % 256;
    }

    // Install a custom trace function for the decoder
    kodoc_set_trace_callback(decoder, trace_callback, NULL);

    while (!kodoc_is_complete(decoder))
    {
        // Insert a new symbol until the encoder is full
        if (kodoc_rank(encoder) < max_symbols)
        {
            uint32_t rank = kodoc_rank(encoder);
            uint8_t* symbol = data_in + (rank * max_symbol_size);
            kodoc_set_const_symbol(encoder, rank, symbol, max_symbol_size);
            printf("Symbol %d added to the encoder\n", rank);
        }

        // Only send packets if the encoder has more data than the decoder
        if (kodoc_rank(encoder) == kodoc_rank(decoder))
        {
            continue;
        }

        // Write an encoded packet into the payload buffer
        kodoc_write_payload(encoder, payload);
        printf("Encoded packet generated\n");

        // Here we simulate that we are losing 50% of the packets
        if (rand() % 2)
        {
            printf("Packet dropped on channel\n\n");
            continue;
        }

        printf("Decoder received packet\n");

        // Packet got through - pass that packet to the decoder
        kodoc_read_payload(decoder, payload);

        printf("Encoder rank = %d\n", kodoc_rank(encoder));
        printf("Decoder rank = %d\n", kodoc_rank(decoder));

        printf("Decoder uncoded = %d\n", kodoc_symbols_uncoded(decoder));
        printf("Decoder partially decoded = %d\n",
               kodoc_symbols_partially_decoded(decoder));

        // Transmit the feedback
        kodoc_write_feedback(decoder, feedback);

        // Note that the feedback packets can also be lost in a real network,
        // but here we deliver all of them for the sake of simplicity
        printf("Received feedback from decoder\n\n");
        kodoc_read_feedback(encoder, feedback);
    }

    if (memcmp(data_in, data_out, block_size) == 0)
    {
        printf("Data decoded correctly\n");
    }
    else
    {
        printf("Unexpected failure to decode, please file a bug report :)\n");
    }

    free(data_in);
    free(data_out);
    free(payload);
    free(feedback);

    kodoc_delete_coder(encoder);
    kodoc_delete_coder(decoder);

    kodoc_delete_factory(encoder_factory);
    kodoc_delete_factory(decoder_factory);

    return 0;
}
JNIEXPORT
jboolean JNICALL Java_com_steinwurf_dummy_1android_MainActivity_runKodo(
    JNIEnv* env, jobject thiz)
{
    // Seed random number generator to produce different results every time
    srand(time(NULL));

    // Set the number of symbols (i.e. the generation size in RLNC
    // terminology) and the size of a symbol in bytes
    uint32_t max_symbols = 42;
    uint32_t max_symbol_size = 160;

    // Select the coding to use
    int32_t code_type = kodoc_full_vector;

    // Select the finite field
    int32_t finite_field = kodoc_binary;

    // Create the factories
    kodoc_factory_t encoder_factory =
        kodoc_new_encoder_factory(code_type, finite_field,
                                  max_symbols, max_symbol_size);

    kodoc_factory_t decoder_factory =
        kodoc_new_decoder_factory(code_type, finite_field,
                                  max_symbols, max_symbol_size);

    // Create the coders
    kodoc_coder_t encoder = kodoc_factory_build_coder(encoder_factory);
    kodoc_coder_t decoder = kodoc_factory_build_coder(decoder_factory);

    // Generate the data
    uint32_t payload_size = kodoc_payload_size(encoder);
    uint8_t* payload = (uint8_t*) malloc(payload_size);

    uint32_t block_size = kodoc_block_size(encoder);
    uint8_t* data_in = (uint8_t*) malloc(block_size);

    uint32_t i = 0;
    for (; i < block_size; ++i)
        data_in[i] = rand() % 256;

    // Set the date to encode
    kodoc_set_const_symbols(encoder, data_in, block_size);

    uint8_t* data_out = (uint8_t*) malloc(block_size);
    kodoc_set_mutable_symbols(decoder, data_out, block_size);

    // Run the decoding
    while (!kodoc_is_complete(decoder))
    {
        kodoc_write_payload(encoder, payload);
        kodoc_read_payload(decoder, payload);
    }

    // Check if the decoding was successful
    bool success = false;
    if (memcmp(data_in, data_out, block_size) == 0)
        success = true;

    // Clean up
    free(data_in);
    free(data_out);
    free(payload);

    kodoc_delete_coder(encoder);
    kodoc_delete_coder(decoder);

    kodoc_delete_factory(encoder_factory);
    kodoc_delete_factory(decoder_factory);

    return success;
}
Beispiel #10
0
void test_sliding_window(uint32_t max_symbols, uint32_t max_symbol_size,
                         int32_t finite_field)
{
    kodoc_factory_t encoder_factory = kodoc_new_encoder_factory(
        kodoc_sliding_window, finite_field, max_symbols, max_symbol_size);

    kodoc_factory_t decoder_factory = kodoc_new_decoder_factory(
        kodoc_sliding_window, finite_field, max_symbols, max_symbol_size);

    kodoc_coder_t encoder = kodoc_factory_build_coder(encoder_factory);
    kodoc_coder_t decoder = kodoc_factory_build_coder(decoder_factory);

    EXPECT_EQ(max_symbols,kodoc_factory_max_symbols(encoder_factory));
    EXPECT_EQ(max_symbol_size,kodoc_factory_max_symbol_size(encoder_factory));
    EXPECT_EQ(max_symbols, kodoc_symbols(encoder));
    EXPECT_EQ(max_symbol_size,kodoc_symbol_size(encoder));

    EXPECT_EQ(max_symbols, kodoc_factory_max_symbols(decoder_factory));
    EXPECT_EQ(max_symbol_size, kodoc_factory_max_symbol_size(decoder_factory));
    EXPECT_EQ(max_symbols, kodoc_symbols(decoder));
    EXPECT_EQ(max_symbol_size, kodoc_symbol_size(decoder));

    EXPECT_EQ(max_symbols * max_symbol_size, kodoc_block_size(encoder));
    EXPECT_EQ(max_symbols * max_symbol_size, kodoc_block_size(decoder));

    EXPECT_TRUE(kodoc_factory_max_payload_size(encoder_factory) >=
                kodoc_payload_size(encoder));

    EXPECT_TRUE(kodoc_factory_max_payload_size(decoder_factory) >=
                kodoc_payload_size(decoder));

    EXPECT_EQ(kodoc_factory_max_payload_size(encoder_factory),
              kodoc_factory_max_payload_size(decoder_factory));

    uint32_t feedback_size = 0;

    EXPECT_EQ(kodoc_feedback_size(encoder), kodoc_feedback_size(decoder));

    feedback_size = kodoc_feedback_size(encoder);
    EXPECT_TRUE(feedback_size > 0);

    // Allocate some storage for a "payload" the payload is what we would
    // eventually send over a network
    uint32_t payload_size = kodoc_payload_size(encoder);
    uint8_t* payload = (uint8_t*) malloc(payload_size);
    uint8_t* feedback = (uint8_t*) malloc(feedback_size);

    // Allocate some data to encode. In this case we make a buffer
    // with the same size as the encoder's block size (the max.
    // amount a single encoder can encode)
    uint32_t block_size = kodoc_block_size(encoder);
    uint8_t* data_in = (uint8_t*) malloc(block_size);
    uint8_t* data_out = (uint8_t*) malloc(block_size);

    // Just for fun - fill the data with random data
    for (uint32_t i = 0; i < block_size; ++i)
        data_in[i] = rand() % 256;

    // Install a custom trace function for the encoder and decoder
    kodoc_set_trace_callback(encoder, encoder_trace_callback, NULL);
    kodoc_set_trace_callback(decoder, decoder_trace_callback, NULL);

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

    kodoc_set_mutable_symbols(decoder, data_out, block_size);

    EXPECT_TRUE(kodoc_is_complete(decoder) == 0);

    while (!kodoc_is_complete(decoder))
    {
        // Encode the packet into the payload buffer
        uint32_t payload_used = kodoc_write_payload(encoder, payload);
        EXPECT_TRUE(payload_used <= kodoc_payload_size(encoder));

        // Pass that packet to the decoder
        kodoc_read_payload(decoder, payload);
        // All payloads must be innovative due to the perfect feedback
        EXPECT_TRUE(kodoc_is_partially_complete(decoder) != 0);

        kodoc_write_feedback(decoder, feedback);
        kodoc_read_feedback(encoder, feedback);
    }
    EXPECT_TRUE(kodoc_is_complete(decoder) != 0);

    // Check if we properly decoded the data
    EXPECT_EQ(memcmp(data_in, data_out, block_size), 0);

    // Check that the trace functions were called at least once
    EXPECT_GT(encoder_trace_called, 0U);
    EXPECT_GT(decoder_trace_called, 0U);

    free(data_in);
    free(data_out);
    free(payload);
    free(feedback);

    kodoc_delete_coder(encoder);
    kodoc_delete_coder(decoder);

    kodoc_delete_factory(encoder_factory);
    kodoc_delete_factory(decoder_factory);
}
Beispiel #11
0
int main(int argc, char* argv[])
{
    // Variables needed for the network / socket usage
    int32_t socket_descriptor = 0;
    int32_t return_code = 0;
    int32_t bytes_received = 0;
    socklen_t remote_address_size;
    struct sockaddr_in remote_address;
    struct sockaddr_in local_address;

    // Variables needed for the coding
    uint32_t max_symbols = 32;
    uint32_t max_symbol_size = 160;

    uint32_t symbols = 0;

    int32_t codec = kodoc_on_the_fly;
    int32_t finite_field = kodoc_binary8;

    kodoc_factory_t decoder_factory = 0;
    kodoc_coder_t decoder = 0;

    // The buffer used to receive incoming packets
    uint32_t payload_size = 0;
    uint8_t* payload = 0;

    // Keeps track of which symbols have been decoded
    uint8_t* decoded = (uint8_t*) malloc(sizeof(uint8_t) * max_symbols);

    // Initialize winsock if on Windows
#ifdef _WIN32

    WORD versionWanted = MAKEWORD(1, 1);
    WSADATA wsaData;

    return_code = WSAStartup(versionWanted, &wsaData);

    if (return_code != 0)
    {
        // Tell the user that we could not find a usable
        // Winsock DLL.
        printf("WSAStartup failed with error: %d\n", return_code);
        exit(1);
    }

#endif

    // Initialize global variables
    rx_packets = 0;

    if (argc < 3)
    {
        printf("usage : %s <port> <symbols>\n", argv[0]);
        exit(1);
    }

    // Socket creation
    socket_descriptor = socket(AF_INET, SOCK_DGRAM, 0);
    if (socket_descriptor < 0)
    {
        printf("%s: cannot open socket \n", argv[0]);
        exit(1);
    }

    // Bind local server port
    local_address.sin_family = AF_INET;
    local_address.sin_addr.s_addr = htonl(INADDR_ANY);
    local_address.sin_port = htons(atoi(argv[1]));
    return_code = bind(socket_descriptor, (struct sockaddr*) &local_address,
                       sizeof(local_address));

    if (return_code < 0)
    {
        printf("%s: cannot bind port number %d \n", argv[0], atoi(argv[1]));
        exit(1);
    }

    // Install signal handler
    signal(SIGINT, exit_on_sigint);

    // Initialize the factory with the chosen symbols and symbol size
    symbols = atoi(argv[2]);
    if (symbols > max_symbols)
    {
        printf("%s: number of symbols cannot be higher than %d \n",
               argv[0], max_symbols);
        exit(1);
    }

    // Create the encoder factory
    decoder_factory = kodoc_new_decoder_factory(
        codec, finite_field, max_symbols, max_symbol_size);

    kodoc_factory_set_symbols(decoder_factory, symbols);
    decoder = kodoc_factory_build_coder(decoder_factory);

    // Create the buffer needed for the payload
    payload_size = kodoc_payload_size(decoder);
    payload = (uint8_t*) malloc(payload_size);

    uint32_t block_size = kodoc_block_size(decoder);
    uint8_t* data_out = (uint8_t*) malloc(block_size);
    kodoc_set_mutable_symbols(decoder, data_out, block_size);

    // Zero initialize the decoded array */
    memset(decoded, '\0', sizeof(uint8_t) * max_symbols);

    printf("%s: waiting for data on UDP port %u\n", argv[0], atoi(argv[1]));

    // Receiver loop
    while (!kodoc_is_complete(decoder))
    {
        // Receive message
        remote_address_size = sizeof(remote_address);

        bytes_received = recvfrom(
            socket_descriptor, payload, payload_size, 0,
            (struct sockaddr*) &remote_address, &remote_address_size);

        if (bytes_received < 0)
        {
            printf("%s: recvfrom error %d\n", argv[0], bytes_received);
            fflush(stdout);
            continue;
        }

        // Print received message
        printf("%s: UDP packet from %s:%u : %d\n",
               argv[0],inet_ntoa(remote_address.sin_addr),
               ntohs(remote_address.sin_port), bytes_received);

        ++rx_packets;

        // Packet got through - pass that packet to the decoder
        kodoc_read_payload(decoder, payload);

        if (kodoc_has_partial_decoding_interface(decoder) &&
            kodoc_is_partially_complete(decoder))
        {
            uint32_t i = 0;
            for (; i < kodoc_symbols(decoder); ++i)
            {
                if (!kodoc_is_symbol_uncoded(decoder, i))
                    continue;

                if (!decoded[i])
                {
                    // Update that this symbol now has been decoded,
                    // in a real application we could copy out the symbol
                    // using the kodoc_copy_from_symbol(..) or use the data_out
                    // directly.
                    printf("Symbol %d was decoded\n", i);
                    decoded[i] = 1;
                }
            }
        }
    }

    printf("Data decoded!\n");

    // Cleanup
    free(decoded);
    free(payload);

    kodoc_delete_coder(decoder);
    kodoc_delete_factory(decoder_factory);

    return 0;
}
Beispiel #12
0
int main()
{
    // Seed random number generator to produce different results every time
    srand(time(NULL));

    // Set the number of symbols (i.e. the generation size in RLNC
    // terminology) and the size of a symbol in bytes
    uint32_t max_symbols = 3;
    uint32_t max_symbol_size = 16;

    int32_t codec = kodoc_full_vector;
    int32_t finite_field = kodoc_binary8;

    // In the following we will make an encoder/decoder factory.
    // The factories are used to build actual encoders/decoder
    kodoc_factory_t encoder_factory =
        kodoc_new_encoder_factory(codec, finite_field,
                                  max_symbols, max_symbol_size);

    kodoc_factory_t decoder_factory =
        kodoc_new_decoder_factory(codec, finite_field,
                                  max_symbols, max_symbol_size);

    // If we wanted to build an encoder or decoder with a smaller number of
    // symbols or a different symbol size, then this can be adjusted using the
    // following functions:
    //      kodoc_factory_set_symbols(...)
    //      kodoc_factory_set_symbol_size(...)
    // We cannot exceed the maximum values which was used when building
    // the factory.
    kodoc_coder_t encoder = kodoc_factory_build_coder(encoder_factory);
    kodoc_coder_t decoder = kodoc_factory_build_coder(decoder_factory);

    // Allocate some storage for a "payload" the payload is what we would
    // eventually send over a network
    uint32_t payload_size = kodoc_payload_size(encoder);
    uint8_t* payload = (uint8_t*) malloc(payload_size);

    // Allocate some data to encode. In this case we make a buffer
    // with the same size as the encoder's block size (the max.
    // amount a single encoder can encode)
    uint32_t block_size = kodoc_block_size(encoder);
    uint8_t* data_in = (uint8_t*) malloc(block_size);

    // Just for fun - fill the data with random data
    uint32_t i = 0;
    for (; i < block_size; ++i)
    {
        data_in[i] = rand() % 256;
    }

    // Install the stdout trace function for the encoder (everything will
    // be printed to stdout without filtering)
    kodoc_set_trace_stdout(encoder);
    // Set a custom zone prefix for the encoder (this helps to differentiate
    // the trace output of the encoder and the decoder)
    kodoc_set_zone_prefix(encoder, "Encoder");

    // Install a custom trace function for the decoder (we can process and
    // filter the data in our trace callback)
    kodoc_set_trace_callback(decoder, trace_callback, NULL);
    // Set a custom zone prefix for the decoder
    kodoc_set_zone_prefix(decoder, "Decoder");

    kodoc_set_const_symbols(encoder, data_in, block_size);

    uint8_t* data_out = (uint8_t*) malloc(block_size);
    kodoc_set_mutable_symbols(decoder, data_out, block_size);

    while (!kodoc_is_complete(decoder))
    {
        kodoc_write_payload(encoder, payload);

        if ((rand() % 2) == 0)
        {
            continue;
        }

        kodoc_read_payload(decoder, payload);
    }

    if (memcmp(data_in, data_out, block_size) == 0)
    {
        printf("Data decoded correctly\n");
    }
    else
    {
        printf("Unexpected failure to decode, please file a bug report :)\n");
    }

    free(data_in);
    free(data_out);
    free(payload);

    kodoc_delete_coder(encoder);
    kodoc_delete_coder(decoder);

    kodoc_delete_factory(encoder_factory);
    kodoc_delete_factory(decoder_factory);

    return 0;
}
Beispiel #13
0
int main()
{
    // Seed the random number generator to produce different data every time
    srand(time(NULL));

    // Set the number of symbols and the symbol size
    uint32_t max_symbols = 10;
    uint32_t max_symbol_size = 100;

    // Here we select the codec we wish to use
    int32_t codec = kodoc_perpetual;

    // Here we select the finite field to use.
    // kodoc_binary8 is common choice for the perpetual codec
    int32_t finite_field = kodoc_binary8;

    // First, we create an encoder & decoder factory.
    // The factories are used to build actual encoders/decoders
    kodoc_factory_t encoder_factory =
        kodoc_new_encoder_factory(codec, finite_field,
                                  max_symbols, max_symbol_size);

    kodoc_factory_t decoder_factory =
        kodoc_new_decoder_factory(codec, finite_field,
                                  max_symbols, max_symbol_size);

    kodoc_coder_t encoder = kodoc_factory_build_coder(encoder_factory);
    kodoc_coder_t decoder = kodoc_factory_build_coder(decoder_factory);

    // The perpetual encoder supports three operation modes:
    //
    // 1) Random pivot mode (default):
    //    The pivot element is drawn at random
    // 2) Pseudo-systematic
    //    Pivot elements are generated with indices 0,1,2,...,n
    //    After that, the pivots are drawn at random.
    // 3) Pre-charging
    //    For the first "width" symbols, the pivot index is 0. After that,
    ///   the pseudo-systematic mode is used. Finally, pivots are drawn at
    ///   random. The resulting indices: 0(width times),1,2,...,n
    //
    // The operation mode is set with the following API.
    // Note that if both pre-charging and pseudo-systematic is enabled,
    // pre-charging takes precedence.

    // Enable the pseudo-systematic operation mode - faster
    kodoc_set_pseudo_systematic(encoder, 1);

    // Enable the pre-charing operation mode - even faster
    //kodoc_set_pre_charging(encoder, 1);

    printf("Pseudo-systematic flag: %d\n", kodoc_pseudo_systematic(encoder));
    printf("Pre-charging flag: %d\n", kodoc_pre_charging(encoder));

    // The width of the perpetual code can be set either as a number of symbols
    // using kodoc_set_width(), or as a ratio of the number of symbols using
    // kodoc_set_width_ratio().
    //
    // The default width is set to 10% of the number of symbols.
    printf("The width ratio defaults to: %0.2f"
           " (therefore the calculated width is %d)\n",
           kodoc_width_ratio(encoder), kodoc_width(encoder));

    /// When modifying the width, the width ratio will change as well
    kodoc_set_width(encoder, 4);
    printf("The width was set to: %d "
           " (therefore the calculated width ratio is %0.2f)\n",
           kodoc_width(encoder), kodoc_width_ratio(encoder));

    /// When modifying the width ratio, the width will change as well
    kodoc_set_width_ratio(encoder, 0.2);
    printf("The width ratio was set to: %0.2f"
           " (therefore the calculated width is %d)\n",
           kodoc_width_ratio(encoder), kodoc_width(encoder));

    // Allocate some storage for a "payload". The payload is what we would
    // eventually send over a network.
    uint32_t bytes_used;
    uint32_t payload_size = kodoc_payload_size(encoder);
    uint8_t* payload = (uint8_t*) malloc(payload_size);

    // Allocate input and output data buffers
    uint32_t block_size = kodoc_block_size(encoder);
    uint8_t* data_in = (uint8_t*) malloc(block_size);
    uint8_t* data_out = (uint8_t*) malloc(block_size);

    // Fill the input buffer with random data
    uint32_t i = 0;
    for (; i < block_size; ++i)
        data_in[i] = rand() % 256;

    // Assign the data buffers to the encoder and decoder
    kodoc_set_const_symbols(encoder, data_in, block_size);
    kodoc_set_mutable_symbols(decoder, data_out, block_size);

    // Install a custom trace function for the decoder
    kodoc_set_trace_callback(decoder, trace_callback, NULL);

    uint32_t lost_payloads = 0;
    uint32_t received_payloads = 0;
    while (!kodoc_is_complete(decoder))
    {
        // The encoder will use a certain amount of bytes of the payload buffer
        bytes_used = kodoc_write_payload(encoder, payload);
        printf("Payload generated by encoder, bytes used = %d\n", bytes_used);

        // Simulate a channel with a 50% loss rate
        if (rand() % 2)
        {
            lost_payloads++;
            printf("Symbol lost on channel\n\n");
            continue;
        }

        // Pass the generated packet to the decoder
        received_payloads++;
        kodoc_read_payload(decoder, payload);
        printf("Payload processed by decoder, current rank = %d\n\n",
               kodoc_rank(decoder));
    }

    printf("Number of lost payloads: %d\n", lost_payloads);
    printf("Number of received payloads: %d\n", received_payloads);

    // Check that we properly decoded the data
    if (memcmp(data_in, data_out, block_size) == 0)
    {
        printf("Data decoded correctly\n");
    }
    else
    {
        printf("Unexpected failure to decode, please file a bug report :)\n");
    }

    // Free the allocated buffers and the kodo objects
    free(data_in);
    free(data_out);
    free(payload);

    kodoc_delete_coder(encoder);
    kodoc_delete_coder(decoder);

    kodoc_delete_factory(encoder_factory);
    kodoc_delete_factory(decoder_factory);

    return 0;
}
Beispiel #14
0
int main()
{
    // Seed the random number generator to produce different data every time
    srand(time(NULL));

    // Set the number of symbols and the symbol size
    uint32_t max_symbols = 10;
    uint32_t max_symbol_size = 100;

    // Here we select the codec we wish to use
    int32_t codec = kodoc_sparse_seed;

    // Here we select the finite field to use.
    // For the sparse seed codec, we can choose kodoc_binary, kodoc_binary4 or
    // kodoc_binary8 (kodoc_binary is recommended for high performance)
    int32_t finite_field = kodoc_binary8;

    kodoc_factory_t encoder_factory =
        kodoc_new_encoder_factory(codec, finite_field,
                                 max_symbols, max_symbol_size);

    kodoc_factory_t decoder_factory =
        kodoc_new_decoder_factory(codec, finite_field,
                                 max_symbols, max_symbol_size);

    kodoc_coder_t encoder = kodoc_factory_build_coder(encoder_factory);
    kodoc_coder_t decoder = kodoc_factory_build_coder(decoder_factory);

    // The coding vector density on the encoder is set with
    // kodoc_set_density().
    // Note: the density can be adjusted at any time. This feature can be used
    // to adapt to changing network conditions.
    printf("The density defaults to: %0.2f\n", kodoc_density(encoder));
    kodoc_set_density(encoder, 0.4);
    printf("The density was set to: %0.2f\n", kodoc_density(encoder));
    // A low density setting can lead to a large number of redundant symbols.
    // In practice, the value should be tuned to the specific scenario.

    // Allocate some storage for a "payload". The payload is what we would
    // eventually send over a network.
    uint32_t bytes_used;
    uint32_t payload_size = kodoc_payload_size(encoder);
    uint8_t* payload = (uint8_t*) malloc(payload_size);

    // Allocate input and output data buffers
    uint32_t block_size = kodoc_block_size(encoder);
    uint8_t* data_in = (uint8_t*) malloc(block_size);
    uint8_t* data_out = (uint8_t*) malloc(block_size);

    // Fill the input buffer with random data
    uint32_t i = 0;
    for(; i < block_size; ++i)
        data_in[i] = rand() % 256;

    // Assign the data buffers to the encoder and decoder
    kodoc_set_const_symbols(encoder, data_in, block_size);
    kodoc_set_mutable_symbols(decoder, data_out, block_size);

    // Install a custom trace function for the decoder
    kodoc_set_trace_callback(decoder, trace_callback, NULL);

    uint32_t lost_payloads = 0;
    uint32_t received_payloads = 0;
    while (!kodoc_is_complete(decoder))
    {
        // The encoder will use a certain amount of bytes of the payload buffer
        bytes_used = kodoc_write_payload(encoder, payload);
        printf("Payload generated by encoder, bytes used = %d\n", bytes_used);

        // Simulate a channel with a 50% loss rate
        if (rand() % 2)
        {
            lost_payloads++;
            printf("Symbol lost on channel\n\n");
            continue;
        }

        // Pass the generated packet to the decoder
        received_payloads++;
        kodoc_read_payload(decoder, payload);
        printf("Payload processed by decoder, current rank = %d\n\n",
               kodoc_rank(decoder));
    }

    printf("Number of lost payloads: %d\n", lost_payloads);
    printf("Number of received payloads: %d\n", received_payloads);

    // Check that we properly decoded the data
    if (memcmp(data_in, data_out, block_size) == 0)
    {
        printf("Data decoded correctly\n");
    }
    else
    {
        printf("Unexpected failure to decode, please file a bug report :)\n");
    }

    // Free the allocated buffers and the kodo objects
    free(data_in);
    free(data_out);
    free(payload);

    kodoc_delete_coder(encoder);
    kodoc_delete_coder(decoder);

    kodoc_delete_factory(encoder_factory);
    kodoc_delete_factory(decoder_factory);

    return 0;
}
void test_on_the_fly(uint32_t max_symbols, uint32_t max_symbol_size,
                     int32_t finite_field)
{
    kodoc_factory_t encoder_factory = kodoc_new_encoder_factory(
                                          kodoc_on_the_fly, finite_field, max_symbols, max_symbol_size);

    kodoc_factory_t decoder_factory = kodoc_new_decoder_factory(
                                          kodoc_on_the_fly, finite_field, max_symbols, max_symbol_size);

    kodoc_coder_t encoder = kodoc_factory_build_coder(encoder_factory);
    kodoc_coder_t decoder = kodoc_factory_build_coder(decoder_factory);

    uint32_t symbol_size = kodoc_symbol_size(encoder);
    uint32_t payload_size = kodoc_payload_size(encoder);
    uint8_t* payload = (uint8_t*) malloc(payload_size);

    uint32_t block_size = kodoc_block_size(encoder);
    uint8_t* data_in = (uint8_t*) malloc(block_size);
    uint8_t* data_out = (uint8_t*) malloc(block_size);

    for (uint32_t i = 0; i < block_size; ++i)
        data_in[i] = rand() % 256;

    kodoc_set_mutable_symbols(decoder, data_out, block_size);

    EXPECT_TRUE(kodoc_is_complete(decoder) == 0);

    while (!kodoc_is_complete(decoder))
    {
        EXPECT_GE(kodoc_rank(encoder), kodoc_rank(decoder));

        // The rank of an encoder indicates how many symbols have been added,
        // i.e. how many symbols are available for encoding
        uint32_t encoder_rank = kodoc_rank(encoder);

        // Randomly choose to add a new symbol (with 50% probability)
        // if the encoder rank is less than the maximum number of symbols
        if ((rand() % 2) && encoder_rank < kodoc_symbols(encoder))
        {
            // Calculate the offset to the next symbol to insert
            uint8_t* symbol = data_in + (encoder_rank * symbol_size);
            kodoc_set_const_symbol(encoder, encoder_rank, symbol, symbol_size);
        }
        // Generate an encoded packet
        kodoc_write_payload(encoder, payload);

        // Simulate that 50% of the packets are lost
        if (rand() % 2) continue;

        // Packet got through - pass that packet to the decoder
        kodoc_read_payload(decoder, payload);

        // Check the decoder rank and symbol counters
        EXPECT_GE(kodoc_rank(encoder), kodoc_rank(decoder));
        EXPECT_GE(kodoc_rank(decoder), kodoc_symbols_uncoded(decoder));
        EXPECT_GE(kodoc_rank(decoder), kodoc_symbols_partially_decoded(decoder));
        EXPECT_EQ(kodoc_symbols(decoder) - kodoc_rank(decoder),
                  kodoc_symbols_missing(decoder));

        // Check the decoder whether it is partially complete
        // The decoder has to support the partial decoding tracker
        if (kodoc_has_partial_decoding_interface(decoder) &&
                kodoc_is_partially_complete(decoder))
        {
            for (uint32_t i = 0; i < kodoc_symbols(decoder); ++i)
            {
                // Go through all symbols that are already decoded
                if (kodoc_is_symbol_uncoded(decoder, i))
                {
                    // All uncoded symbols must have a pivot
                    EXPECT_TRUE(kodoc_is_symbol_pivot(decoder, i) != 0);
                    // The uncoded symbols cannot be missing
                    EXPECT_TRUE(kodoc_is_symbol_missing(decoder, i) == 0);
                    // The uncoded symbols cannot be partially decoded
                    EXPECT_TRUE(
                        kodoc_is_symbol_partially_decoded(decoder, i) == 0);

                    uint8_t* original = data_in + i * symbol_size;
                    uint8_t* target = data_out + i * symbol_size;

                    // verify the decoded symbol against the original data
                    EXPECT_EQ(memcmp(original, target, symbol_size), 0);
                }
            }
        }
    }

    EXPECT_EQ(memcmp(data_in, data_out, block_size), 0);

    free(data_in);
    free(data_out);
    free(payload);

    kodoc_delete_coder(encoder);
    kodoc_delete_coder(decoder);

    kodoc_delete_factory(encoder_factory);
    kodoc_delete_factory(decoder_factory);
}