rs Struct Reference

#include <rs.h>

Inheritance diagram for rs:

Collaboration diagram for rs:

Public Member Functions
	rs (const char *cfg, bool is_audio)
	rs (unsigned int k, unsigned int n)
virtual	~rs ()
bool	decode (char *in, int in_len, char **out, int *len, const std::map< int, int > &) override
virtual audio_frame2	encode (audio_frame2 const &) override
std::shared_ptr< video_frame >	encode (std::shared_ptr< video_frame > frame) override
Public Member Functions inherited from fec
virtual	~fec ()

Private Member Functions
uint32_t	get_buf_len (const char *buf, std::map< int, int > const &c_m)
int	get_ss (int hdr_len, int len)

Private Attributes
unsigned int	m_k
unsigned int	m_n
void *	state = nullptr

Additional Inherited Members
Static Public Member Functions inherited from fec
static fec *	create_from_config (const char *str, bool is_audio) noexcept
static fec *	create_from_desc (struct fec_desc) noexcept
static enum fec_type	fec_type_from_pt (int pt) throw ()
static int	pt_from_fec_type (enum tx_media_type media_type, enum fec_type fec_type, bool encrypted) throw ()

Detailed Description

Definition at line 49 of file rs.h.

Constructor & Destructor Documentation

rs() [1/2]

rs::rs	(	unsigned int	k,
		unsigned int	n )

Constructs RS state. Since this constructor is currently used only for the decoder, it allows creation of dummy state even if zfec was not compiled in.

Definition at line 82 of file rs.cpp.

        : m_k(k), m_n(n)
{
        assert (k <= MAX_K);
        assert (n <= MAX_N);
        assert (m_k <= m_n);
#ifdef HAVE_ZFEC
        state = fec_new(m_k, m_n);
        assert(state != NULL);
#else
        LOG(LOG_LEVEL_ERROR) << "zfec support is not compiled in, error correction is disabled\n";
#endif
}

References LOG, LOG_LEVEL_ERROR, m_k, m_n, MAX_K, MAX_N, and state.

rs() [2/2]

rs::rs	(	const char *	cfg,
		bool	is_audio )

Definition at line 96 of file rs.cpp.

{
        if (strcmp(c_cfg, "help") == 0) {
                usage();
                throw 0;
        }
        char *cfg = strdup(c_cfg);
        char *item, *save_ptr;
        item = strtok_r(cfg, ":", &save_ptr);
        if (item != NULL) {
                m_k = atoi(item);
                item = strtok_r(NULL, ":", &save_ptr);
                assert(item != NULL);
                m_n = atoi(item);
        } else {
                m_k = is_audio ? DEFAULT_K_AUDIO : DEFAULT_K_VIDEO;
                m_n = DEFAULT_N;
        }
        free(cfg);
        if (m_k > MAX_K || m_n > MAX_N || m_k >= m_n) {
                usage();
                throw 1;
        }
 
#ifdef HAVE_ZFEC
        state = fec_new(m_k, m_n);
        assert(state != NULL);
        MSG(INFO, "Using Reed-Solomon with k=%u n=%u\n", m_k, m_n);
#else
        throw ug_runtime_error("zfec support is not compiled in");
#endif
}

References DEFAULT_K_AUDIO, DEFAULT_K_VIDEO, DEFAULT_N, m_k, m_n, MAX_K, MAX_N, MSG, state, and usage().

Here is the call graph for this function:

~rs()

rs::~rs ( )

virtual

Definition at line 129 of file rs.cpp.

{
#ifdef HAVE_ZFEC
        if (state != nullptr) {
                fec_free((fec_t *) state);
        }
#endif
}

References state.

Member Function Documentation

decode()

bool rs::decode ( char * in, int in_len, char ** out, int * out_len, const std::map< int, int > &  )

overridevirtual

Return values

true	if whole frame was reconstructed
false	if decoder was unable to reconstruct the frame However, if it was reconstructed at least partially (or the code is a systematic one) and length can be read, set len to a non-zero value.

Implements fec.

Definition at line 273 of file rs.cpp.

{
        std::map<int, int> m = c_m; // make private copy
        unsigned int ss = in_len / m_n;
 
        // compact neighbouring segments
        for (auto it = m.begin(); it != m.end(); ++it) {
                int start = it->first;
                int size = it->second;
 
                auto neighbour = m.end();
                while ((neighbour = m.find(start + size)) != m.end()) {
                        it->second += neighbour->second;
                        size = it->second;
                        m.erase(neighbour);
                }
        }
 
        if (state == nullptr) { // zfec was not compiled in - dummy mode
                *len = get_buf_len(in, c_m);
                *out = (char *) in + sizeof(uint32_t);
                auto fst_sgmt = m.find(0);
                return fst_sgmt != m.end() && (unsigned) fst_sgmt->second >= ss * m_k;
        }
 
#ifdef HAVE_ZFEC
        assert(m_n <= MAX_N);
        void *pkt[MAX_N];
        unsigned int index[MAX_N];
        unsigned int i = 0;
#if 0
 
 
 
        for (auto it = m.begin(); it != m.end(); ++it) {
                int start = it->first;
                int offset = it->second;
 
                int first_symbol_start = (start + ss - 1) / ss * ss;
                int last_symbol_end = (start + offset) / ss * ss;
                //fprintf(stderr, "%d %d %d\n", first_symbol_start, last_symbol_end, start);
                for (int j = first_symbol_start; j < last_symbol_end; j += ss) {
                        //fprintf(stderr, "%d\n", j);
                        pkt[i] = (void *) (in + j);
                        index[i] = j / ss;
                        i++;
                        if (i == m_k) break;
                }
                if (i == m_k) break;
        }
 
        if (i != m_k) {
                *len = 0;
                return;
        }
 
        assert (i == m_k);
 
        int ret = fec_decode(state, pkt, index, ss);
        if (ret != 0) {
                *len = 0;
                return;
        }
        uint32_t out_sz;
        memcpy(&out_sz,  pkt[0], sizeof(out_sz));
        fprintf(stderr, "%d %d\n\n", out_sz, index[0]);
        *len = out_sz;
        *out = (char *) in + 4;
#else
        //const unsigned int bitset_size = m_k;
 
        std::bitset<MAX_K> empty_slots;
        std::bitset<MAX_K> repaired_slots;
 
        for (auto it = m.begin(); it != m.end(); ++it) {
                int start = it->first;
                int size = it->second;
 
                unsigned int first_symbol_start = (start + ss - 1) / ss * ss;
                unsigned int last_symbol_end = (start + size) / ss * ss;
                for (unsigned int j = first_symbol_start; j < last_symbol_end; j += ss) {
                        if (j/ss < m_k) {
                                pkt[j/ss] = in + j;
                                index[j/ss] = j/ss;
                                empty_slots.set(j/ss);
                                //fprintf(stderr, "%d\n", j/ss);
                        } else {
                                for (unsigned int k = 0; k < m_k; ++k) {
                                        if (!empty_slots.test(k)) {
                                                pkt[k] = in + j;
                                                index[k] = j/ss;
                                                //fprintf(stderr, "%d\n", j/ss);
                                                empty_slots.set(k);
                                                repaired_slots.set(k);
                                                break;
                                        }
                                        //fprintf(stderr, "what???\n", j/ss);
                                }
                        }
                        i++;
                        //fprintf(stderr, " %d\n", i);
                        if (i == m_k) break;
                }
                if (i == m_k) break;
        }
 
        //fprintf(stderr, "       %d\n", i);
 
        if (i != m_k) {
                *len = get_buf_len(in, c_m);
                *out = (char *) in + sizeof(uint32_t);
                return false;
        }
 
        char **output = (char **) malloc(m_k * sizeof(char *));
        for (unsigned int i = 0; i < m_k; ++i) {
                output[i] = (char *) malloc(ss);
        }
 
        fec_decode((const fec_t *) state, (const gf *const *) pkt,
                        (gf *const *) output, index, ss);
 
        i = 0;
        for (unsigned int j = 0; j < m_k; ++j) {
                if (repaired_slots.test(j)) {
                        memcpy((void *) (in + j * ss), output[i], ss);
                        i++;
                }
        }
 
        for (unsigned int i = 0; i < m_k; ++i) {
                free(output[i]);
        }
        free(output);
 
        uint32_t out_sz;
        memcpy(&out_sz, in, sizeof(out_sz));
        //fprintf(stderr, "       %d\n", out_sz);
        *len = out_sz;
        *out = (char *) in + sizeof(uint32_t);
#endif
#endif // defined HAVE_ZFEC
 
        return true;
}

References get_buf_len(), len, m_k, m_n, MAX_N, offset, start(), and state.

Here is the call graph for this function:

encode() [1/2]

audio_frame2 rs::encode ( audio_frame2 const & in )

overridevirtual

Reimplemented from fec.

Definition at line 205 of file rs.cpp.

{
#ifdef HAVE_ZFEC
        audio_frame2 out;
        out.init(in.get_channel_count(), in.get_codec(), in.get_bps(), in.get_sample_rate());
        out.reserve(3 * in.get_data_len() / in.get_channel_count()); // just an estimate
 
        for (int i = 0; i < in.get_channel_count(); ++i) {
                audio_payload_hdr_t hdr;
                format_audio_header(&in, i, 0, (uint32_t *) &hdr);
                size_t hdr_len = sizeof(hdr);
                size_t len = in.get_data_len(i);
                uint32_t len32 = len + hdr_len;
                //const char *data = in->get_data(i);
                out.append(i, (char *) &len32, sizeof len32);
                out.append(i, (char *) &hdr, sizeof hdr);
                out.append(i, in.get_data(i), in.get_data_len(i));
 
                int ss = get_ss(hdr_len, len);
                int buffer_len = ss * m_n;
                out.resize(i, buffer_len);
                memset(out.get_data(i) + sizeof(len32) + hdr_len + len, 0, ss * m_k - (sizeof(len32) + hdr_len + len));
 
                out.set_fec_params(i, fec_desc(FEC_RS, m_k, m_n - m_k, 0, 0, ss));
 
                void *src[MAX_K];
                for (unsigned int k = 0; k < m_k; ++k) {
                        src[k] = out.get_data(i) + ss * k;
                }
 
                void *dst[MAX_N];
                unsigned int dst_idx[MAX_N];
                for (unsigned int m = 0; m < m_n-m_k; ++m) {
                        dst[m] = out.get_data(i) + ss * (m_k + m);
                        dst_idx[m] = m_k + m;
                }
 
                fec_encode((const fec_t *)state, (gf **) src,
                                (gf **) dst, dst_idx, m_n-m_k, ss);
        }
 
        return out;
#else
        (void) in;
        return {};
#endif // defined HAVE_ZFEC
}

References audio_frame2::append(), FEC_RS, format_audio_header(), audio_frame2::get_bps(), audio_frame2::get_channel_count(), audio_frame2::get_codec(), audio_frame2::get_data(), audio_frame2::get_data_len(), audio_frame2::get_sample_rate(), get_ss(), audio_frame2::init(), len, m_k, m_n, MAX_K, MAX_N, audio_frame2::reserve(), audio_frame2::resize(), audio_frame2::set_fec_params(), and state.

Here is the call graph for this function:

encode() [2/2]

shared_ptr< video_frame > rs::encode ( std::shared_ptr< video_frame > frame )

overridevirtual

Implements fec.

Definition at line 138 of file rs.cpp.

{
#ifdef HAVE_ZFEC
        assert(state != nullptr);
 
        video_payload_hdr_t hdr;
        format_video_header(in.get(), 0, 0, hdr);
        const size_t hdr_len = sizeof(hdr);
 
        struct video_frame *out = vf_alloc_desc(video_desc_from_frame(in.get()));
 
        for (unsigned i = 0; i < in->tile_count; ++i) {
                size_t len = in->tiles[i].data_len;
                char *data = in->tiles[i].data;
                //int encode(char *hdr, int hdr_len, char *in, int len, char **out) {
                int ss = get_ss(hdr_len, len);
                int buffer_len = ss * m_n;
                char *out_data;
                out_data = out->tiles[i].data = (char *) malloc(buffer_len);
                uint32_t len32 = len + hdr_len;
                memcpy(out_data, &len32, sizeof(len32));
                memcpy(out_data + sizeof(len32), hdr, hdr_len);
                memcpy(out_data + sizeof(len32) + hdr_len, data, len);
                memset(out_data + sizeof(len32) + hdr_len + len, 0, ss * m_k - (sizeof(len32) + hdr_len + len));
 
#if 0
                void *src[MAX_K];
                for (int k = 0; k < m_k; ++k) {
                        src[k] = *out + ss * k;
                }
 
                for (int m = 0; m < m_n - m_k; ++m) {
                        fec_encode(state, src, *out + ss * (m_k + m), m, ss);
                }
#else
                void *src[MAX_K];
                for (unsigned int k = 0; k < m_k; ++k) {
                        src[k] = out_data + ss * k;
                }
                void *dst[MAX_N];
                unsigned int dst_idx[MAX_N];
                for (unsigned int m = 0; m < m_n-m_k; ++m) {
                        dst[m] = out_data + ss * (m_k + m);
                        dst_idx[m] = m_k + m;
                }
 
                fec_encode((const fec_t *)state, (gf **) src,
                                (gf **) dst, dst_idx, m_n-m_k, ss);
#endif
 
                out->tiles[i].data_len = buffer_len;
                out->fec_params = fec_desc(FEC_RS, m_k, m_n - m_k, 0, 0, ss);
        }
 
        static auto deleter = [](video_frame *frame) {
                for (unsigned i = 0; i < frame->tile_count; ++i) {
                        free(frame->tiles[i].data);
                }
                vf_free(frame);
        };
        return {out, deleter};
#else
        (void) in;
        return {};
#endif // defined HAVE_ZFEC
}

References tile::data, tile::data_len, deleter, video_frame::fec_params, FEC_RS, format_video_header(), frame, get_ss(), len, m_k, m_n, MAX_K, MAX_N, state, video_frame::tile_count, video_frame::tiles, vf_alloc_desc(), vf_free(), and video_desc_from_frame().

Here is the call graph for this function:

get_buf_len()

uint32_t rs::get_buf_len ( const char * buf, std::map< int, int > const & c_m )

private

Returns

stored buffer data length or 0 if first packet (header) is missing

Definition at line 263 of file rs.cpp.

{
        if (auto it = c_m.find(0); it != c_m.end() && it->second >= 4) {
                uint32_t out_sz;
                memcpy(&out_sz, buf, sizeof(out_sz));
                return out_sz;
        }
        return 0U;
}

Referenced by decode().

get_ss()

int rs::get_ss ( int hdr_len, int len )

private

Returns symbol size (?) for given headers len and with configured m_k

Definition at line 256 of file rs.cpp.

                                   {
        return ((sizeof(uint32_t) + hdr_len + len) + m_k - 1) / m_k;
}

References len, and m_k.

Referenced by encode(), and encode().

Member Data Documentation

m_k

unsigned int rs::m_k

private

Definition at line 62 of file rs.h.

Referenced by rs(), rs(), decode(), encode(), encode(), and get_ss().

m_n

unsigned int rs::m_n

private

Definition at line 62 of file rs.h.

Referenced by rs(), rs(), decode(), encode(), and encode().

state

void* rs::state = nullptr

private

Definition at line 61 of file rs.h.

Referenced by rs(), rs(), ~rs(), decode(), encode(), and encode().

---

The documentation for this struct was generated from the following files:

• src/rtp/rs.h
• src/rtp/rs.cpp