boost::shared_ptr<basic_source<Encoder> > build_source(const std::string &id) { auto encoder = m_encoder_factory.build(); encoder->set_symbols(sak::storage(m_data)); auto source = boost::make_shared< basic_source<Encoder> >(id, encoder); return source; }
TEST(TestReedSolomonCodes, test_encode_decode) { { kodo::rs_encoder<fifi::binary8>::factory encoder_factory(255, 1600); kodo::rs_decoder<fifi::binary8>::factory decoder_factory(255, 1600); uint32_t symbols = rand_symbols(255); uint32_t symbol_size = rand_symbol_size(); encoder_factory.set_symbols(symbols); encoder_factory.set_symbol_size(symbol_size); decoder_factory.set_symbols(symbols); decoder_factory.set_symbol_size(symbol_size); auto encoder = encoder_factory.build(); auto decoder = decoder_factory.build(); // Encode/decode operations EXPECT_TRUE(encoder->payload_size() == decoder->payload_size()); std::vector<uint8_t> payload(encoder->payload_size()); std::vector<uint8_t> data_in = random_vector(encoder->block_size()); encoder->set_symbols(sak::storage(data_in)); uint32_t symbol_count = 0; while( !decoder->is_complete() ) { encoder->encode( &payload[0] ); decoder->decode( &payload[0] ); ++symbol_count; } // A reed solomon code should be able to decode // with exactly k symbols EXPECT_EQ(symbol_count, symbols); std::vector<uint8_t> data_out(decoder->block_size(), '\0'); decoder->copy_symbols(sak::storage(data_out)); EXPECT_TRUE(std::equal(data_out.begin(), data_out.end(), data_in.begin())); } }
int main() { // Set the number of symbols (i.e. the generation size in RLNC // terminology) and the size of a symbol in bytes uint32_t symbols = 42; uint32_t symbol_size = 100; typedef kodo::full_rlnc_encoder<fifi::binary8> rlnc_encoder; typedef kodo::full_rlnc_decoder<fifi::binary8> rlnc_decoder; // In the following we will make an encoder/decoder factory. // The factories are used to build actual encoders/decoders rlnc_encoder::factory encoder_factory(symbols, symbol_size); auto encoder = encoder_factory.build(); rlnc_decoder::factory decoder_factory(symbols, symbol_size); auto decoder = decoder_factory.build(); std::vector<uint8_t> payload(encoder->payload_size()); std::vector<uint8_t> data_in(encoder->block_size()); // Just for fun - fill the data with random data for(auto &e: data_in) e = rand() % 256; // Assign the data buffer to the encoder so that we may start // to produce encoded symbols from it encoder->set_symbols(sak::storage(data_in)); while( !decoder->is_complete() ) { // Encode a packet into the payload buffer encoder->encode( &payload[0] ); // Pass that packet to the decoder decoder->decode( &payload[0] ); } }
inline void test_basic_api(uint32_t symbols, uint32_t symbol_size) { // Common setting typename Encoder::factory encoder_factory(symbols, symbol_size); auto encoder = encoder_factory.build(); typename Decoder::factory decoder_factory(symbols, symbol_size); auto decoder = decoder_factory.build(); EXPECT_TRUE(symbols == encoder_factory.max_symbols()); EXPECT_TRUE(symbol_size == encoder_factory.max_symbol_size()); EXPECT_TRUE(symbols == encoder->symbols()); EXPECT_TRUE(symbol_size == encoder->symbol_size()); EXPECT_TRUE(symbols == decoder_factory.max_symbols()); EXPECT_TRUE(symbol_size == decoder_factory.max_symbol_size()); EXPECT_TRUE(symbols == decoder->symbols()); EXPECT_TRUE(symbol_size == decoder->symbol_size()); EXPECT_TRUE(encoder->symbol_length() > 0); EXPECT_TRUE(decoder->symbol_length() > 0); EXPECT_TRUE(encoder->block_size() == symbols * symbol_size); EXPECT_TRUE(decoder->block_size() == symbols * symbol_size); EXPECT_TRUE(encoder_factory.max_payload_size() >= encoder->payload_size()); EXPECT_TRUE(decoder_factory.max_payload_size() >= decoder->payload_size()); EXPECT_EQ(encoder_factory.max_payload_size(), decoder_factory.max_payload_size()); // Encode/decode operations EXPECT_EQ(encoder->payload_size(), decoder->payload_size()); std::vector<uint8_t> payload(encoder->payload_size()); std::vector<uint8_t> data_in = random_vector(encoder->block_size()); std::vector<uint8_t> data_in_copy(data_in); sak::mutable_storage storage_in = sak::storage(data_in); sak::mutable_storage storage_in_copy = sak::storage(data_in_copy); EXPECT_TRUE(sak::equal(storage_in, storage_in_copy)); // Only used for prime fields, lets reconsider how we implement // this less intrusive uint32_t prefix = 0; if(fifi::is_prime2325<typename Encoder::field_type>::value) { // This field only works for multiple of uint32_t assert((encoder->block_size() % 4) == 0); uint32_t block_length = encoder->block_size() / 4; fifi::prime2325_binary_search search(block_length); prefix = search.find_prefix(storage_in_copy); // Apply the negated prefix fifi::apply_prefix(storage_in_copy, ~prefix); } encoder->set_symbols(storage_in_copy); // Set the encoder non-systematic if(kodo::is_systematic_encoder(encoder)) kodo::set_systematic_off(encoder); while( !decoder->is_complete() ) { uint32_t payload_used = encoder->encode( &payload[0] ); EXPECT_TRUE(payload_used <= encoder->payload_size()); decoder->decode( &payload[0] ); } std::vector<uint8_t> data_out(decoder->block_size(), '\0'); decoder->copy_symbols(sak::storage(data_out)); if(fifi::is_prime2325<typename Encoder::field_type>::value) { // Now we have to apply the negated prefix to the decoded data fifi::apply_prefix(sak::storage(data_out), ~prefix); } EXPECT_TRUE(std::equal(data_out.begin(), data_out.end(), data_in.begin())); }
/// @example use_cached_symbol_decoder.cpp /// /// This example shows how to use the cached symbol decoder to "extract" /// the symbol coding coefficients and the encoded symbol data from an /// incoming symbol. int main() { // The finite field we will use in the example. You can try // with other fields by specifying e.g. fifi::binary8 for the // extension field 2^8 typedef fifi::binary finite_field; // Set the number of symbols (i.e. the generation size in RLNC // terminology) and the size of a symbol in bytes uint32_t symbols = 8; uint32_t symbol_size = 160; // Typdefs for the encoder/decoder type we wish to use typedef kodo::full_rlnc_encoder<finite_field> rlnc_encoder; typedef kodo::full_rlnc_decoder<finite_field> rlnc_decoder; typedef kodo::symbol_info_decoder<finite_field> rlnc_info_decoder; // In the following we will make an encoder/decoder factory. // The factories are used to build actual encoders/decoders. // Each stack we use have their own factories. rlnc_encoder::factory encoder_factory(symbols, symbol_size); auto encoder = encoder_factory.build(); rlnc_decoder::factory decoder_factory(symbols, symbol_size); auto decoder = decoder_factory.build(); rlnc_info_decoder::factory info_decoder_factory(symbols, symbol_size); auto info_decoder = info_decoder_factory.build(); // Allocate some storage for a "payload" the payload is what we would // eventually send over a network std::vector<uint8_t> payload(encoder->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) std::vector<uint8_t> data_in(encoder->block_size()); // Just for fun - fill the data with random data for(auto &e: data_in) e = rand() % 256; // Assign the data buffer to the encoder so that we may start // to produce encoded symbols from it encoder->set_symbols(sak::storage(data_in)); while( !decoder->is_complete()) { // Encode a packet into the payload buffer encoder->encode( &payload[0] ); // Here we "simulate" a packet loss of approximately 50% // by dropping half of the encoded packets. // When running this example you will notice that the initial // symbols are received systematically (i.e. uncoded). After // sending all symbols once uncoded, the encoder will switch // to full coding, in which case you will see the full encoding // vectors being sent and received. if((rand() % 2) == 0) continue; // Pass the encoded packet to the info decoder. After this // information about the coded symbol can be fetched using the // cached_symbol_decoder API info_decoder->decode( &payload[0] ); if(!info_decoder->cached_symbol_coded()) { // The symbol was uncoded so we may ask the cache which of the // original symbols we have received. std::cout << "Symbol was uncoded, index = " << info_decoder->cached_symbol_index() << std::endl; // Now we pass the data directly into our actual decoder. This is // done using the "Codec API" directly, and not through the "Payload // API" as we would typically do. decoder->decode_symbol( info_decoder->cached_symbol_data(), info_decoder->cached_symbol_index()); } else { // The symbol was coded so we may ask the cache to return // the coding coefficients used to create the encoded symbol. std::cout << "Symbol was coded, encoding vector = "; const uint8_t* c = info_decoder->cached_symbol_coefficients(); // We loop through the coefficient buffer and print the coefficients for(uint32_t i = 0; i < info_decoder->symbols(); ++i) { std::cout << (uint32_t) fifi::get_value<finite_field>(c, i) << " "; } std::cout << std::endl; // Pass that packet to the decoder, as with the uncoded symbols // above we pass it directly to the "Codec API" decoder->decode_symbol(info_decoder->cached_symbol_data(), info_decoder->cached_symbol_coefficients()); } } // The decoder is complete, now copy the symbols from the decoder std::vector<uint8_t> data_out(decoder->block_size()); decoder->copy_symbols(sak::storage(data_out)); // Check we properly decoded the data if (std::equal(data_out.begin(), data_out.end(), data_in.begin())) { std::cout << "Data decoded correctly" << std::endl; } else { std::cout << "Unexpected failure to decode " << "please file a bug report :)" << std::endl; } }
inline void invoke_reuse_incomplete(uint32_t symbols, uint32_t symbol_size) { bool do_complete; typename Encoder::factory encoder_factory(symbols, symbol_size); typename Decoder::factory decoder_factory(symbols, symbol_size); // Use factory a lot of times for (uint32_t i = 0; i < 100; ++i) { // Build coders auto encoder = encoder_factory.build(); auto decoder = decoder_factory.build(); // Prepare buffers std::vector<uint8_t> payload(encoder->payload_size()); std::vector<uint8_t> data_in(encoder->block_size()); // Fill with random data for (auto &e: data_in) e = rand() % 256; // Put data in encoder encoder->set_symbols(sak::storage(data_in)); if (rand() % 100 > 90) { do_complete = false; } else { do_complete = true; } // Start encoding/decoding while (!decoder->is_complete()) { encoder->encode(&payload[0]); // Loose a packet with probability if (rand() % 100 > 90) continue; decoder->decode(&payload[0]); // Stop decoding after a while with probability if (!do_complete && decoder->rank() == symbols - 2) break; } // Check if completed decoders are correct if (decoder->is_complete()) { std::vector<uint8_t> data_out(decoder->block_size()); decoder->copy_symbols(sak::storage(data_out)); ASSERT_TRUE(sak::equal(sak::storage(data_out), sak::storage(data_in))); } } }
inline void invoke_recoding(recoding_parameters param) { // Common setting typename Encoder::factory encoder_factory( param.m_max_symbols, param.m_max_symbol_size); encoder_factory.set_symbols(param.m_symbols); encoder_factory.set_symbol_size(param.m_symbol_size); auto encoder = encoder_factory.build(); typename Decoder::factory decoder_factory( param.m_max_symbols, param.m_max_symbol_size); decoder_factory.set_symbols(param.m_symbols); decoder_factory.set_symbol_size(param.m_symbol_size); auto decoder_one = decoder_factory.build(); auto decoder_two = decoder_factory.build(); // If tested with a shallow decoder we have to remember to set the // buffers to use for the decoding std::vector<uint8_t> buffer_decoder_one(decoder_one->block_size(), '\0'); std::vector<uint8_t> buffer_decoder_two(decoder_two->block_size(), '\0'); if(kodo::has_shallow_symbol_storage<Decoder>::value) { decoder_one->set_symbols(sak::storage(buffer_decoder_one)); decoder_two->set_symbols(sak::storage(buffer_decoder_two)); } EXPECT_EQ(encoder->payload_size(), decoder_one->payload_size()); EXPECT_EQ(encoder->payload_size(), decoder_two->payload_size()); std::vector<uint8_t> payload(encoder->payload_size()); std::vector<uint8_t> data_in = random_vector(encoder->block_size()); encoder->set_symbols(sak::storage(data_in)); // Set the encoder non-systematic if(kodo::has_systematic_encoder<Encoder>::value) kodo::set_systematic_off(encoder); while( !decoder_two->is_complete() ) { uint32_t encode_size = encoder->encode( &payload[0] ); EXPECT_TRUE(encode_size <= payload.size()); EXPECT_TRUE(encode_size > 0); decoder_one->decode( &payload[0] ); uint32_t recode_size = decoder_one->recode( &payload[0] ); EXPECT_TRUE(recode_size <= payload.size()); EXPECT_TRUE(recode_size > 0); decoder_two->decode( &payload[0] ); } std::vector<uint8_t> data_out_one(decoder_one->block_size(), '\0'); std::vector<uint8_t> data_out_two(decoder_two->block_size(), '\0'); decoder_one->copy_symbols(sak::storage(data_out_one)); decoder_two->copy_symbols(sak::storage(data_out_two)); EXPECT_TRUE(std::equal(data_out_one.begin(), data_out_one.end(), data_in.begin())); EXPECT_TRUE(std::equal(data_out_two.begin(), data_out_two.end(), data_in.begin())); }