static int32_t minpf_post_load_plugin(const char* pluginPath, minpf_post_load_func postLoadFunc)
{
minpf_plugin_manager* mgr = minpf_get_plugin_manager();
minpf_exit_func exitFunc = postLoadFunc(pluginPath, &mgr->platformServices);
if (!exitFunc)
return -1;
mgr->exit_functions[mgr->num_exit_functions++] = exitFunc;
return 0;
}
void OPJ_CALLCONV opj_plugin_stop_batch_decode(void)
{
minpf_plugin_manager* mgr = NULL;
PLUGIN_STOP_BATCH_DECODE func = NULL;
if (!pluginInitialized)
return;
mgr = minpf_get_plugin_manager();
if (mgr && mgr->num_libraries > 0) {
func = (PLUGIN_STOP_BATCH_DECODE)minpf_get_symbol(mgr->dynamic_libraries[0], plugin_stop_batch_decode_method_name);
if (func) {
func();
}
}
}
int32_t minpf_load_from_path(const char* path, minpf_invoke_service_func func)
{
minpf_plugin_manager* mgr = minpf_get_plugin_manager();
if (!path || path[0] == '\0') // Check that the path is non-empty.
return -1;
mgr->platformServices.invokeService = func;
int32_t rc = minpf_load(path);
if (rc) {
fprintf(stderr, "Unable to open library %s\n", path);
}
return rc;
}
uint32_t OPJ_CALLCONV opj_plugin_get_debug_state()
{
minpf_plugin_manager* mgr = NULL;
PLUGIN_GET_DEBUG_STATE func = NULL;
uint32_t rc = OPJ_PLUGIN_STATE_NO_DEBUG;
if (!pluginInitialized)
return rc;
mgr = minpf_get_plugin_manager();
if (mgr && mgr->num_libraries > 0) {
func = (PLUGIN_GET_DEBUG_STATE)minpf_get_symbol(mgr->dynamic_libraries[0], plugin_get_debug_state_method_name);
if (func) {
rc = func();
}
}
return rc;
}
int32_t OPJ_CALLCONV opj_plugin_encode(opj_cparameters_t* encode_parameters,
OPJ_PLUGIN_ENCODE_USER_CALLBACK callback)
{
minpf_plugin_manager* mgr = NULL;
PLUGIN_ENCODE func = NULL;
if (!pluginInitialized)
return -1;
userEncodeCallback = callback;
mgr = minpf_get_plugin_manager();
if (mgr && mgr->num_libraries > 0) {
func = (PLUGIN_ENCODE)minpf_get_symbol(mgr->dynamic_libraries[0], plugin_encode_method_name);
if (func) {
return func((opj_cparameters_t*)encode_parameters, opj_plugin_internal_encode_callback);
}
}
return -1;
}
int32_t OPJ_CALLCONV opj_plugin_decode(opj_decompress_parameters* decode_parameters,
opj_plugin_decode_callback preDecode,
opj_plugin_decode_callback postDecode)
{
minpf_plugin_manager* mgr = NULL;
PLUGIN_DECODE func = NULL;
if (!pluginInitialized)
return -1;
userPreDecodeCallback = preDecode;
userPostDecodeCallback = postDecode;
mgr = minpf_get_plugin_manager();
func = NULL;
if (mgr && mgr->num_libraries > 0) {
func = (PLUGIN_DECODE)minpf_get_symbol(mgr->dynamic_libraries[0], plugin_decode_method_name);
if (func) {
return func((opj_decompress_parameters*)decode_parameters, opj_plugin_internal_decode_callback);
}
}
return -1;
}
static int32_t minpf_load(const char* path)
{
minpf_post_load_func postLoadFunc = NULL;
minpf_dynamic_library* lib = NULL;
int32_t res = 0;
minpf_plugin_manager* mgr = minpf_get_plugin_manager();
if (!mgr || mgr->num_libraries == MINPF_MAX_PLUGINS) {
return -1;
}
lib = minpf_load_dynamic_library(path, NULL);
if (!lib) {
return -1;
}
printf("Plugin %s successfully loaded\n", path);
postLoadFunc = (minpf_post_load_func)(minpf_get_symbol(lib, "minpf_post_load_plugin"));
if (!postLoadFunc) {
free(lib);
return -1;
}
char fullPath[4096];
if (minpf_get_full_path(path, (void*)postLoadFunc, lib->handle, fullPath, 4096)) {
printf("Full library path: %s\n", fullPath);
}
else {
return -1;
}
mgr->dynamic_libraries[mgr->num_libraries++] = lib;
auto rc = minpf_post_load_plugin(fullPath, postLoadFunc);
if (rc)
fprintf(stderr, "Plugin %s failed to initialize \n", path);
else
fprintf(stdout, "Plugin %s successfully initialized \n", path);
return rc;
}
int32_t minpf_load_from_dir(const char* directory_path, minpf_invoke_service_func func)
{
DIR *dir;
struct dirent* content;
char libraryPath[MINPF_MAX_PATH_LEN];
minpf_plugin_manager* mgr = minpf_get_plugin_manager();
if (!directory_path || directory_path[0] == '\0') // Check that the path is non-empty.
return -1;
mgr->platformServices.invokeService = func;
dir= opendir(directory_path);
if(!dir) {
fprintf(stderr,"Unable to open folder %s\n",directory_path);
return -1;
}
int32_t rc = -1;
while((content=readdir(dir))!=NULL) {
if(strcmp(".",content->d_name)==0 || strcmp("..",content->d_name)==0 )
continue;
//ignore files with incorrect extensions
if ( strcmp(get_filename_ext(content->d_name), minpf_get_dynamic_library_extension()) != 0)
continue;
strcpy(libraryPath, directory_path);
strcat(libraryPath, MINPF_FILE_SEPARATOR);
strcat(libraryPath, content->d_name);
if (minpf_load(libraryPath) != 0)
continue;
rc = 0;
}
auto dir_rc = closedir(dir);
return rc || dir_rc;
}
int32_t minpf_register_object(const char * id, const minpf_register_params * params)
{
int error;
minpf_plugin_api_version v;
minpf_register_params* existing_plugin_params;
minpf_plugin_manager* pluginManager = minpf_get_plugin_manager();
minpf_register_params* registered_params = NULL;
if (!id || id[0] == '\0' || !params)
return -1;
if (!minpf_is_valid_plugin(id, params))
return -1;
v = pluginManager->platformServices.version;
if (v.major != params->version.major)
return -1;
// check if plugin is already registered
existing_plugin_params = (minpf_register_params*)malloc(sizeof(minpf_register_params));
error = hashmap_get(pluginManager->plugins, id, (void**)(&existing_plugin_params));
free(existing_plugin_params);
existing_plugin_params = NULL;
if (error != MAP_MISSING)
return 0;
registered_params = (minpf_register_params*)malloc(sizeof(minpf_register_params));
if (!registered_params)
return -1;
*registered_params = *params;
error = hashmap_put(pluginManager->plugins, id, registered_params);
return (error==MAP_OK) ? 0 : -1;
}
