Module infrastructure

Files
file	module.h

Classes
struct	module
class	module_raii

Macros
#define	CAST_MODULE(x)
#define	MODULE_MAGIC   to_fourcc('M', 'O', 'D', ' ')

Typedefs
typedef void(*	module_deleter_t) (struct module *)
typedef void(*	notify_t) (struct module *)

Enumerations
enum	module_class {   MODULE_CLASS_NONE = 0 , MODULE_CLASS_ROOT , MODULE_CLASS_PORT , MODULE_CLASS_COMPRESS ,   MODULE_CLASS_DATA , MODULE_CLASS_SENDER , MODULE_CLASS_RECEIVER , MODULE_CLASS_TX ,   MODULE_CLASS_AUDIO , MODULE_CLASS_CONTROL , MODULE_CLASS_CAPTURE , MODULE_CLASS_FILTER ,   MODULE_CLASS_DISPLAY , MODULE_CLASS_DECODER , MODULE_CLASS_EXPORTER , MODULE_CLASS_KEYCONTROL }

Functions
void	append_message_path (char *buf, int buflen, const enum module_class *modules)
void	dump_parents (struct module *node)
void	dump_tree (struct module *root_node, int indent)
struct module *	get_matching_child (struct module *node, const char *path)
struct module *	get_module (struct module *root, const char *path)
struct module *	get_parent_module (struct module *node)
struct module *	get_root_module (struct module *node)
const char *	module_class_name (enum module_class cls)
void	module_done (struct module *module_data)
bool	module_get_path_str (struct module *mod, char *buf, size_t buflen)
void	module_init_default (struct module *module_data)
void	module_register (struct module *module_data, struct module *parent)

Detailed Description

Module registration

Example:

struct state {
     struct module mod;
     ...
} s;
module_init_default(&s->mod);
s->mod.cls = MODULE_CLASS_<NAME>; // allways needed
s->mod.priv_data = s;             // optional
s->mod.deleter = deleter;         // only used for generic modules, see a note bellow
module_register(&s->mod, s->parent);

Note

Struct module should be first inside the struct in order to be able to call CAST_MODULE to it (however, it is currently strictly required only for tx and video_compress_info modules).

Macro Definition Documentation

CAST_MODULE

#define CAST_MODULE

(

x

)

Value:

((struct module *) x)

Definition at line 197 of file module.h.

Referenced by am_participant::~am_participant(), rtp_video_rxtx::~rtp_video_rxtx(), audio_done(), and audio_init().

MODULE_MAGIC

#define MODULE_MAGIC   to_fourcc('M', 'O', 'D', ' ')

Definition at line 79 of file module.h.

Referenced by module_done(), and module_init_default().

Typedef Documentation

module_deleter_t

typedef void(* module_deleter_t) (struct module *)

Definition at line 103 of file module.h.

notify_t

typedef void(* notify_t) (struct module *)

Definition at line 104 of file module.h.

Enumeration Type Documentation

module_class

enum module_class

Enumerator
MODULE_CLASS_NONE
MODULE_CLASS_ROOT
MODULE_CLASS_PORT
MODULE_CLASS_COMPRESS
MODULE_CLASS_DATA
MODULE_CLASS_SENDER
MODULE_CLASS_RECEIVER
MODULE_CLASS_TX
MODULE_CLASS_AUDIO
MODULE_CLASS_CONTROL
MODULE_CLASS_CAPTURE
MODULE_CLASS_FILTER
MODULE_CLASS_DISPLAY
MODULE_CLASS_DECODER
MODULE_CLASS_EXPORTER
MODULE_CLASS_KEYCONTROL

Definition at line 81 of file module.h.

                  {
        MODULE_CLASS_NONE = 0,
        MODULE_CLASS_ROOT,
        MODULE_CLASS_PORT,
        MODULE_CLASS_COMPRESS,
        MODULE_CLASS_DATA,
        MODULE_CLASS_SENDER,
        MODULE_CLASS_RECEIVER,
        MODULE_CLASS_TX,
        MODULE_CLASS_AUDIO,
        MODULE_CLASS_CONTROL,
        MODULE_CLASS_CAPTURE,
        MODULE_CLASS_FILTER,
        MODULE_CLASS_DISPLAY,
        MODULE_CLASS_DECODER,
        MODULE_CLASS_EXPORTER,
        MODULE_CLASS_KEYCONTROL,
};

Function Documentation

append_message_path()

void append_message_path	(	char *	buf,
		int	buflen,
		const enum module_class *	modules )

Definition at line 187 of file module.c.

{
        const enum module_class *mod = modules;
 
        while(*mod != MODULE_CLASS_NONE) {
                if(strlen(buf) > 0) {
                        strncat(buf, ".", buflen - strlen(buf) - 1);
                }
                const char *node_name = module_class_name(*mod);
                assert(node_name != NULL);
 
                strncat(buf, node_name, buflen - strlen(buf) - 1);
                mod += 1;
        }
}

References module_class_name(), and MODULE_CLASS_NONE.

Referenced by BasicRTSPOnlySubsession::deleteStream(), process_msg(), sdp_send_change_address_message(), and BasicRTSPOnlySubsession::startStream().

Here is the call graph for this function:

dump_parents()

void dump_parents

(

struct module *

node

)

Definition at line 348 of file module.c.

{
        bool first = true;
        while (node != NULL) {
                if (!first) {
                        printf("<-");
                }
                printf("%s", module_class_name(node->cls));
                first = false;
                node  = get_parent_module(node);
        }
        printf("\n");
}

References cls, first, get_parent_module(), and module_class_name().

Referenced by module_done().

Here is the call graph for this function:

dump_tree()

void dump_tree	(	struct module *	root_node,
		int	indent )

Dumps modules' tree.

Important

no module in the tree should be locked (although currently recursive mutexes are used, so it will work if locked from same thread)

Definition at line 333 of file module.c.

                                                     {
        for(int i = 0; i < indent; ++i)
                putchar(' ');
 
        printf("%s\n", module_class_name(root_node->cls));
 
        module_mutex_lock(&root_node->lock);
        for(void *it = simple_linked_list_it_init(root_node->children); it != NULL; ) {
                struct module *child = simple_linked_list_it_next(&it);
                dump_tree(child, indent + 2);
        }
        module_mutex_unlock(&root_node->lock);
}

References children, cls, dump_tree(), lock, module_class_name(), module_mutex_lock(), module_mutex_unlock(), simple_linked_list_it_init(), and simple_linked_list_it_next().

Referenced by dump_tree(), module_done(), and process_msg().

Here is the call graph for this function:

get_matching_child()

struct module * get_matching_child	(	struct module *	node,
		const char *	path )

IMPORTANT: module given as parameter should be locked within the calling thread.

Return values

NULL	if not found
non-NULL	pointer to the module

Definition at line 300 of file module.c.

{
        struct module *receiver = node;
        char *path, *tmp;
        char *item, *save_ptr = NULL;
 
        assert(node != NULL);
 
        tmp = path = strdup(const_path);
        assert(path != NULL);
        if ((item = strtok_r(path, ".", &save_ptr))) {
                int id_num = 0;
                char *id_name = NULL;
                get_receiver_index(item, &id_num, &id_name);
                receiver = find_child(receiver, item, id_num, id_name);
                if (!receiver) {
                        free(tmp);
                        return NULL;
                }
                free(tmp);
                return receiver;
        }
 
        free(tmp);
 
        return NULL;
}

References find_child(), and get_receiver_index().

Referenced by get_module(), module_check_undelivered_messages(), and send_message_common().

Here is the call graph for this function:

get_module()

struct module * get_module	(	struct module *	root,
		const char *	path )

Return values

NULL	if not found
non-NULL	pointer to the module

Definition at line 264 of file module.c.

{
        assert(root != NULL);
        assert(const_path != NULL);
 
        struct module *receiver = root;
        char *path, *tmp;
        char *item, *save_ptr;
 
        module_mutex_lock(&root->lock);
 
        tmp = path = strdup(const_path);
        assert(path != NULL);
        while ((item = strtok_r(path, ".", &save_ptr))) {
                struct module *old_receiver = receiver;
 
                receiver = get_matching_child(receiver, item);
 
                if (!receiver) {
                        module_mutex_unlock(&old_receiver->lock);
                        free(tmp);
                        return NULL;
                }
                module_mutex_lock(&receiver->lock);
                module_mutex_unlock(&old_receiver->lock);
 
                path = NULL;
 
        }
        free(tmp);
 
        module_mutex_unlock(&receiver->lock);
 
        return receiver;
}

References get_matching_child(), lock, module_mutex_lock(), and module_mutex_unlock().

Referenced by state_controlport_stats::state_controlport_stats(), state_video_decoder::state_video_decoder(), ultragrid_rtp_video_rxtx::ultragrid_rtp_video_rxtx(), audio_decoder_init(), display_sdl_init(), and tx_init().

Here is the call graph for this function:

get_parent_module()

struct module * get_parent_module

(

struct module *

node

)

Definition at line 214 of file module.c.

{
        return node->parent;
}

References parent.

Referenced by dump_parents(), get_module_identifier(), set_fec(), and tx_update().

get_root_module()

struct module * get_root_module

(

struct module *

node

)

Returns pointer to root module.

Return values

root

module

Definition at line 203 of file module.c.

{
        assert(node);
        while(node->parent) {
                node = node->parent;
        }
        assert(node->cls == MODULE_CLASS_ROOT);
 
        return node;
}

References cls, MODULE_CLASS_ROOT, and parent.

Referenced by keyboard_control::impl::impl(), state_controlport_stats::state_controlport_stats(), state_video_decoder::state_video_decoder(), ultragrid_rtp_video_rxtx::ultragrid_rtp_video_rxtx(), audio_decoder_init(), audio_done(), h264_sdp_video_rxtx::change_address_callback(), display_decklink_init(), display_sdl2_run(), display_sdl_init(), glfw_key_callback(), keycontrol_register_key(), h264_sdp_video_rxtx::send_frame(), h264_sdp_video_rxtx::set_audio_spec(), tx_init(), and vidcap_switcher_register_keyboard_ctl().

module_class_name()

const char * module_class_name

(

enum module_class

cls

)

Definition at line 178 of file module.c.

{
        if((unsigned int) cls < sizeof(module_class_name_pairs)/sizeof(const char *))
                return module_class_name_pairs[cls];
        else
                return NULL;
}

References cls, and module_class_name_pairs.

Referenced by append_message_path(), dump_parents(), dump_tree(), find_child(), get_module_identifier(), and process_msg().

module_done()

void module_done

(

struct module *

module_data

)

Definition at line 93 of file module.c.

{
        if(!module_data)
                return;
 
        if (module_data->cls == MODULE_CLASS_NONE)
                return;
 
        assert(module_data->magic == MODULE_MAGIC);
 
        if(module_data->parent) {
                module_mutex_lock(&module_data->parent->lock);
                bool found = simple_linked_list_remove(
                    module_data->parent->children, module_data);
                assert(found);
                module_mutex_unlock(&module_data->parent->lock);
        }
 
        // we assume that deleter may dealloc space where are structure stored
        module_mutex_lock(&module_data->lock);
        struct module tmp;
        memcpy(&tmp, module_data, sizeof(struct module));
        module_mutex_unlock(&module_data->lock);
 
        module_data->cls = MODULE_CLASS_NONE;
 
        if(module_data->deleter)
                module_data->deleter(module_data);
 
        if(simple_linked_list_size(tmp.children) > 0) {
                log_msg(LOG_LEVEL_WARNING, "Warning: Child database not empty! Remaining:\n");
                dump_tree(&tmp, 0);
                module_mutex_lock(&tmp.lock);
                for(void *it = simple_linked_list_it_init(module_data->children); it != NULL; ) {
                        struct module *child = simple_linked_list_it_next(&it);
                        module_mutex_lock(&child->lock);
                        child->parent = NULL;
                        module_mutex_unlock(&child->lock);
                }
                module_mutex_unlock(&tmp.lock);
        }
        simple_linked_list_destroy(tmp.children);
 
        if(simple_linked_list_size(tmp.msg_queue) > 0) {
                fprintf(stderr, "Warning: Message queue not empty!\n");
                if (log_level >= LOG_LEVEL_VERBOSE) {
                        printf("Path: ");
                        dump_parents(&tmp);
                }
                struct message *m;
                while ((m = check_message(&tmp))) {
                        free_message(m, NULL);
                }
        }
        simple_linked_list_destroy(tmp.msg_queue);
 
        while (simple_linked_list_size(tmp.msg_queue_children) > 0) {
                struct message *m = simple_linked_list_pop(tmp.msg_queue_children);
                free_message_for_child(m, NULL);
        }
        simple_linked_list_destroy(tmp.msg_queue_children);
 
        pthread_mutex_destroy(&tmp.lock);
 
        free(tmp.name);
}

References check_message(), children, cls, deleter, dump_parents(), dump_tree(), free_message(), free_message_for_child(), lock, log_level, LOG_LEVEL_VERBOSE, LOG_LEVEL_WARNING, log_msg(), magic, MODULE_CLASS_NONE, MODULE_MAGIC, module_mutex_lock(), module_mutex_unlock(), msg_queue, msg_queue_children, name, parent, simple_linked_list_destroy(), simple_linked_list_it_init(), simple_linked_list_it_next(), simple_linked_list_pop(), simple_linked_list_remove(), and simple_linked_list_size().

Referenced by video_rxtx::video_rxtx(), am_participant::~am_participant(), hd_rum_translator_state::~hd_rum_translator_state(), module_raii::~module_raii(), replica::~replica(), rtp_video_rxtx::~rtp_video_rxtx(), state_gl::~state_gl(), state_sdl::~state_sdl(), state_uv::~state_uv(), state_video_decoder::~state_video_decoder(), video_rxtx::~video_rxtx(), audio_decoder_destroy(), audio_done(), audio_init(), capture_filter_destroy(), capture_filter_init(), cleanup_common(), compress_done(), control_done(), display_done(), display_sdl2_done(), done(), export_destroy(), initialize_video_capture(), initialize_video_display(), keyboard_control::impl::stop(), tx_init(), vidcap_done(), vidcap_file_common_cleanup(), and vidcap_switcher_done().

Here is the call graph for this function:

module_get_path_str()

bool module_get_path_str	(	struct module *	mod,
		char *	buf,
		size_t	buflen )

Gets textual representation of path from root to module.

Currently only simple paths are created (class names only)

Definition at line 408 of file module.c.

                                                                       {
        assert(buflen > 0);
        buf[0] = '\0';
 
        while (mod) {
                const char *cur_name = get_module_identifier(mod);
                if (sizeof(buf) + 1 + sizeof(cur_name) >= buflen) {
                        return false;
                }
                // move content of buf strlen(cur_name) right
                if (strlen(buf) > 0) {
                        memmove(buf + strlen(cur_name) + 1, buf, strlen(buf) + 1);
                        buf[strlen(cur_name)] = '.'; // and separate with '.'
                } else { // rightmost (first written) element
                        buf[strlen(cur_name)] = '\0';
                }
                memcpy(buf, cur_name, strlen(cur_name));
                mod = mod->parent;
        }
 
        return true;
}

References get_module_identifier(), and parent.

Referenced by keycontrol_register_key().

Here is the call graph for this function:

module_init_default()

void module_init_default

(

struct module *

module_data

)

Definition at line 48 of file module.c.

{
        int ret = 0;
        memset(module_data, 0, sizeof(struct module));
 
        pthread_mutexattr_t attr;
        ret |= pthread_mutexattr_init(&attr);
        ret |= pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
        ret |= pthread_mutex_init(&module_data->lock, &attr);
        ret |= pthread_mutex_init(&module_data->msg_queue_lock, &attr);
        ret |= pthread_mutexattr_destroy(&attr);
        assert(ret == 0 && "Unable to create mutex or set attributes");
 
        module_data->children = simple_linked_list_init();
        module_data->msg_queue = simple_linked_list_init();
        module_data->msg_queue_children = simple_linked_list_init();
 
        module_data->magic = MODULE_MAGIC;
}

References children, lock, magic, MODULE_MAGIC, msg_queue, msg_queue_children, msg_queue_lock, and simple_linked_list_init().

Referenced by keyboard_control::impl::impl(), module_raii::module_raii(), replica::replica(), state_gl::state_gl(), state_sdl::state_sdl(), state_video_decoder::state_video_decoder(), video_rxtx::video_rxtx(), audio_decoder_init(), capture_filter_init(), cineform_compress_init(), compress_init(), control_init(), display_sdl2_init(), export_init(), init(), init_root_module(), initialize_import(), initialize_video_capture(), initialize_video_display(), j2k_compress_init(), tx_init(), vidcap_file_init(), and vidcap_switcher_init().

Here is the call graph for this function:

module_register()

void module_register	(	struct module *	module_data,
		struct module *	parent )

Definition at line 82 of file module.c.

{
        if(parent) {
                module_data->parent = parent;
                module_mutex_lock(&module_data->parent->lock);
                simple_linked_list_append(module_data->parent->children, module_data);
                module_check_undelivered_messages(module_data->parent);
                module_mutex_unlock(&module_data->parent->lock);
        }
}

References children, lock, module_check_undelivered_messages(), module_mutex_lock(), module_mutex_unlock(), parent, parent, and simple_linked_list_append().

Referenced by keyboard_control::impl::impl(), module_raii::module_raii(), replica::replica(), state_gl::state_gl(), state_sdl::state_sdl(), state_video_decoder::state_video_decoder(), video_rxtx::video_rxtx(), audio_decoder_init(), capture_filter_init(), cineform_compress_init(), compress_init(), control_init(), display_sdl2_init(), export_init(), init(), initialize_import(), initialize_video_capture(), initialize_video_display(), j2k_compress_init(), tx_init(), vidcap_file_init(), and vidcap_switcher_init().

Here is the call graph for this function: