mirror of
https://github.com/SatDump/SatDump
synced 2026-08-13 17:47:30 -04:00
112 lines
No EOL
4.2 KiB
C++
112 lines
No EOL
4.2 KiB
C++
/**********************************************************************
|
|
* This file is used for testing random stuff without running the
|
|
* whole of SatDump, which comes in handy for debugging individual
|
|
* elements before putting them all together in modules...
|
|
*
|
|
* If you are an user, ignore this file which will not be built by
|
|
* default, and you're a developper in need of doing stuff here...
|
|
* Go ahead!
|
|
*
|
|
* Don't judge the code you might see in there! :)
|
|
**********************************************************************/
|
|
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include "modules/common/sathelper/packetfixer.h"
|
|
#include "modules/viterbi/cc_decoder_impl.h"
|
|
#include "modules/viterbi/cc_encoder_impl.h"
|
|
#include "modules/viterbi/depuncture_bb_impl.h"
|
|
#include "modules/common/repack_bits_byte.h"
|
|
|
|
void char_array_to_uchar(const char *in, unsigned char *out, int nsamples)
|
|
{
|
|
for (int i = 0; i < nsamples; i++)
|
|
{
|
|
long int r = (long int)rint((float)in[i] * 127.0);
|
|
if (r < 0)
|
|
r = 0;
|
|
else if (r > 255)
|
|
r = 255;
|
|
out[i] = r;
|
|
}
|
|
}
|
|
|
|
#define BUFFER_SIZE 8192
|
|
#define TEST_SIZE 1024
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
uint8_t input_buffer[BUFFER_SIZE];
|
|
uint8_t input_buffer_converted[BUFFER_SIZE];
|
|
uint8_t reorg_buffer[BUFFER_SIZE];
|
|
uint8_t depunc_buffer[BUFFER_SIZE * 2];
|
|
uint8_t encode_buffer[BUFFER_SIZE * 2];
|
|
uint8_t output_buffer[BUFFER_SIZE * 2];
|
|
uint8_t byte_buffer[BUFFER_SIZE * 2];
|
|
|
|
gr::fec::depuncture_bb_impl depunc(3, 110);
|
|
gr::fec::code::cc_decoder_impl cc_decoder(8192, 7, 2, {79, 109}, 0, -1, CC_STREAMING, false);
|
|
RepackBitsByte repacker;
|
|
|
|
/*gr::fec::depuncture_bb_impl depunc_ber(3, 110);
|
|
gr::fec::code::cc_decoder_impl cc_decoder_ber((TEST_SIZE * 1.5f) / 2.0f, 7, 2, {79, 109}, 0, -1, CC_STREAMING, false);
|
|
gr::fec::code::cc_encoder_impl cc_encoder_ber((TEST_SIZE * 1.5f) / 2.0f, 7, 2, {79, 109}, 0, CC_STREAMING, false);
|
|
uint8_t ber_in_buffer[TEST_SIZE];
|
|
uint8_t ber_converted_buffer[TEST_SIZE];
|
|
uint8_t ber_reorg_buffer[TEST_SIZE];
|
|
uint8_t ber_depunc_buffer[TEST_SIZE * 2];
|
|
uint8_t ber_decode_buffer[TEST_SIZE];
|
|
uint8_t ber_encode_buffer[TEST_SIZE * 2];*/
|
|
|
|
std::ifstream data_in("test.bin2", std::ios::binary);
|
|
std::ofstream data_out("test.b2", std::ios::binary);
|
|
|
|
while (!data_in.eof())
|
|
{
|
|
data_in.read((char *)input_buffer, BUFFER_SIZE);
|
|
|
|
/*{
|
|
std::memcpy(ber_in_buffer, input_buffer, TEST_SIZE);
|
|
char_array_to_uchar((char *)ber_in_buffer, ber_converted_buffer, TEST_SIZE);
|
|
|
|
for (int i = 0; i < TEST_SIZE / 4; i++)
|
|
{
|
|
ber_reorg_buffer[i * 4 + 0] = ber_converted_buffer[i * 4 + 0];
|
|
ber_reorg_buffer[i * 4 + 1] = ber_converted_buffer[i * 4 + 1];
|
|
ber_reorg_buffer[i * 4 + 2] = ber_converted_buffer[i * 4 + 3];
|
|
ber_reorg_buffer[i * 4 + 3] = ber_converted_buffer[i * 4 + 2];
|
|
}
|
|
|
|
depunc.general_work(TEST_SIZE, ber_reorg_buffer, ber_depunc_buffer);
|
|
|
|
cc_decoder_ber.generic_work(ber_depunc_buffer, ber_decode_buffer);
|
|
cc_encoder_ber.generic_work(ber_decode_buffer, ber_encode_buffer);
|
|
|
|
float errors = 0;
|
|
for (int i = 0; i < TEST_SIZE * 1.5f; i++)
|
|
errors += (ber_depunc_buffer[i] > 0) != (ber_encode_buffer[i] > 0);
|
|
|
|
std::cout << (errors / ((float)TEST_SIZE * 1.5f * 2.0f)) * 2.0f << '\n';
|
|
}*/
|
|
|
|
char_array_to_uchar((char *)input_buffer, input_buffer_converted, BUFFER_SIZE);
|
|
|
|
for (int i = 0; i < BUFFER_SIZE / 4; i++)
|
|
{
|
|
reorg_buffer[i * 4 + 0] = input_buffer_converted[i * 4 + 0];
|
|
reorg_buffer[i * 4 + 1] = input_buffer_converted[i * 4 + 1];
|
|
reorg_buffer[i * 4 + 2] = input_buffer_converted[i * 4 + 3];
|
|
reorg_buffer[i * 4 + 3] = input_buffer_converted[i * 4 + 2];
|
|
}
|
|
|
|
depunc.general_work(BUFFER_SIZE, reorg_buffer, depunc_buffer);
|
|
|
|
int out = cc_decoder.continuous_work(depunc_buffer, BUFFER_SIZE * 1.5, output_buffer);
|
|
|
|
// std::cout << decoded << std::endl;
|
|
|
|
int bytes_out = repacker.work(output_buffer, out, byte_buffer);
|
|
|
|
data_out.write((char *)byte_buffer, bytes_out);
|
|
}
|
|
} |