lib_common.cpp File Reference

#include <iostream>
#include <map>
#include "debug.h"
#include "host.h"
#include "lib_common.h"
#include "utils/color_out.h"

Include dependency graph for lib_common.cpp:

Go to the source code of this file.

Classes
struct	ci_less
struct	ci_less::nocase_compare
struct	lib_info
struct	library_class_info_t

Macros
#define	MOD_NAME   "[lib] "

Functions
static auto &	get_libmap ()
map< string, const void * >	get_libraries_for_class (enum library_class cls, int abi_version, bool include_hidden)
bool	list_all_modules ()
void	list_modules (enum library_class cls, int abi_version, bool full)
const void *	load_library (const char *name, enum library_class cls, int abi_version)
void	open_all (const char *pattern, list< void * > &libs)
void	register_library (const char *name, const void *data, enum library_class cls, int abi_version, int hidden)

Variables
static map< string, string >	lib_errors
const map< enum library_class, library_class_info_t >	library_class_info

Detailed Description

Author

Martin Pulec pulec.nosp@m.@ces.nosp@m.net.c.nosp@m.z

Definition in file lib_common.cpp.

Macro Definition Documentation

MOD_NAME

#define MOD_NAME   "[lib] "

Definition at line 58 of file lib_common.cpp.

Function Documentation

get_libmap()

static auto & get_libmap ( )

static

Definition at line 242 of file lib_common.cpp.

                         {
        /* This is needed because register_library() may be called before global
         * static members are initialized (it is __attribute__((constructor)))
         */
        static map<enum library_class, map<string, lib_info, ci_less>> libraries;
        return libraries;
}

Referenced by get_libraries_for_class(), list_all_modules(), load_library(), and register_library().

get_libraries_for_class()

map< string, const void * > get_libraries_for_class	(	enum library_class	cls,
		int	abi_version,
		bool	include_hidden )

Definition at line 336 of file lib_common.cpp.

{
        map<string, const void *> ret;
        auto& libraries = get_libmap();
        auto it = libraries.find(cls);
        if (it != libraries.end()) {
                for (auto && item : it->second) {
                        if (abi_version == item.second.abi_version) {
                                if (include_hidden || !item.second.hidden) {
                                        ret[item.first] = item.second.data;
                                }
                        } else {
                                LOG(LOG_LEVEL_WARNING) << "Module " << item.first << " ABI version mismatch (required " <<
                                        abi_version << ", have " << item.second.abi_version << ")\n";
 
                        }
                }
        }
 
        return ret;
}

References cls, get_libmap(), LOG, and LOG_LEVEL_WARNING.

Referenced by audio_codec_init_real(), audio_filter_init(), create_filter(), find_best_decompress(), list_modules(), and print_capabilities().

Here is the call graph for this function:

list_all_modules()

bool list_all_modules

(

)

Return values

false

if there occurs some problem opening one or more modules, true otherwise

Definition at line 308 of file lib_common.cpp.

                        {
        bool ret = true;
 
        auto& libraries = get_libmap();
        for (auto cls_it = library_class_info.begin(); cls_it != library_class_info.end();
                        ++cls_it) {
                cout << cls_it->second.class_name << "\n";
                auto it = libraries.find(cls_it->first);
                if (it != libraries.end()) {
                        for (auto && item : it->second) {
                                col() << "\t" << SBOLD(item.first) << "\n";
                        }
                }
                cout << "\n";
        }
 
        if (!lib_errors.empty()) {
                ret = false;
                col() << SBOLD(SRED("Errors:")) << "\n";
                for (auto && item : lib_errors) {
                        cout << "\t" << SRED(item.first) << "\n\t\t" << item.second << "\n";
                }
                cout << "\n";
        }
 
        return ret;
}

References get_libmap(), lib_errors, library_class_info, SBOLD, and SRED.

Referenced by parse_global_opts(), and parse_options_internal().

Here is the call graph for this function:

list_modules()

void list_modules	(	enum library_class	cls,
		int	abi_version,
		bool	full )

Prints list of modules of given class

Parameters

full	include hidden modules

Definition at line 298 of file lib_common.cpp.

                                                                      {
        const auto & class_set = get_libraries_for_class(cls, abi_version, full);
        for (auto && item : class_set) {
                col() << "\t" << SBOLD(item.first.c_str()) << "\n";
        }
}

References cls, get_libraries_for_class(), and SBOLD.

Referenced by audio_capture_print_help(), audio_playback_help(), capture_filter_init(), video_rxtx::list(), list_video_capture_devices(), list_video_display_devices(), show_compress_help(), and show_vo_postprocess_help().

Here is the call graph for this function:

load_library()

const void * load_library	(	const char *	name,
		enum library_class	cls,
		int	abi_version )

Definition at line 259 of file lib_common.cpp.

{
        auto it_cls = get_libmap().find(cls);
        if (it_cls != get_libmap().end()) {
                auto it_module = it_cls->second.find(name);
                if (it_module != it_cls->second.end()) {
                        const auto& mod_pair = it_module->second;
                        if (mod_pair.abi_version == abi_version) {
                                return mod_pair.data;
                        } else {
                                LOG(LOG_LEVEL_WARNING) << "Module " << name << " ABI version mismatch (required " <<
                                        abi_version << ", have " << mod_pair.abi_version << ")\n";
                        }
                }
        }
 
        // Library was not found or was not loaded due to unsatisfied
        // dependencies. If the latter one, display reason why dlopen() failed.
        if (library_class_info.find(cls) != library_class_info.end()) {
                string filename = "ultragrid_";
                if (strlen(library_class_info.at(cls).file_prefix) > 0) {
                        filename += library_class_info.at(cls).file_prefix;
                        filename += "_";
                }
 
                filename += name + string(".so");
 
                if (lib_errors.find(filename) != lib_errors.end()) {
                        LOG(LOG_LEVEL_WARNING) << filename << ": " << lib_errors.find(filename)->second << "\n";
                }
        }
 
        return NULL;
}

References cls, get_libmap(), lib_errors, library_class_info, LOG, LOG_LEVEL_WARNING, and name.

Referenced by adjust_params(), audio_capture_init(), audio_decoder_init(), audio_playback_init(), video_rxtx::create(), video_rxtx::get_long_name(), init(), ldgm::init(), initialize_video_capture(), initialize_video_display(), tx_init(), and video_decoder_init().

Here is the call graph for this function:

open_all()

void open_all	(	const char *	pattern,
		list< void * > &	libs )

Definition at line 176 of file lib_common.cpp.

                                                       {
#ifdef BUILD_LIBRARIES
        char path[512];
        glob_t glob_buf;
 
        /* binary not from $PATH */
        if (!running_from_path(uv_argv)) {
                char *tmp = strdup(uv_argv[0]);
                char *dir = dirname(tmp);
                snprintf(path, sizeof(path), "%s/../lib/ultragrid/%s", dir, pattern);
                free(tmp);
        } else {
                snprintf(path, sizeof(path), LIB_DIR "/ultragrid/%s", pattern);
        }
 
        glob(path, 0, NULL, &glob_buf);
 
        for(unsigned int i = 0; i < glob_buf.gl_pathc; ++i) {
                void *handle = dlopen(glob_buf.gl_pathv[i], RTLD_NOW|RTLD_GLOBAL);
                if (!handle) {
                        char *error = dlerror();
                        MSG(WARNING, "Library %s opening warning: %s \n",
                            glob_buf.gl_pathv[i], error);
                        char *filename = basename(glob_buf.gl_pathv[i]);
                        if (filename && error) {
                                lib_errors.emplace(filename, error);
                        }
                        continue;
                }
                libs.push_back(handle);
        }
 
        globfree(&glob_buf);
#else
        UNUSED(libs);
        UNUSED(pattern);
#endif
}

References lib_errors, MSG, UNUSED, and uv_argv.

Referenced by common_preinit().

register_library()

void register_library	(	const char *	name,
		const void *	data,
		enum library_class	cls,
		int	abi_version,
		int	hidden )

Definition at line 250 of file lib_common.cpp.

{
        auto& map = get_libmap()[cls];
        if (map.find(name) != map.end()) {
                LOG(LOG_LEVEL_ERROR) << "Module \"" << name << "\" (class " << cls << ") multiple initialization!\n";
        }
        map[name] = {data, abi_version, static_cast<bool>(hidden)};
}

References cls, get_libmap(), LOG, LOG_LEVEL_ERROR, and name.

Here is the call graph for this function:

Variable Documentation

lib_errors

map<string, string> lib_errors

static

Definition at line 81 of file lib_common.cpp.

Referenced by list_all_modules(), load_library(), and open_all().

library_class_info

const map<enum library_class, library_class_info_t> library_class_info

Initial value:

= {
        { LIBRARY_CLASS_UNDEFINED, { "General module", "" }},
        { LIBRARY_CLASS_CAPTURE_FILTER, { "Video capture filter" , "vcapfilter" }},
        { LIBRARY_CLASS_AUDIO_CAPTURE, { "Audio capture device", "acap" }},
        { LIBRARY_CLASS_AUDIO_PLAYBACK, { "Audio playback device", "aplay" }},
        { LIBRARY_CLASS_VIDEO_CAPTURE, { "Video capture device", "vidcap" }},
        { LIBRARY_CLASS_VIDEO_DISPLAY, { "Video display device", "display" }},
        { LIBRARY_CLASS_AUDIO_COMPRESS, { "Audio compression", "acompress" }},
        { LIBRARY_CLASS_VIDEO_DECOMPRESS, { "Video decompression", "vdecompress" }},
        { LIBRARY_CLASS_VIDEO_COMPRESS, { "Video compression", "vcompress" }},
        { LIBRARY_CLASS_VIDEO_POSTPROCESS, { "Video postprocess", "vo_pp" }},
        { LIBRARY_CLASS_VIDEO_RXTX, { "Video RXTX", "video_rxtx" }},
}

Definition at line 67 of file lib_common.cpp.

                                                                         {
        { LIBRARY_CLASS_UNDEFINED, { "General module", "" }},
        { LIBRARY_CLASS_CAPTURE_FILTER, { "Video capture filter" , "vcapfilter" }},
        { LIBRARY_CLASS_AUDIO_CAPTURE, { "Audio capture device", "acap" }},
        { LIBRARY_CLASS_AUDIO_PLAYBACK, { "Audio playback device", "aplay" }},
        { LIBRARY_CLASS_VIDEO_CAPTURE, { "Video capture device", "vidcap" }},
        { LIBRARY_CLASS_VIDEO_DISPLAY, { "Video display device", "display" }},
        { LIBRARY_CLASS_AUDIO_COMPRESS, { "Audio compression", "acompress" }},
        { LIBRARY_CLASS_VIDEO_DECOMPRESS, { "Video decompression", "vdecompress" }},
        { LIBRARY_CLASS_VIDEO_COMPRESS, { "Video compression", "vcompress" }},
        { LIBRARY_CLASS_VIDEO_POSTPROCESS, { "Video postprocess", "vo_pp" }},
        { LIBRARY_CLASS_VIDEO_RXTX, { "Video RXTX", "video_rxtx" }},
};

Referenced by list_all_modules(), and load_library().