2013-09-30 19:37:13 -07:00
|
|
|
/******************************************************************************
|
|
|
|
|
Copyright (C) 2013 by Hugh Bailey <obs.jim@gmail.com>
|
|
|
|
|
|
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
2013-12-02 21:24:38 -08:00
|
|
|
the Free Software Foundation, either version 2 of the License, or
|
2013-09-30 19:37:13 -07:00
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
|
|
#include "util/platform.h"
|
|
|
|
|
#include "util/dstr.h"
|
|
|
|
|
|
|
|
|
|
#include "obs-defs.h"
|
2014-01-26 17:48:14 -08:00
|
|
|
#include "obs-internal.h"
|
2013-09-30 19:37:13 -07:00
|
|
|
#include "obs-module.h"
|
|
|
|
|
|
Revamp API and start using doxygen
The API used to be designed in such a way to where it would expect
exports for each individual source/output/encoder/etc. You would export
functions for each and it would automatically load those functions based
on a specific naming scheme from the module.
The idea behind this was that I wanted to limit the usage of structures
in the API so only functions could be used. It was an interesting idea
in theory, but this idea turned out to be flawed in a number of ways:
1.) Requiring exports to create sources/outputs/encoders/etc meant that
you could not create them by any other means, which meant that
things like faruton's .net plugin would become difficult.
2.) Export function declarations could not be checked, therefore if you
created a function with the wrong parameters and parameter types,
the compiler wouldn't know how to check for that.
3.) Required overly complex load functions in libobs just to handle it.
It makes much more sense to just have a load function that you call
manually. Complexity is the bane of all good programs.
4.) It required that you have functions of specific names, which looked
and felt somewhat unsightly.
So, to fix these issues, I replaced it with a more commonly used API
scheme, seen commonly in places like kernels and typical C libraries
with abstraction. You simply create a structure that contains the
callback definitions, and you pass it to a function to register that
definition (such as obs_register_source), which you call in the
obs_module_load of the module.
It will also automatically check the structure size and ensure that it
only loads the required values if the structure happened to add new
values in an API change.
The "main" source file for each module must include obs-module.h, and
must use OBS_DECLARE_MODULE() within that source file.
Also, started writing some doxygen documentation in to the main library
headers. Will add more detailed documentation as I go.
2014-02-12 07:04:50 -08:00
|
|
|
extern char *find_plugin(const char *plugin);
|
2013-09-30 19:37:13 -07:00
|
|
|
|
Revamp API and start using doxygen
The API used to be designed in such a way to where it would expect
exports for each individual source/output/encoder/etc. You would export
functions for each and it would automatically load those functions based
on a specific naming scheme from the module.
The idea behind this was that I wanted to limit the usage of structures
in the API so only functions could be used. It was an interesting idea
in theory, but this idea turned out to be flawed in a number of ways:
1.) Requiring exports to create sources/outputs/encoders/etc meant that
you could not create them by any other means, which meant that
things like faruton's .net plugin would become difficult.
2.) Export function declarations could not be checked, therefore if you
created a function with the wrong parameters and parameter types,
the compiler wouldn't know how to check for that.
3.) Required overly complex load functions in libobs just to handle it.
It makes much more sense to just have a load function that you call
manually. Complexity is the bane of all good programs.
4.) It required that you have functions of specific names, which looked
and felt somewhat unsightly.
So, to fix these issues, I replaced it with a more commonly used API
scheme, seen commonly in places like kernels and typical C libraries
with abstraction. You simply create a structure that contains the
callback definitions, and you pass it to a function to register that
definition (such as obs_register_source), which you call in the
obs_module_load of the module.
It will also automatically check the structure size and ensure that it
only loads the required values if the structure happened to add new
values in an API change.
The "main" source file for each module must include obs-module.h, and
must use OBS_DECLARE_MODULE() within that source file.
Also, started writing some doxygen documentation in to the main library
headers. Will add more detailed documentation as I go.
2014-02-12 07:04:50 -08:00
|
|
|
/* These variables get the current size of the info structures. Used to
|
|
|
|
|
* automatically prevent API breakage in case functions have to be added */
|
|
|
|
|
static size_t cur_source_info_size = 0;
|
|
|
|
|
static size_t cur_output_info_size = 0;
|
|
|
|
|
static size_t cur_encoder_info_size = 0;
|
|
|
|
|
static size_t cur_service_info_size = 0;
|
|
|
|
|
static size_t cur_modal_ui_size = 0;
|
|
|
|
|
static size_t cur_modeless_ui_size = 0;
|
2013-09-30 19:37:13 -07:00
|
|
|
|
Revamp API and start using doxygen
The API used to be designed in such a way to where it would expect
exports for each individual source/output/encoder/etc. You would export
functions for each and it would automatically load those functions based
on a specific naming scheme from the module.
The idea behind this was that I wanted to limit the usage of structures
in the API so only functions could be used. It was an interesting idea
in theory, but this idea turned out to be flawed in a number of ways:
1.) Requiring exports to create sources/outputs/encoders/etc meant that
you could not create them by any other means, which meant that
things like faruton's .net plugin would become difficult.
2.) Export function declarations could not be checked, therefore if you
created a function with the wrong parameters and parameter types,
the compiler wouldn't know how to check for that.
3.) Required overly complex load functions in libobs just to handle it.
It makes much more sense to just have a load function that you call
manually. Complexity is the bane of all good programs.
4.) It required that you have functions of specific names, which looked
and felt somewhat unsightly.
So, to fix these issues, I replaced it with a more commonly used API
scheme, seen commonly in places like kernels and typical C libraries
with abstraction. You simply create a structure that contains the
callback definitions, and you pass it to a function to register that
definition (such as obs_register_source), which you call in the
obs_module_load of the module.
It will also automatically check the structure size and ensure that it
only loads the required values if the structure happened to add new
values in an API change.
The "main" source file for each module must include obs-module.h, and
must use OBS_DECLARE_MODULE() within that source file.
Also, started writing some doxygen documentation in to the main library
headers. Will add more detailed documentation as I go.
2014-02-12 07:04:50 -08:00
|
|
|
static inline int req_func_not_found(const char *name, const char *path)
|
2014-01-31 23:49:50 -08:00
|
|
|
{
|
Revamp API and start using doxygen
The API used to be designed in such a way to where it would expect
exports for each individual source/output/encoder/etc. You would export
functions for each and it would automatically load those functions based
on a specific naming scheme from the module.
The idea behind this was that I wanted to limit the usage of structures
in the API so only functions could be used. It was an interesting idea
in theory, but this idea turned out to be flawed in a number of ways:
1.) Requiring exports to create sources/outputs/encoders/etc meant that
you could not create them by any other means, which meant that
things like faruton's .net plugin would become difficult.
2.) Export function declarations could not be checked, therefore if you
created a function with the wrong parameters and parameter types,
the compiler wouldn't know how to check for that.
3.) Required overly complex load functions in libobs just to handle it.
It makes much more sense to just have a load function that you call
manually. Complexity is the bane of all good programs.
4.) It required that you have functions of specific names, which looked
and felt somewhat unsightly.
So, to fix these issues, I replaced it with a more commonly used API
scheme, seen commonly in places like kernels and typical C libraries
with abstraction. You simply create a structure that contains the
callback definitions, and you pass it to a function to register that
definition (such as obs_register_source), which you call in the
obs_module_load of the module.
It will also automatically check the structure size and ensure that it
only loads the required values if the structure happened to add new
values in an API change.
The "main" source file for each module must include obs-module.h, and
must use OBS_DECLARE_MODULE() within that source file.
Also, started writing some doxygen documentation in to the main library
headers. Will add more detailed documentation as I go.
2014-02-12 07:04:50 -08:00
|
|
|
blog(LOG_WARNING, "Required module function '%s' in module '%s' not "
|
|
|
|
|
"found, loading of module failed",
|
|
|
|
|
name, path);
|
|
|
|
|
return MODULE_FUNCTION_NOT_FOUND;
|
2014-02-01 16:43:32 -08:00
|
|
|
}
|
2014-01-31 23:49:50 -08:00
|
|
|
|
Revamp API and start using doxygen
The API used to be designed in such a way to where it would expect
exports for each individual source/output/encoder/etc. You would export
functions for each and it would automatically load those functions based
on a specific naming scheme from the module.
The idea behind this was that I wanted to limit the usage of structures
in the API so only functions could be used. It was an interesting idea
in theory, but this idea turned out to be flawed in a number of ways:
1.) Requiring exports to create sources/outputs/encoders/etc meant that
you could not create them by any other means, which meant that
things like faruton's .net plugin would become difficult.
2.) Export function declarations could not be checked, therefore if you
created a function with the wrong parameters and parameter types,
the compiler wouldn't know how to check for that.
3.) Required overly complex load functions in libobs just to handle it.
It makes much more sense to just have a load function that you call
manually. Complexity is the bane of all good programs.
4.) It required that you have functions of specific names, which looked
and felt somewhat unsightly.
So, to fix these issues, I replaced it with a more commonly used API
scheme, seen commonly in places like kernels and typical C libraries
with abstraction. You simply create a structure that contains the
callback definitions, and you pass it to a function to register that
definition (such as obs_register_source), which you call in the
obs_module_load of the module.
It will also automatically check the structure size and ensure that it
only loads the required values if the structure happened to add new
values in an API change.
The "main" source file for each module must include obs-module.h, and
must use OBS_DECLARE_MODULE() within that source file.
Also, started writing some doxygen documentation in to the main library
headers. Will add more detailed documentation as I go.
2014-02-12 07:04:50 -08:00
|
|
|
#define LOAD_REQ_SIZE_FUNC(func, module, path) \
|
|
|
|
|
func = os_dlsym(module, #func); \
|
|
|
|
|
if (!func) \
|
|
|
|
|
return req_func_not_found(#func, path)
|
2013-11-01 14:33:00 -07:00
|
|
|
|
2013-11-13 05:24:20 -08:00
|
|
|
static int call_module_load(void *module, const char *path)
|
|
|
|
|
{
|
Revamp API and start using doxygen
The API used to be designed in such a way to where it would expect
exports for each individual source/output/encoder/etc. You would export
functions for each and it would automatically load those functions based
on a specific naming scheme from the module.
The idea behind this was that I wanted to limit the usage of structures
in the API so only functions could be used. It was an interesting idea
in theory, but this idea turned out to be flawed in a number of ways:
1.) Requiring exports to create sources/outputs/encoders/etc meant that
you could not create them by any other means, which meant that
things like faruton's .net plugin would become difficult.
2.) Export function declarations could not be checked, therefore if you
created a function with the wrong parameters and parameter types,
the compiler wouldn't know how to check for that.
3.) Required overly complex load functions in libobs just to handle it.
It makes much more sense to just have a load function that you call
manually. Complexity is the bane of all good programs.
4.) It required that you have functions of specific names, which looked
and felt somewhat unsightly.
So, to fix these issues, I replaced it with a more commonly used API
scheme, seen commonly in places like kernels and typical C libraries
with abstraction. You simply create a structure that contains the
callback definitions, and you pass it to a function to register that
definition (such as obs_register_source), which you call in the
obs_module_load of the module.
It will also automatically check the structure size and ensure that it
only loads the required values if the structure happened to add new
values in an API change.
The "main" source file for each module must include obs-module.h, and
must use OBS_DECLARE_MODULE() within that source file.
Also, started writing some doxygen documentation in to the main library
headers. Will add more detailed documentation as I go.
2014-02-12 07:04:50 -08:00
|
|
|
bool (*obs_module_load)(uint32_t obs_ver) = NULL;
|
|
|
|
|
size_t (*obs_module_source_info_size)(void) = NULL;
|
|
|
|
|
size_t (*obs_module_output_info_size)(void) = NULL;
|
|
|
|
|
size_t (*obs_module_encoder_info_size)(void) = NULL;
|
|
|
|
|
size_t (*obs_module_service_info_size)(void) = NULL;
|
|
|
|
|
size_t (*obs_module_modal_ui_size)(void) = NULL;
|
|
|
|
|
size_t (*obs_module_modeless_ui_size)(void) = NULL;
|
|
|
|
|
|
|
|
|
|
obs_module_load = os_dlsym(module, "obs_module_load");
|
|
|
|
|
if (!obs_module_load)
|
|
|
|
|
return req_func_not_found("obs_module_load", path);
|
|
|
|
|
|
|
|
|
|
LOAD_REQ_SIZE_FUNC(obs_module_source_info_size, module, path);
|
|
|
|
|
LOAD_REQ_SIZE_FUNC(obs_module_output_info_size, module, path);
|
|
|
|
|
LOAD_REQ_SIZE_FUNC(obs_module_encoder_info_size, module, path);
|
|
|
|
|
LOAD_REQ_SIZE_FUNC(obs_module_service_info_size, module, path);
|
|
|
|
|
LOAD_REQ_SIZE_FUNC(obs_module_modal_ui_size, module, path);
|
|
|
|
|
LOAD_REQ_SIZE_FUNC(obs_module_modeless_ui_size, module, path);
|
|
|
|
|
|
|
|
|
|
cur_source_info_size = obs_module_source_info_size();
|
|
|
|
|
cur_output_info_size = obs_module_output_info_size();
|
|
|
|
|
cur_encoder_info_size = obs_module_encoder_info_size();
|
|
|
|
|
cur_service_info_size = obs_module_service_info_size();
|
|
|
|
|
cur_modal_ui_size = obs_module_modal_ui_size();
|
|
|
|
|
cur_modeless_ui_size = obs_module_modeless_ui_size();
|
|
|
|
|
|
|
|
|
|
if (!obs_module_load(LIBOBS_API_VER)) {
|
2013-11-13 05:24:20 -08:00
|
|
|
blog(LOG_WARNING, "Module '%s' failed to load: "
|
Revamp API and start using doxygen
The API used to be designed in such a way to where it would expect
exports for each individual source/output/encoder/etc. You would export
functions for each and it would automatically load those functions based
on a specific naming scheme from the module.
The idea behind this was that I wanted to limit the usage of structures
in the API so only functions could be used. It was an interesting idea
in theory, but this idea turned out to be flawed in a number of ways:
1.) Requiring exports to create sources/outputs/encoders/etc meant that
you could not create them by any other means, which meant that
things like faruton's .net plugin would become difficult.
2.) Export function declarations could not be checked, therefore if you
created a function with the wrong parameters and parameter types,
the compiler wouldn't know how to check for that.
3.) Required overly complex load functions in libobs just to handle it.
It makes much more sense to just have a load function that you call
manually. Complexity is the bane of all good programs.
4.) It required that you have functions of specific names, which looked
and felt somewhat unsightly.
So, to fix these issues, I replaced it with a more commonly used API
scheme, seen commonly in places like kernels and typical C libraries
with abstraction. You simply create a structure that contains the
callback definitions, and you pass it to a function to register that
definition (such as obs_register_source), which you call in the
obs_module_load of the module.
It will also automatically check the structure size and ensure that it
only loads the required values if the structure happened to add new
values in an API change.
The "main" source file for each module must include obs-module.h, and
must use OBS_DECLARE_MODULE() within that source file.
Also, started writing some doxygen documentation in to the main library
headers. Will add more detailed documentation as I go.
2014-02-12 07:04:50 -08:00
|
|
|
"obs_module_load failed", path);
|
2013-11-13 05:24:20 -08:00
|
|
|
return MODULE_ERROR;
|
|
|
|
|
}
|
|
|
|
|
|
Revamp API and start using doxygen
The API used to be designed in such a way to where it would expect
exports for each individual source/output/encoder/etc. You would export
functions for each and it would automatically load those functions based
on a specific naming scheme from the module.
The idea behind this was that I wanted to limit the usage of structures
in the API so only functions could be used. It was an interesting idea
in theory, but this idea turned out to be flawed in a number of ways:
1.) Requiring exports to create sources/outputs/encoders/etc meant that
you could not create them by any other means, which meant that
things like faruton's .net plugin would become difficult.
2.) Export function declarations could not be checked, therefore if you
created a function with the wrong parameters and parameter types,
the compiler wouldn't know how to check for that.
3.) Required overly complex load functions in libobs just to handle it.
It makes much more sense to just have a load function that you call
manually. Complexity is the bane of all good programs.
4.) It required that you have functions of specific names, which looked
and felt somewhat unsightly.
So, to fix these issues, I replaced it with a more commonly used API
scheme, seen commonly in places like kernels and typical C libraries
with abstraction. You simply create a structure that contains the
callback definitions, and you pass it to a function to register that
definition (such as obs_register_source), which you call in the
obs_module_load of the module.
It will also automatically check the structure size and ensure that it
only loads the required values if the structure happened to add new
values in an API change.
The "main" source file for each module must include obs-module.h, and
must use OBS_DECLARE_MODULE() within that source file.
Also, started writing some doxygen documentation in to the main library
headers. Will add more detailed documentation as I go.
2014-02-12 07:04:50 -08:00
|
|
|
cur_source_info_size = 0;
|
|
|
|
|
cur_output_info_size = 0;
|
|
|
|
|
cur_encoder_info_size = 0;
|
|
|
|
|
cur_service_info_size = 0;
|
|
|
|
|
cur_modal_ui_size = 0;
|
|
|
|
|
cur_modeless_ui_size = 0;
|
|
|
|
|
|
2013-11-13 05:24:20 -08:00
|
|
|
return MODULE_SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-14 12:37:52 -07:00
|
|
|
int obs_load_module(const char *path)
|
2013-09-30 19:37:13 -07:00
|
|
|
{
|
|
|
|
|
struct obs_module mod;
|
2013-11-01 14:33:00 -07:00
|
|
|
char *plugin_path = find_plugin(path);
|
2013-11-13 05:24:20 -08:00
|
|
|
int errorcode;
|
2013-09-30 19:37:13 -07:00
|
|
|
|
2013-11-01 16:52:34 -07:00
|
|
|
mod.module = os_dlopen(plugin_path);
|
2013-11-01 14:33:00 -07:00
|
|
|
bfree(plugin_path);
|
2013-09-30 19:37:13 -07:00
|
|
|
if (!mod.module)
|
Revamp API and start using doxygen
The API used to be designed in such a way to where it would expect
exports for each individual source/output/encoder/etc. You would export
functions for each and it would automatically load those functions based
on a specific naming scheme from the module.
The idea behind this was that I wanted to limit the usage of structures
in the API so only functions could be used. It was an interesting idea
in theory, but this idea turned out to be flawed in a number of ways:
1.) Requiring exports to create sources/outputs/encoders/etc meant that
you could not create them by any other means, which meant that
things like faruton's .net plugin would become difficult.
2.) Export function declarations could not be checked, therefore if you
created a function with the wrong parameters and parameter types,
the compiler wouldn't know how to check for that.
3.) Required overly complex load functions in libobs just to handle it.
It makes much more sense to just have a load function that you call
manually. Complexity is the bane of all good programs.
4.) It required that you have functions of specific names, which looked
and felt somewhat unsightly.
So, to fix these issues, I replaced it with a more commonly used API
scheme, seen commonly in places like kernels and typical C libraries
with abstraction. You simply create a structure that contains the
callback definitions, and you pass it to a function to register that
definition (such as obs_register_source), which you call in the
obs_module_load of the module.
It will also automatically check the structure size and ensure that it
only loads the required values if the structure happened to add new
values in an API change.
The "main" source file for each module must include obs-module.h, and
must use OBS_DECLARE_MODULE() within that source file.
Also, started writing some doxygen documentation in to the main library
headers. Will add more detailed documentation as I go.
2014-02-12 07:04:50 -08:00
|
|
|
return MODULE_FILE_NOT_FOUND;
|
2013-09-30 19:37:13 -07:00
|
|
|
|
2013-11-13 05:24:20 -08:00
|
|
|
errorcode = call_module_load(mod.module, path);
|
|
|
|
|
if (errorcode != MODULE_SUCCESS) {
|
|
|
|
|
os_dlclose(mod.module);
|
|
|
|
|
return errorcode;
|
2013-09-30 19:37:13 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mod.name = bstrdup(path);
|
|
|
|
|
da_push_back(obs->modules, &mod);
|
|
|
|
|
return MODULE_SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void free_module(struct obs_module *mod)
|
|
|
|
|
{
|
|
|
|
|
if (!mod)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (mod->module) {
|
|
|
|
|
void (*module_unload)(void);
|
|
|
|
|
|
Revamp API and start using doxygen
The API used to be designed in such a way to where it would expect
exports for each individual source/output/encoder/etc. You would export
functions for each and it would automatically load those functions based
on a specific naming scheme from the module.
The idea behind this was that I wanted to limit the usage of structures
in the API so only functions could be used. It was an interesting idea
in theory, but this idea turned out to be flawed in a number of ways:
1.) Requiring exports to create sources/outputs/encoders/etc meant that
you could not create them by any other means, which meant that
things like faruton's .net plugin would become difficult.
2.) Export function declarations could not be checked, therefore if you
created a function with the wrong parameters and parameter types,
the compiler wouldn't know how to check for that.
3.) Required overly complex load functions in libobs just to handle it.
It makes much more sense to just have a load function that you call
manually. Complexity is the bane of all good programs.
4.) It required that you have functions of specific names, which looked
and felt somewhat unsightly.
So, to fix these issues, I replaced it with a more commonly used API
scheme, seen commonly in places like kernels and typical C libraries
with abstraction. You simply create a structure that contains the
callback definitions, and you pass it to a function to register that
definition (such as obs_register_source), which you call in the
obs_module_load of the module.
It will also automatically check the structure size and ensure that it
only loads the required values if the structure happened to add new
values in an API change.
The "main" source file for each module must include obs-module.h, and
must use OBS_DECLARE_MODULE() within that source file.
Also, started writing some doxygen documentation in to the main library
headers. Will add more detailed documentation as I go.
2014-02-12 07:04:50 -08:00
|
|
|
module_unload = os_dlsym(mod->module, "module_unload");
|
2013-09-30 19:37:13 -07:00
|
|
|
if (module_unload)
|
|
|
|
|
module_unload();
|
|
|
|
|
|
|
|
|
|
os_dlclose(mod->module);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bfree(mod->name);
|
|
|
|
|
}
|
Revamp API and start using doxygen
The API used to be designed in such a way to where it would expect
exports for each individual source/output/encoder/etc. You would export
functions for each and it would automatically load those functions based
on a specific naming scheme from the module.
The idea behind this was that I wanted to limit the usage of structures
in the API so only functions could be used. It was an interesting idea
in theory, but this idea turned out to be flawed in a number of ways:
1.) Requiring exports to create sources/outputs/encoders/etc meant that
you could not create them by any other means, which meant that
things like faruton's .net plugin would become difficult.
2.) Export function declarations could not be checked, therefore if you
created a function with the wrong parameters and parameter types,
the compiler wouldn't know how to check for that.
3.) Required overly complex load functions in libobs just to handle it.
It makes much more sense to just have a load function that you call
manually. Complexity is the bane of all good programs.
4.) It required that you have functions of specific names, which looked
and felt somewhat unsightly.
So, to fix these issues, I replaced it with a more commonly used API
scheme, seen commonly in places like kernels and typical C libraries
with abstraction. You simply create a structure that contains the
callback definitions, and you pass it to a function to register that
definition (such as obs_register_source), which you call in the
obs_module_load of the module.
It will also automatically check the structure size and ensure that it
only loads the required values if the structure happened to add new
values in an API change.
The "main" source file for each module must include obs-module.h, and
must use OBS_DECLARE_MODULE() within that source file.
Also, started writing some doxygen documentation in to the main library
headers. Will add more detailed documentation as I go.
2014-02-12 07:04:50 -08:00
|
|
|
|
|
|
|
|
void obs_register_source(const struct obs_source_info *info)
|
|
|
|
|
{
|
|
|
|
|
struct obs_source_info data = {0};
|
|
|
|
|
struct darray *array;
|
|
|
|
|
|
|
|
|
|
if (!cur_source_info_size) {
|
|
|
|
|
blog(LOG_WARNING, "Tried to register obs_source_info"
|
|
|
|
|
" outside of obs_module_load");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
memcpy(&data, info, cur_source_info_size);
|
|
|
|
|
|
|
|
|
|
if (info->type == OBS_SOURCE_TYPE_INPUT) {
|
|
|
|
|
array = &obs->input_types.da;
|
|
|
|
|
} else if (info->type == OBS_SOURCE_TYPE_FILTER) {
|
|
|
|
|
array = &obs->filter_types.da;
|
|
|
|
|
} else if (info->type == OBS_SOURCE_TYPE_TRANSITION) {
|
|
|
|
|
array = &obs->transition_types.da;
|
|
|
|
|
} else {
|
|
|
|
|
blog(LOG_WARNING, "Tried to register unknown source type: %u",
|
|
|
|
|
info->type);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
darray_push_back(sizeof(struct obs_source_info), array, &data);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define REGISTER_OBS_DEF(size_var, structure, dest, info) \
|
|
|
|
|
do { \
|
|
|
|
|
struct structure data = {0}; \
|
|
|
|
|
if (!size_var) { \
|
|
|
|
|
blog(LOG_WARNING, "Tried to register " #structure \
|
|
|
|
|
" outside of obs_module_load"); \
|
|
|
|
|
return; \
|
|
|
|
|
} \
|
|
|
|
|
\
|
|
|
|
|
memcpy(&data, info, size_var); \
|
|
|
|
|
da_push_back(dest, &data); \
|
|
|
|
|
} while (false)
|
|
|
|
|
|
|
|
|
|
#define CHECK_REQUIRED_VAL(info, val, func) \
|
|
|
|
|
do { \
|
|
|
|
|
if (!info->val) {\
|
|
|
|
|
blog(LOG_WARNING, "Required value '" #val " for" \
|
|
|
|
|
"'%s' not found. " #func \
|
|
|
|
|
" failed.", \
|
|
|
|
|
info->id);\
|
|
|
|
|
return; \
|
|
|
|
|
} \
|
|
|
|
|
} while (false)
|
|
|
|
|
|
|
|
|
|
void obs_register_output(const struct obs_output_info *info)
|
|
|
|
|
{
|
|
|
|
|
CHECK_REQUIRED_VAL(info, getname, obs_register_output);
|
|
|
|
|
CHECK_REQUIRED_VAL(info, create, obs_register_output);
|
|
|
|
|
CHECK_REQUIRED_VAL(info, destroy, obs_register_output);
|
|
|
|
|
CHECK_REQUIRED_VAL(info, start, obs_register_output);
|
|
|
|
|
CHECK_REQUIRED_VAL(info, stop, obs_register_output);
|
|
|
|
|
CHECK_REQUIRED_VAL(info, active, obs_register_output);
|
|
|
|
|
|
|
|
|
|
REGISTER_OBS_DEF(cur_output_info_size, obs_output_info,
|
|
|
|
|
obs->output_types, info);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void obs_register_encoder(const struct obs_encoder_info *info)
|
|
|
|
|
{
|
|
|
|
|
CHECK_REQUIRED_VAL(info, getname, obs_register_encoder);
|
|
|
|
|
CHECK_REQUIRED_VAL(info, create, obs_register_encoder);
|
|
|
|
|
CHECK_REQUIRED_VAL(info, destroy, obs_register_encoder);
|
|
|
|
|
CHECK_REQUIRED_VAL(info, reset, obs_register_encoder);
|
|
|
|
|
CHECK_REQUIRED_VAL(info, encode, obs_register_encoder);
|
|
|
|
|
CHECK_REQUIRED_VAL(info, getheader, obs_register_encoder);
|
|
|
|
|
|
|
|
|
|
REGISTER_OBS_DEF(cur_encoder_info_size, obs_encoder_info,
|
|
|
|
|
obs->encoder_types, info);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void obs_register_service(const struct obs_service_info *info)
|
|
|
|
|
{
|
|
|
|
|
CHECK_REQUIRED_VAL(info, getname, obs_register_service);
|
|
|
|
|
CHECK_REQUIRED_VAL(info, create, obs_register_service);
|
|
|
|
|
CHECK_REQUIRED_VAL(info, destroy, obs_register_service);
|
|
|
|
|
|
|
|
|
|
REGISTER_OBS_DEF(cur_service_info_size, obs_service_info,
|
|
|
|
|
obs->service_types, info);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void obs_regsiter_modal_ui(const struct obs_modal_ui *info)
|
|
|
|
|
{
|
|
|
|
|
CHECK_REQUIRED_VAL(info, task, obs_regsiter_modal_ui);
|
|
|
|
|
CHECK_REQUIRED_VAL(info, target, obs_regsiter_modal_ui);
|
|
|
|
|
CHECK_REQUIRED_VAL(info, exec, obs_regsiter_modal_ui);
|
|
|
|
|
|
|
|
|
|
REGISTER_OBS_DEF(cur_modal_ui_size, obs_modal_ui,
|
|
|
|
|
obs->modal_ui_callbacks, info);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void obs_regsiter_modeless_ui(const struct obs_modeless_ui *info)
|
|
|
|
|
{
|
|
|
|
|
CHECK_REQUIRED_VAL(info, task, obs_regsiter_modeless_ui);
|
|
|
|
|
CHECK_REQUIRED_VAL(info, target, obs_regsiter_modeless_ui);
|
|
|
|
|
CHECK_REQUIRED_VAL(info, create, obs_regsiter_modeless_ui);
|
|
|
|
|
|
|
|
|
|
REGISTER_OBS_DEF(cur_modeless_ui_size, obs_modeless_ui,
|
|
|
|
|
obs->modeless_ui_callbacks, info);
|
|
|
|
|
}
|
