ldgm Struct Reference

#include <ldgm.h>

Inheritance diagram for ldgm:

Collaboration diagram for ldgm:

Public Member Functions
	ldgm (const char *cfg)
	ldgm (int packet_size, int frame_size, double max_expected_loss)
	ldgm (unsigned int k, unsigned int m, unsigned int c, unsigned int seed)
bool	decode (char *in, int in_len, char **out, int *len, const std::map< int, int > &)
std::shared_ptr< video_frame >	encode (std::shared_ptr< video_frame >)
void	set_params (unsigned int k, unsigned int m, unsigned int c, unsigned int seed)
Public Member Functions inherited from fec
virtual	~fec ()
virtual audio_frame2	encode (audio_frame2 const &)

Private Member Functions
void	init (unsigned int k, unsigned int m, unsigned int c, unsigned int seed=DEFAULT_LDGM_SEED)

Private Attributes
unsigned int	m_c
std::shared_ptr< LDGM_session >	m_coding_session
unsigned int	m_k
unsigned int	m_m
unsigned int	m_seed

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 54 of file ldgm.h.

Constructor & Destructor Documentation

ldgm() [1/3]

ldgm::ldgm	(	unsigned int	k,
		unsigned int	m,
		unsigned int	c,
		unsigned int	seed )

Definition at line 239 of file ldgm.cpp.

{
        init(k, m, c, seed);
}

References init().

Here is the call graph for this function:

ldgm() [2/3]

ldgm::ldgm	(	int	packet_size,
		int	frame_size,
		double	max_expected_loss )

Definition at line 336 of file ldgm.cpp.

{
        packet_type_t packet_type;
        int nearest = INT_MAX;
        loss_t loss = -1.0;
        int k, m, c;
 
        assert(max_expected_loss >= 0.0 && max_expected_loss <= 100.0);
 
        if(frame_size < 2000000 && packet_size >= (STD1500 + JUMBO9000) / 2) {
                throw string("LDGM: with frames smaller than 2M you should use standard Ethernet frames.");
        }
 
        if(packet_size < (STD1500 + JUMBO9000) / 2) {
                packet_type = STD1500;
        } else {
                packet_type = JUMBO9000;
        }
 
        for(unsigned int i = 1; i < sizeof(losses) / sizeof(loss_t); ++i) {
                if(max_expected_loss >= losses[i - 1] && max_expected_loss <= losses[i]) {
                        loss = losses[i];
                        break;
                }
        }
 
        if(loss == -1.0) {
                ostringstream oss;
                oss <<  "LDGM: Cannot provide predefined settings for correction of loss of " << setprecision(2)
                        << max_expected_loss << endl << 
                        "LDGM: You have to try and set LDGM parameters manually. You can inform us if you need better protection.";
                throw oss.str();
        }
 
        printf("LDGM: Choosing maximal loss %2.2f percent.\n", loss);
 
        for(unsigned int i = 0; i < sizeof(suggested_configurations) / sizeof(configuration_t); ++i) {
                if(suggested_configurations[i].packet_type == packet_type &&
                                suggested_configurations[i].loss == loss) {
                        if(abs(suggested_configurations[i].frame_size - frame_size) < abs(nearest - frame_size)) {
                                nearest = suggested_configurations[i].frame_size;
                                k = suggested_configurations[i].k;
                                m = suggested_configurations[i].m;
                                c = suggested_configurations[i].c;
                        }
                }
        }
 
        if (nearest == INT_MAX) {
                throw string("LDGM: Could not find matching configuration for your request.\n"
                                "Please, set LDGM parameters manually.");
        }
 
        double difference_from_frame_size = abs(nearest - frame_size) / (double) frame_size;
        if(difference_from_frame_size > 0.2) {
                LOG(LOG_LEVEL_WARNING) << "LDGM: Chosen LDGM setting for frame size that is " << difference_from_frame_size * 100.0 << "% " << (nearest - frame_size > 0 ? "higher" : "lower") << " than your frame size.\n";
                LOG(LOG_LEVEL_WARNING) << "You may wish to set the parameters manually.\n";
        }
 
        if(difference_from_frame_size > 0.5) {
                throw string("");
        }
 
        init(k, m, c);
}

References abs(), configuration_t::c, configuration_t::frame_size, init(), JUMBO9000, configuration_t::k, LOG, LOG_LEVEL_WARNING, loss, losses, configuration_t::m, STD1500, and suggested_configurations.

Here is the call graph for this function:

ldgm() [3/3]

ldgm::ldgm

(

const char *

cfg

)

Definition at line 282 of file ldgm.cpp.

{
        unsigned int k = DEFAULT_K,
                     m = DEFAULT_M,
                     c = DEFAULT_C;
 
        if(cfg && strlen(cfg) > 0) {
                if(strcasecmp(cfg, "help") == 0) {
                        usage();
                        throw 0;
                }
                char *save_ptr = NULL;
                char *item;
                char *tmp = strdup(cfg);
                item = strtok_r(tmp, ":", &save_ptr);
                if(item) {
                        k = atoi(item);
                }
                item = strtok_r(NULL, ":", &save_ptr);
                if(item) {
                        m = atoi(item);
                        item = strtok_r(NULL, ":", &save_ptr);
                        if(item) {
                                c = atoi(item);
                        }
                } else {
                        throw string("[LDGM] Was set k value but not m.");
                }
                free(tmp);
        }
 
        if(c < MIN_C || c > MAX_C) {
                ostringstream oss;
                oss << "[LDGM] C value shoud be inside interval [" << MIN_C << ", " << MAX_C << "]";
                throw oss.str();
        }
 
        if(k > MAX_K) {
                ostringstream oss;
                oss << "[LDGM] K value exceeds maximal value " <<  MAX_K;
                throw oss.str();
        }
 
        if(k < MINIMAL_VALUE || m < MINIMAL_VALUE) {
                ostringstream oss;
                oss << "[LDGM] Either k or m is lower than minimal value " << MINIMAL_VALUE;
                throw oss.str();
        }
 
        printf("[LDGM] Using values k = %u, m = %u, c = %u.\n", k, m, c);
 
        init(k, m, c);
}

References DEFAULT_C, DEFAULT_K, DEFAULT_M, init(), MAX_C, MAX_K, MIN_C, MINIMAL_VALUE, and usage().

Here is the call graph for this function:

Member Function Documentation

decode()

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

virtual

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 244 of file ldgm.cpp.

                                                                                                {
        char *decoded;
        decoded = m_coding_session->decode_frame(frame, size, out_size, packets);
        if (*out_size > 0) {
                *out = decoded;
                return true;
        } else {
                return false;
        }
}

References frame, and m_coding_session.

encode()

shared_ptr< video_frame > ldgm::encode ( std::shared_ptr< video_frame > tx_frame )

virtual

Implements fec.

Definition at line 426 of file ldgm.cpp.

{
        // We need to have copy of coding session shared pointer in order to exit
        // gracefully even when destructed LDGM state first with some frame still
        // existing.
        std::shared_ptr<LDGM_session> coding_session = this->m_coding_session;
        shared_ptr<video_frame> out(vf_alloc_desc(video_desc_from_frame(tx_frame.get())),
                        [coding_session = std::move(coding_session)](struct video_frame *frame) {
                                for (unsigned int i = 0; i < frame->tile_count; ++i) {
                                        coding_session->free_out_buf(frame->tiles[i].data);
                                }
                                vf_free(frame);
                        });
 
        for (unsigned int i = 0; i < tx_frame->tile_count; ++i) {
                video_payload_hdr_t video_hdr;
                format_video_header(tx_frame.get(), i, 0, video_hdr);
 
                check_packet_size(tx_frame->tiles[i].data_len, m_k);
 
                int out_size;
                char *output = m_coding_session->encode_hdr_frame((char *) video_hdr, sizeof(video_hdr),
                                tx_frame->tiles[i].data, tx_frame->tiles[i].data_len, &out_size);
 
                out->tiles[i].data = output;
                out->tiles[i].data_len = out_size;
        }
 
        out->fec_params.type = FEC_LDGM;
        out->fec_params.k = m_k;
        out->fec_params.m = m_m;
        out->fec_params.c = m_c;
        out->fec_params.seed = m_seed;
        out->fec_params.symbol_size = m_coding_session->get_packet_size();
 
        return out;
}

References frame, m_coding_session, vf_alloc_desc(), vf_free(), and video_desc_from_frame().

Here is the call graph for this function:

init()

void ldgm::init ( unsigned int k, unsigned int m, unsigned int c, unsigned int seed = DEFAULT_LDGM_SEED )

private

Definition at line 212 of file ldgm.cpp.

{
        bool ldgm_device_gpu = false;
 
        if (get_commandline_param("ldgm-device")) {
            ldgm_device_gpu = strcasecmp(get_commandline_param("ldgm-device"), "GPU") == 0;
        }
 
        if (ldgm_device_gpu) {
                LDGM_session_gpu *(*loader)();
                loader = reinterpret_cast<LDGM_session_gpu *(*)()>(
                                const_cast<void *>(
                                        load_library("ldgm_gpu",
                                                LIBRARY_CLASS_UNDEFINED, LDGM_GPU_API_VERSION)));
                if (!loader) {
                        throw string("GPU accelerated LDGM support is not compiled in");
                } else {
                        m_coding_session = unique_ptr<LDGM_session>(loader());
 
                }
        } else {
                m_coding_session = unique_ptr<LDGM_session>(new LDGM_session_cpu());
        }
 
        set_params(k, m, c, seed);
}

References get_commandline_param(), LDGM_GPU_API_VERSION, LIBRARY_CLASS_UNDEFINED, load_library(), m_coding_session, and set_params().

Referenced by ldgm(), ldgm(), and ldgm().

Here is the call graph for this function:

set_params()

void ldgm::set_params	(	unsigned int	k,
		unsigned int	m,
		unsigned int	c,
		unsigned int	seed )

Definition at line 161 of file ldgm.cpp.

{
        m_k = k;
        m_m = m;
        m_c = c;
        m_seed = seed;
 
        m_coding_session->set_params(k, m, c);
 
        char filename[512];
        char path[256];
 
        int res;
 
#ifdef _WIN32
        TCHAR tmpPath[MAX_PATH];
        UINT ret = GetTempPath(MAX_PATH, tmpPath);
        if(ret == 0 || ret > MAX_PATH) {
                fprintf(stderr, "Unable to get temporary directory name.\n");
                throw 1;
        }
        snprintf(path, 256, "%s\\ultragrid\\", tmpPath);
#else
        snprintf(path, 256, "/var/tmp/ultragrid-%d/", (int) getuid());
#endif
 
        res = mkdir(path, S_IRWXU | S_IRWXG | S_IRWXO);
        if(res != 0) {
                if(errno != EEXIST) {
                        perror("mkdir");
                        fprintf(stderr, "[LDGM] Unable to create data directory.\n");
                        throw 1;
                }
        }
        snprintf(filename, 512, "%s/ldgm_matrix-%u-%u-%u-%u.bin", path, k, m, c, seed);
        if(!file_exists(filename)) {
                int ret = generate_ldgm_matrix(filename, k, m, c, seed, 0);
                if(ret != 0) {
                        fprintf(stderr, "[LDGM] Unable to initialize LDGM matrix.\n");
                        throw 1;
                }
        }
 
        m_coding_session->set_pcMatrix(filename);
 
        MSG(INFO, "Using LDGM with k=%u m=%u c=%u\n", m_k, m_m, m_c);
}

References file_exists(), generate_ldgm_matrix(), m_c, m_coding_session, m_k, m_m, m_seed, and MSG.

Referenced by init().

Here is the call graph for this function:

Member Data Documentation

m_c

unsigned int ldgm::m_c

private

Definition at line 67 of file ldgm.h.

Referenced by set_params().

m_coding_session

std::shared_ptr<LDGM_session> ldgm::m_coding_session

private

Definition at line 66 of file ldgm.h.

Referenced by decode(), encode(), init(), and set_params().

m_k

unsigned int ldgm::m_k

private

Definition at line 67 of file ldgm.h.

Referenced by set_params().

m_m

unsigned int ldgm::m_m

private

Definition at line 67 of file ldgm.h.

Referenced by set_params().

m_seed

unsigned int ldgm::m_seed

private

Definition at line 68 of file ldgm.h.

Referenced by set_params().

---

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

• src/rtp/ldgm.h
• src/rtp/ldgm.cpp