Function decode

test/rfc_test.cpp:321–427

}

uint64_t decode (uint32_t mysize, std::mt19937_64 &rnd, float drop_prob,
															uint8_t overhead)
{
	// returns average number of microseconds for encoding and decoding
	Timer t;
	const uint16_t symbol_size = 1280;
//    const uint16_t subsymbol = 1280 / 4; // small interleaving
	const uint16_t subsymbol = 1280; // small interleaving
	const size_t max_sub_block = std::numeric_limits<uint32_t>::max();
	std::vector<uint8_t> myvec;

	// initialize vector
	std::uniform_int_distribution<uint8_t> distr (0,
										std::numeric_limits<uint8_t>::max());
	myvec.reserve (mysize * symbol_size);
	for (uint32_t i = 0; i < mysize * symbol_size; ++i)
		myvec.push_back (distr(rnd));

	std::vector<std::pair<uint32_t, std::vector<uint8_t>>> encoded;

	auto enc_it = myvec.begin();
	RaptorQ::Encoder<std::vector<uint8_t>::iterator,
									std::vector<uint8_t>::iterator> enc (
					enc_it, myvec.end(), subsymbol, symbol_size, max_sub_block);

	t.start();
	enc.precompute(1, false);
	uint64_t micro1 = t.stop();

	if (micro1 == 0)
		return 0;

	if (drop_prob > static_cast<float>(100.0))
		drop_prob = 90.0;	// this is still too high probably.
	std::uniform_real_distribution<float> drop (0.0, 100.0);

	int32_t repair = overhead;

	for (auto block : enc) {
		for (auto sym_it = block.begin_source(); sym_it != block.end_source();
																	++sym_it) {
			float dropped = drop (rnd);
			if (dropped <= drop_prob) {
				++repair;
				continue;
			}
			std::vector<uint8_t> source_sym (symbol_size, 0);
			auto it = source_sym.begin();
			(*sym_it) (it, source_sym.end());
			encoded.emplace_back ((*sym_it).id(), std::move(source_sym));
		}
		auto sym_it = block.begin_repair();
		for (; repair >= 0 && sym_it != block.end_repair (block.max_repair());
																	++sym_it) {
			// repair symbols can be lost, too
			float dropped = drop (rnd);
			if (dropped <= drop_prob) {
				continue;