jp9000
/
obs-studio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
obs-studio/libobs/obs-source.c

1914 lines
49 KiB
C
Raw Normal View History

first commit
2013-09-30 19:37:13 -07:00
/******************************************************************************
Fix video reset and apply new video settings This allows the changing of bideo settings without having to completely reset all graphics data. Will recreate internal output/conversion buffers and such and reset the main preview.
2014-02-22 19:14:19 -08:00
Copyright (C) 2013-2014 by Hugh Bailey <obs.jim@gmail.com>
first commit
2013-09-30 19:37:13 -07:00
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
With the permission of my fellow contributors, I'm switching obs-studio back to GPL v2+ to prevent issues between this project and the original OBS project, and for personal reasons to avoid legal ambiguity (not political reasons, I admittedly would prefer GPL v3+)
2013-12-02 21:24:38 -08:00
the Free Software Foundation, either version 2 of the License, or
first commit
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/>.
******************************************************************************/
Fix a some more linux/GCC specific warnings
2014-02-14 14:56:01 -08:00
#include <inttypes.h>
not sure how a backslash slipped into an include, but it's gone now
2013-10-29 23:54:43 -07:00
#include "media-io/format-conversion.h"
Implement automatic video scaling (if requested) Add a scaler interface (defaults to swscale), and if a separate output wants to use a different scale or format than the default output format, allow a scaler instance to be created automatically for that output, which will then receive the new scaled output.
2014-02-18 12:37:56 -08:00
#include "media-io/video-frame.h"
Added simple volume meter for reference of input levels.
2014-05-20 07:26:18 -07:00
#include "media-io/audio-io.h"
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
#include "util/threading.h"
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
#include "util/platform.h"
make sure to include function declarations from calldata.h
2013-12-30 09:09:20 -08:00
#include "callback/calldata.h"
changed gs_draw_sprite to allow custom sizes, added output textures to the core, and adjusted the test code to accommodate the changes
2013-11-26 21:26:14 -08:00
#include "graphics/matrix3.h"
#include "graphics/vec3.h"
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
first commit
2013-09-30 19:37:13 -07:00
#include "obs.h"
Rename obs-data.h to obs-internal.h Renaming obs-data.h to avoid confusion about its usage
2014-01-26 17:48:14 -08:00
#include "obs-internal.h"
first commit
2013-09-30 19:37:13 -07:00
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
static inline bool source_valid(struct obs_source *source)
{
return source && source->context.data;
}
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 const struct obs_source_info *find_source(struct darray *list,
add names to sources, use 'id' for the internal source identifier names rather than 'name'
2013-12-20 16:23:19 -08:00
const char *id)
first commit
2013-09-30 19:37:13 -07:00
{
size_t i;
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
struct obs_source_info *array = list->array;
first commit
2013-09-30 19:37:13 -07:00
for (i = 0; i < list->num; i++) {
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
struct obs_source_info *info = array+i;
add names to sources, use 'id' for the internal source identifier names rather than 'name'
2013-12-20 16:23:19 -08:00
if (strcmp(info->id, id) == 0)
first commit
2013-09-30 19:37:13 -07:00
return info;
}
return NULL;
}
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 const struct obs_source_info *get_source_info(enum obs_source_type type,
update API and implement preliminary ability to add sources to scenes
2013-12-30 05:56:39 -08:00
const char *id)
{
struct darray *list = NULL;
switch (type) {
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
case OBS_SOURCE_TYPE_INPUT:
list = &obs->input_types.da;
break;
case OBS_SOURCE_TYPE_FILTER:
list = &obs->filter_types.da;
break;
case OBS_SOURCE_TYPE_TRANSITION:
list = &obs->transition_types.da;
break;
update API and implement preliminary ability to add sources to scenes
2013-12-30 05:56:39 -08:00
}
return find_source(list, id);
}
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
static const char *source_signals[] = {
"void destroy(ptr source)",
"void add(ptr source)",
"void remove(ptr source)",
"void activate(ptr source)",
"void deactivate(ptr source)",
"void show(ptr source)",
"void hide(ptr source)",
"void volume(ptr source, in out float volume)",
libobs: Add level/magnitude/peak volume levels This replaces the older code which simply queried the max volume level value for any given audio. I'm still not 100% sure on if this is how I want to approach the problem, particularly, whether this should be done in obs_source or in audio_line, but it can always be moved later if needed. This uses the calculations by the awesome Bill Hamilton that OBS1 used for its volume levels. It calculates the current max (level), magnitude, and current peak. This data then can be used to create awesome volume meter controls later on. NOTE: Will probably need optimization, does one float at a time right now. Also, change some of the naming conventions. I actually need to change a lot of the naming conventions in general so that all words are separated by underscores. Kind of a bad practice there on my part.
2014-06-03 04:43:00 -07:00
"void volume_level(ptr source, float level, float magnitude, "
"float peak)",
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
NULL
};
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
bool obs_source_init_context(struct obs_source *source,
obs_data_t settings, const char *name)
implement signal/procedure handling into libobs and individual sources
2013-12-26 22:10:15 -08:00
{
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
if (!obs_context_data_init(&source->context, settings, name))
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
return false;
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
return signal_handler_add_array(source->context.signals,
source_signals);
implement signal/procedure handling into libobs and individual sources
2013-12-26 22:10:15 -08:00
}
update API and implement preliminary ability to add sources to scenes
2013-12-30 05:56:39 -08:00
const char *obs_source_getdisplayname(enum obs_source_type type,
const char *id, const char *locale)
{
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
const struct obs_source_info *info = get_source_info(type, id);
update API and implement preliminary ability to add sources to scenes
2013-12-30 05:56:39 -08:00
return (info != NULL) ? info->getname(locale) : NULL;
}
add support for texture_rect texture type in shaders, add new form, clear up a few things in the API
2013-12-20 10:56:01 -08:00
/* internal initialization */
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_source_init(struct obs_source *source,
const struct obs_source_info *info)
first commit
2013-09-30 19:37:13 -07:00
{
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
source->refs = 1;
Add more volume options Added a "master" volume for the entire audio subsystem. Also, added a "presentation" volume for both the master volume and for each invidiaul source. The presentation volume is used to control things like transitioning volumes, preventing sources from outputting any audio when they're inactive, as well as some other uses in the future.
2014-02-20 14:53:16 -08:00
source->user_volume = 1.0f;
Add (temporary terrible) volume controls - Add volume control These volume controls are basically nothing more than sliders. They look terrible and hopefully will be as temporary as they are terrible. - Allow saving of specific non-user sources via obs_load_source and obs_save_source functions. - Save data of desktop/mic audio sources (sync data, volume data, etc), and load the data on startup. - Make it so that a scene is created by default if first time using the application. On certain operating systems where supported, a default capture will be created. Desktop capture on mac, particularly. Not sure what to do about windows because monitor capture on windows 7 is completely terrible and is bad to start users off with.
2014-05-03 22:54:38 -07:00
source->present_volume = 0.0f;
Add source audio sync offset setting
2014-02-20 15:16:25 -08:00
source->sync_offset = 0;
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
pthread_mutex_init_value(&source->filter_mutex);
pthread_mutex_init_value(&source->video_mutex);
pthread_mutex_init_value(&source->audio_mutex);
Add a couple more setting data safety measures Prevent null dereferencing if data is null, instead just make the functions return and ignore the get/set requests.
2014-01-28 14:45:30 -08:00
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
if (pthread_mutex_init(&source->filter_mutex, NULL) != 0)
return false;
if (pthread_mutex_init(&source->audio_mutex, NULL) != 0)
return false;
if (pthread_mutex_init(&source->video_mutex, NULL) != 0)
return false;
first commit
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
if (info->output_flags & OBS_SOURCE_AUDIO) {
Add preliminary audio processing - Mixing still isn't implemented, but the audio system should be able to start up, and mix at least once audio line for the time being. Will have to write some test audio sources to verify things are working properly, and build the rest of the output functionality.
2014-01-09 18:08:20 -08:00
source->audio_line = audio_output_createline(obs->audio.audio,
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
source->context.name);
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
if (!source->audio_line) {
blog(LOG_ERROR, "Failed to create audio line for "
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
"source '%s'", source->context.name);
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
return false;
}
}
make data access in the threads a bit more safe (note: probably will need some more safety measures later on)
2013-10-18 20:25:13 -07:00
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
obs_context_data_insert(&source->context,
&obs->data.sources_mutex,
&obs->data.first_source);
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
return true;
first commit
2013-09-30 19:37:13 -07:00
}
fix a few bugs with callback system, add some test signals
2013-12-27 04:08:58 -08:00
static inline void obs_source_dosignal(struct obs_source *source,
Separate source activation for main/aux views Split off activate to activate and show callbacks, and split off deactivate to deactivate and hide callbacks. Sources didn't previously have a means to know whether it was actually being displayed in the main view or just happened to be visible somewhere. Now, for things like transition sources, they have a means of knowing when they have actually been "activated" so they can initiate their sequence. A source is now only considered "active" when it's being displayed by the main view. When a source is shown in the main view, the activate callback/signal is triggered. When it's no longer being displayed by the main view, deactivate callback/signal is triggered. When a source is just generally visible to see by any view, the show callback/signal is triggered. If it's no longer visible by any views, then the hide callback/signal is triggered. Presentation volume will now only be active when a source is active in the main view rather than also in auxilary views. Also fix a potential bug where parents wouldn't properly increment or decrement all the activation references of a child source when a child was added or removed.
2014-02-23 16:46:00 -08:00
const char *signal_obs, const char *signal_source)
fix a few bugs with callback system, add some test signals
2013-12-27 04:08:58 -08:00
{
struct calldata data;
calldata_init(&data);
calldata_setptr(&data, "source", source);
Separate source activation for main/aux views Split off activate to activate and show callbacks, and split off deactivate to deactivate and hide callbacks. Sources didn't previously have a means to know whether it was actually being displayed in the main view or just happened to be visible somewhere. Now, for things like transition sources, they have a means of knowing when they have actually been "activated" so they can initiate their sequence. A source is now only considered "active" when it's being displayed by the main view. When a source is shown in the main view, the activate callback/signal is triggered. When it's no longer being displayed by the main view, deactivate callback/signal is triggered. When a source is just generally visible to see by any view, the show callback/signal is triggered. If it's no longer visible by any views, then the hide callback/signal is triggered. Presentation volume will now only be active when a source is active in the main view rather than also in auxilary views. Also fix a potential bug where parents wouldn't properly increment or decrement all the activation references of a child source when a child was added or removed.
2014-02-23 16:46:00 -08:00
if (signal_obs)
signal_handler_signal(obs->signals, signal_obs, &data);
if (signal_source)
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
signal_handler_signal(source->context.signals, signal_source,
&data);
fix a few bugs with callback system, add some test signals
2013-12-27 04:08:58 -08:00
calldata_free(&data);
}
add names to sources, use 'id' for the internal source identifier names rather than 'name'
2013-12-20 16:23:19 -08:00
obs_source_t obs_source_create(enum obs_source_type type, const char *id,
Implement settings interface for plugins Add a fairly easy to use settings interface that can be passed to plugins, and replaced the old character string system that was being used before. The new data interface allows for an easier method of getting/altering settings for plugins, and is built to be serializable to/from JSON. Also, removed another wxFormBuilder file that was no longer in use.
2014-01-27 22:14:58 -08:00
const char *name, obs_data_t settings)
first commit
2013-09-30 19:37:13 -07:00
{
struct obs_source *source;
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
const struct obs_source_info *info = get_source_info(type, id);
first commit
2013-09-30 19:37:13 -07:00
if (!info) {
Be more consistent about log levels LOG_ERROR should be used in places where though recoverable (or at least something that can be handled safely), was unexpected, and may affect the user/application. LOG_WARNING should be used in places where it's not entirely unexpected, is recoverable, and doesn't really affect the user/application.
2014-02-28 19:02:29 -08:00
blog(LOG_ERROR, "Source '%s' not found", id);
first commit
2013-09-30 19:37:13 -07:00
return NULL;
}
libobs: Init source info before calling 'create' When a source's private data is being created by a module, it wasn't able to call most source functions because most functions rely on the obs_source_info part of the context to be set. This fixes that issue. It was strange that this wasn't already the case because the other context types already did the same thing.
2014-05-30 02:35:24 -07:00
source = bzalloc(sizeof(struct obs_source));
source->info = *info;
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
if (!obs_source_init_context(source, settings, name))
implement signal/procedure handling into libobs and individual sources
2013-12-26 22:10:15 -08:00
goto fail;
Set defaults automatically Automatically query defaults for sources/outputs/encoders and set them before calling create
2014-03-16 17:42:37 -07:00
if (info->defaults)
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
info->defaults(source->context.settings);
Improve safety for settings usage - Add 'set_default' functions to obs-data.*. These functions ensure that a paramter exists and that the parameter is of a specific type. If not, it will create or overwrite the value with the default setting instead. These functions are meant to be explicitly called before using any of the 'get' functions. The reason why it was designed this way is to encourage defaults to be set in a single place/function. For example, ideal usage is to create one function for your data, "set_my_defaults(obs_data_t data)", set all the default values within that function, and then call that function on create/update, that way all defaults are centralized to a single place. - Ensure that data passed to sources/encoders/outputs/etc is always valid, and not a null value. - While I'm remembering, fix a few defaults of the main program config file data.
2014-01-28 17:41:24 -08:00
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
/* allow the source to be created even if creation fails so that the
* user's data doesn't become lost */
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
source->context.data = info->create(source->context.settings, source);
if (!source->context.data)
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
blog(LOG_ERROR, "Failed to create source '%s'!", name);
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
Improve safety for settings usage - Add 'set_default' functions to obs-data.*. These functions ensure that a paramter exists and that the parameter is of a specific type. If not, it will create or overwrite the value with the default setting instead. These functions are meant to be explicitly called before using any of the 'get' functions. The reason why it was designed this way is to encourage defaults to be set in a single place/function. For example, ideal usage is to create one function for your data, "set_my_defaults(obs_data_t data)", set all the default values within that function, and then call that function on create/update, that way all defaults are centralized to a single place. - Ensure that data passed to sources/encoders/outputs/etc is always valid, and not a null value. - While I'm remembering, fix a few defaults of the main program config file data.
2014-01-28 17:41:24 -08:00
if (!obs_source_init(source, info))
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
goto fail;
first commit
2013-09-30 19:37:13 -07:00
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
obs_source_dosignal(source, "source_create", NULL);
first commit
2013-09-30 19:37:13 -07:00
return source;
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
fail:
blog(LOG_ERROR, "obs_source_create failed");
obs_source_destroy(source);
return NULL;
first commit
2013-09-30 19:37:13 -07:00
}
Implement automatic video scaling (if requested) Add a scaler interface (defaults to swscale), and if a separate output wants to use a different scale or format than the default output format, allow a scaler instance to be created automatically for that output, which will then receive the new scaled output.
2014-02-18 12:37:56 -08:00
void source_frame_init(struct source_frame *frame, enum video_format format,
uint32_t width, uint32_t height)
Add planar audio support, improve test output - Add planar audio support. FFmpeg and libav use planar audio for many encoders, so it was somewhat necessary to add support in libobs itself. - Improve/adjust FFmpeg test output plugin. The exports were somewhat messed up (making me rethink how exports should be done). Not yet functional; it handles video properly, but it still does not handle audio properly. - Improve planar video code. The planar video code was not properly accounting for row sizes for each plane. Specifying row sizes for each plane has now been added. This will also make it more compatible with FFmpeg/libav. - Fixed a bug where callbacks wouldn't create properly in audio-io and video-io code. - Implement 'blogva' function to allow for va_list usage with libobs logging.
2014-02-07 02:03:54 -08:00
{
Implement automatic video scaling (if requested) Add a scaler interface (defaults to swscale), and if a separate output wants to use a different scale or format than the default output format, allow a scaler instance to be created automatically for that output, which will then receive the new scaled output.
2014-02-18 12:37:56 -08:00
struct video_frame vid_frame;
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
if (!frame)
return;
Implement automatic video scaling (if requested) Add a scaler interface (defaults to swscale), and if a separate output wants to use a different scale or format than the default output format, allow a scaler instance to be created automatically for that output, which will then receive the new scaled output.
2014-02-18 12:37:56 -08:00
video_frame_init(&vid_frame, format, width, height);
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 04:51:06 -08:00
frame->format = format;
frame->width = width;
frame->height = height;
Add planar audio support, improve test output - Add planar audio support. FFmpeg and libav use planar audio for many encoders, so it was somewhat necessary to add support in libobs itself. - Improve/adjust FFmpeg test output plugin. The exports were somewhat messed up (making me rethink how exports should be done). Not yet functional; it handles video properly, but it still does not handle audio properly. - Improve planar video code. The planar video code was not properly accounting for row sizes for each plane. Specifying row sizes for each plane has now been added. This will also make it more compatible with FFmpeg/libav. - Fixed a bug where callbacks wouldn't create properly in audio-io and video-io code. - Implement 'blogva' function to allow for va_list usage with libobs logging.
2014-02-07 02:03:54 -08:00
Implement automatic video scaling (if requested) Add a scaler interface (defaults to swscale), and if a separate output wants to use a different scale or format than the default output format, allow a scaler instance to be created automatically for that output, which will then receive the new scaled output.
2014-02-18 12:37:56 -08:00
for (size_t i = 0; i < MAX_AV_PLANES; i++) {
frame->data[i] = vid_frame.data[i];
frame->linesize[i] = vid_frame.linesize[i];
Add planar audio support, improve test output - Add planar audio support. FFmpeg and libav use planar audio for many encoders, so it was somewhat necessary to add support in libobs itself. - Improve/adjust FFmpeg test output plugin. The exports were somewhat messed up (making me rethink how exports should be done). Not yet functional; it handles video properly, but it still does not handle audio properly. - Improve planar video code. The planar video code was not properly accounting for row sizes for each plane. Specifying row sizes for each plane has now been added. This will also make it more compatible with FFmpeg/libav. - Fixed a bug where callbacks wouldn't create properly in audio-io and video-io code. - Implement 'blogva' function to allow for va_list usage with libobs logging.
2014-02-07 02:03:54 -08:00
}
}
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
void obs_source_destroy(struct obs_source *source)
first commit
2013-09-30 19:37:13 -07:00
{
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
size_t i;
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
if (!source)
return;
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
obs_context_data_remove(&source->context);
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
obs_source_dosignal(source, "source_destroy", "destroy");
fix a few bugs with callback system, add some test signals
2013-12-27 04:08:58 -08:00
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (source->context.data) {
Fix an issue with async (video) source destruction obs_source_output_video can cause cached frames to be freed twice if called with a partially destroyed source, among other undesirable effects; freeing the source private data right after the destroy signal has been processed ensures proper behavior
2014-05-04 12:01:46 -07:00
source->info.destroy(source->context.data);
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
source->context.data = NULL;
}
Fix an issue with async (video) source destruction obs_source_output_video can cause cached frames to be freed twice if called with a partially destroyed source, among other undesirable effects; freeing the source private data right after the destroy signal has been processed ensures proper behavior
2014-05-04 12:01:46 -07:00
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
if (source->filter_parent)
obs_source_filter_remove(source->filter_parent, source);
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
for (i = 0; i < source->filters.num; i++)
obs_source_release(source->filters.array[i]);
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
for (i = 0; i < source->video_frames.num; i++)
source_frame_destroy(source->video_frames.array[i]);
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
gs_entercontext(obs->video.graphics);
Add async texrender to cleanup
2014-04-28 12:52:44 -07:00
texrender_destroy(source->async_convert_texrender);
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
texture_destroy(source->async_texture);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
gs_leavecontext();
first commit
2013-09-30 19:37:13 -07:00
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
for (i = 0; i < MAX_AV_PLANES; i++)
Add planar audio support, improve test output - Add planar audio support. FFmpeg and libav use planar audio for many encoders, so it was somewhat necessary to add support in libobs itself. - Improve/adjust FFmpeg test output plugin. The exports were somewhat messed up (making me rethink how exports should be done). Not yet functional; it handles video properly, but it still does not handle audio properly. - Improve planar video code. The planar video code was not properly accounting for row sizes for each plane. Specifying row sizes for each plane has now been added. This will also make it more compatible with FFmpeg/libav. - Fixed a bug where callbacks wouldn't create properly in audio-io and video-io code. - Implement 'blogva' function to allow for va_list usage with libobs logging.
2014-02-07 02:03:54 -08:00
bfree(source->audio_data.data[i]);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
audio_line_destroy(source->audio_line);
audio_resampler_destroy(source->resampler);
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
texrender_destroy(source->filter_texrender);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
da_free(source->video_frames);
da_free(source->filters);
pthread_mutex_destroy(&source->filter_mutex);
pthread_mutex_destroy(&source->audio_mutex);
pthread_mutex_destroy(&source->video_mutex);
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
obs_context_data_free(&source->context);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
bfree(source);
}
Remove external ref count visibility The returned ref count was never used and the returned value doesn't actually confer any meaning in a multithreaded environment
2014-02-02 17:34:06 -08:00
void obs_source_addref(obs_source_t source)
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
{
Remove external ref count visibility The returned ref count was never used and the returned value doesn't actually confer any meaning in a multithreaded environment
2014-02-02 17:34:06 -08:00
if (source)
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
os_atomic_inc_long(&source->refs);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
}
Remove external ref count visibility The returned ref count was never used and the returned value doesn't actually confer any meaning in a multithreaded environment
2014-02-02 17:34:06 -08:00
void obs_source_release(obs_source_t source)
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
{
Remove external ref count visibility The returned ref count was never used and the returned value doesn't actually confer any meaning in a multithreaded environment
2014-02-02 17:34:06 -08:00
if (!source)
return;
adjusted the way source removal is handled to make it a bit more safe
2013-11-20 17:36:46 -08:00
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
if (os_atomic_dec_long(&source->refs) == 0)
Remove external ref count visibility The returned ref count was never used and the returned value doesn't actually confer any meaning in a multithreaded environment
2014-02-02 17:34:06 -08:00
obs_source_destroy(source);
adjusted the way source removal is handled to make it a bit more safe
2013-11-20 17:36:46 -08:00
}
void obs_source_remove(obs_source_t source)
{
Improve naming scheme of libobs core structures
2014-02-05 20:03:06 -08:00
struct obs_core_data *data = &obs->data;
adjusted the way source removal is handled to make it a bit more safe
2013-11-20 17:36:46 -08:00
size_t id;
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
bool exists;
adjusted the way source removal is handled to make it a bit more safe
2013-11-20 17:36:46 -08:00
pthread_mutex_lock(&data->sources_mutex);
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
if (!source || source->removed) {
pthread_mutex_unlock(&data->sources_mutex);
Add module UI export capability Add the ability to be able to call and use toolkit-specific or program-specific user interface in modules. User interface code can be either bundled with the module, or 'split' out in to separate libraries (recommended). There are three reasons why splitting is recommended: 1.) It allows plugins to be able to create custom user interface for each toolkit if desired. 2.) Often, UI will be programmed in one language (the language of the toolkit), and core logic may be programmed in another. This allows plugins to keep the languages separated if necessary. 3.) It prevents direct linkage of UI toolkits libraries with core module logic. Splitting is not required, though is recommended if you want your plugin to be more flexible with other user interface toolkits or programs. Will implement a generic properties lookup next, which will be used for automatic UI handling so that plugin UI isn't necessarily required.
2014-01-31 23:49:50 -08:00
return;
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
}
Add module UI export capability Add the ability to be able to call and use toolkit-specific or program-specific user interface in modules. User interface code can be either bundled with the module, or 'split' out in to separate libraries (recommended). There are three reasons why splitting is recommended: 1.) It allows plugins to be able to create custom user interface for each toolkit if desired. 2.) Often, UI will be programmed in one language (the language of the toolkit), and core logic may be programmed in another. This allows plugins to keep the languages separated if necessary. 3.) It prevents direct linkage of UI toolkits libraries with core module logic. Splitting is not required, though is recommended if you want your plugin to be more flexible with other user interface toolkits or programs. Will implement a generic properties lookup next, which will be used for automatic UI handling so that plugin UI isn't necessarily required.
2014-01-31 23:49:50 -08:00
Improve thread safety in UI code - Implemented better C++ classes for handling scenes/sources/items in obs.hpp, allowing them to automatically increment and decrement the references of each, as well as assign them to QVariants. - Because QVariants are now using the C++ classes, remove the pointer QVariant wrapper. - Use the new C++ classes with the QVariant user data of list box items, both for the sake of thread safety and to ensure that the data referenced is not freed until removed. NOTE: still might need some testing. - Implemented a source-remove signal from libobs, and start using that signal instead of the source-destroy signal for signalling item removal.
2014-02-02 13:26:23 -08:00
source->removed = true;
Add module UI export capability Add the ability to be able to call and use toolkit-specific or program-specific user interface in modules. User interface code can be either bundled with the module, or 'split' out in to separate libraries (recommended). There are three reasons why splitting is recommended: 1.) It allows plugins to be able to create custom user interface for each toolkit if desired. 2.) Often, UI will be programmed in one language (the language of the toolkit), and core logic may be programmed in another. This allows plugins to keep the languages separated if necessary. 3.) It prevents direct linkage of UI toolkits libraries with core module logic. Splitting is not required, though is recommended if you want your plugin to be more flexible with other user interface toolkits or programs. Will implement a generic properties lookup next, which will be used for automatic UI handling so that plugin UI isn't necessarily required.
2014-01-31 23:49:50 -08:00
Improve thread safety in UI code - Implemented better C++ classes for handling scenes/sources/items in obs.hpp, allowing them to automatically increment and decrement the references of each, as well as assign them to QVariants. - Because QVariants are now using the C++ classes, remove the pointer QVariant wrapper. - Use the new C++ classes with the QVariant user data of list box items, both for the sake of thread safety and to ensure that the data referenced is not freed until removed. NOTE: still might need some testing. - Implemented a source-remove signal from libobs, and start using that signal instead of the source-destroy signal for signalling item removal.
2014-02-02 13:26:23 -08:00
obs_source_addref(source);
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
id = da_find(data->user_sources, &source, 0);
exists = (id != DARRAY_INVALID);
if (exists) {
da_erase(data->user_sources, id);
Improve thread safety in UI code - Implemented better C++ classes for handling scenes/sources/items in obs.hpp, allowing them to automatically increment and decrement the references of each, as well as assign them to QVariants. - Because QVariants are now using the C++ classes, remove the pointer QVariant wrapper. - Use the new C++ classes with the QVariant user data of list box items, both for the sake of thread safety and to ensure that the data referenced is not freed until removed. NOTE: still might need some testing. - Implemented a source-remove signal from libobs, and start using that signal instead of the source-destroy signal for signalling item removal.
2014-02-02 13:26:23 -08:00
obs_source_release(source);
adjusted the way source removal is handled to make it a bit more safe
2013-11-20 17:36:46 -08:00
}
pthread_mutex_unlock(&data->sources_mutex);
Improve thread safety in UI code - Implemented better C++ classes for handling scenes/sources/items in obs.hpp, allowing them to automatically increment and decrement the references of each, as well as assign them to QVariants. - Because QVariants are now using the C++ classes, remove the pointer QVariant wrapper. - Use the new C++ classes with the QVariant user data of list box items, both for the sake of thread safety and to ensure that the data referenced is not freed until removed. NOTE: still might need some testing. - Implemented a source-remove signal from libobs, and start using that signal instead of the source-destroy signal for signalling item removal.
2014-02-02 13:26:23 -08:00
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
if (exists)
obs_source_dosignal(source, "source_remove", "remove");
Improve thread safety in UI code - Implemented better C++ classes for handling scenes/sources/items in obs.hpp, allowing them to automatically increment and decrement the references of each, as well as assign them to QVariants. - Because QVariants are now using the C++ classes, remove the pointer QVariant wrapper. - Use the new C++ classes with the QVariant user data of list box items, both for the sake of thread safety and to ensure that the data referenced is not freed until removed. NOTE: still might need some testing. - Implemented a source-remove signal from libobs, and start using that signal instead of the source-destroy signal for signalling item removal.
2014-02-02 13:26:23 -08:00
obs_source_release(source);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
}
bool obs_source_removed(obs_source_t source)
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
return source ? source->removed : true;
first commit
2013-09-30 19:37:13 -07:00
}
Improve properties API Improve the properties API so that it can actually respond somewhat to user input. Maybe later this might be further improved or replaced with something script-based. When creating a property, you can now add a callback to that property that notifies when the property has been changed in the user interface. Return true if you want the properties to be refreshed, or false if not. Though now that I think about it I doubt there would ever be a case where you would have this callback and *not* refresh the properties. Regardless, this allows functions to change the values of properties or settings, or enable/disable/hide other property controls from view dynamically.
2014-04-04 00:30:37 -07:00
static inline obs_data_t get_defaults(const struct obs_source_info *info)
{
obs_data_t settings = obs_data_create();
if (info->defaults)
info->defaults(settings);
return settings;
}
Add a way to get default settings - Implement a means of obtaining default settings for an input/output/encoder. obs_source_defaults for example will return the default settings for a particular source type. - Because C++ doesn't have designated initializers, use functions in the WASAPI plugin to register the sources instead.
2014-03-07 05:55:21 -08:00
obs_data_t obs_source_settings(enum obs_source_type type, const char *id)
{
const struct obs_source_info *info = get_source_info(type, id);
Improve properties API Improve the properties API so that it can actually respond somewhat to user input. Maybe later this might be further improved or replaced with something script-based. When creating a property, you can now add a callback to that property that notifies when the property has been changed in the user interface. Return true if you want the properties to be refreshed, or false if not. Though now that I think about it I doubt there would ever be a case where you would have this callback and *not* refresh the properties. Regardless, this allows functions to change the values of properties or settings, or enable/disable/hide other property controls from view dynamically.
2014-04-04 00:30:37 -07:00
return (info) ? get_defaults(info) : NULL;
Add a way to get default settings - Implement a means of obtaining default settings for an input/output/encoder. obs_source_defaults for example will return the default settings for a particular source type. - Because C++ doesn't have designated initializers, use functions in the WASAPI plugin to register the sources instead.
2014-03-07 05:55:21 -08:00
}
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
obs_properties_t obs_get_source_properties(enum obs_source_type type,
Add property list callbacks - Add property list callbacks to sources/outputs/encoders so that if necessary user interface can be automatically generated or perhaps a property list widget can be used for them. - Change some of the property API names. obs_property_list_t felt a bit awkward when actually using it, so I just renamed it to obs_properties_t. - Removed the getdata/setdata nad getparam/setparam functions from sources/services, they will be superseded by the dynamic procedure call API.
2014-02-01 21:46:13 -08:00
const char *id, const char *locale)
{
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
const struct obs_source_info *info = get_source_info(type, id);
Improve properties API Improve the properties API so that it can actually respond somewhat to user input. Maybe later this might be further improved or replaced with something script-based. When creating a property, you can now add a callback to that property that notifies when the property has been changed in the user interface. Return true if you want the properties to be refreshed, or false if not. Though now that I think about it I doubt there would ever be a case where you would have this callback and *not* refresh the properties. Regardless, this allows functions to change the values of properties or settings, or enable/disable/hide other property controls from view dynamically.
2014-04-04 00:30:37 -07:00
if (info && info->properties) {
obs_data_t defaults = get_defaults(info);
obs_properties_t properties;
properties = info->properties(locale);
obs_properties_apply_settings(properties, defaults);
obs_data_release(defaults);
return properties;
}
Add property list callbacks - Add property list callbacks to sources/outputs/encoders so that if necessary user interface can be automatically generated or perhaps a property list widget can be used for them. - Change some of the property API names. obs_property_list_t felt a bit awkward when actually using it, so I just renamed it to obs_properties_t. - Removed the getdata/setdata nad getparam/setparam functions from sources/services, they will be superseded by the dynamic procedure call API.
2014-02-01 21:46:13 -08:00
return NULL;
}
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
obs_properties_t obs_source_properties(obs_source_t source, const char *locale)
{
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (source_valid(source) && source->info.properties) {
Improve properties API Improve the properties API so that it can actually respond somewhat to user input. Maybe later this might be further improved or replaced with something script-based. When creating a property, you can now add a callback to that property that notifies when the property has been changed in the user interface. Return true if you want the properties to be refreshed, or false if not. Though now that I think about it I doubt there would ever be a case where you would have this callback and *not* refresh the properties. Regardless, this allows functions to change the values of properties or settings, or enable/disable/hide other property controls from view dynamically.
2014-04-04 00:30:37 -07:00
obs_properties_t props;
props = source->info.properties(locale);
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
obs_properties_apply_settings(props, source->context.settings);
Improve properties API Improve the properties API so that it can actually respond somewhat to user input. Maybe later this might be further improved or replaced with something script-based. When creating a property, you can now add a callback to that property that notifies when the property has been changed in the user interface. Return true if you want the properties to be refreshed, or false if not. Though now that I think about it I doubt there would ever be a case where you would have this callback and *not* refresh the properties. Regardless, this allows functions to change the values of properties or settings, or enable/disable/hide other property controls from view dynamically.
2014-04-04 00:30:37 -07:00
return props;
}
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
return NULL;
}
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
uint32_t obs_source_get_output_flags(obs_source_t source)
first commit
2013-09-30 19:37:13 -07:00
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
return source ? source->info.output_flags : 0;
first commit
2013-09-30 19:37:13 -07:00
}
Implement RTMP module (still needs drop code) - Implement the RTMP output module. This time around, we just use a simple FLV muxer, then just write to the stream with RTMP_Write. Easy and effective. - Fix the FLV muxer, the muxer now outputs proper FLV packets. - Output API: * When using encoders, automatically interleave encoded packets before sending it to the output. * Pair encoders and have them automatically wait for the other to start to ensure sync. * Change 'obs_output_signal_start_fail' to 'obs_output_signal_stop' because it was a bit confusing, and doing this makes a lot more sense for outputs that need to stop suddenly (disconnections/etc). - Encoder API: * Remove some unnecessary encoder functions from the actual API and make them internal. Most of the encoder functions are handled automatically by outputs anyway, so there's no real need to expose them and end up inadvertently confusing plugin writers. * Have audio encoders wait for the video encoder to get a frame, then start at the exact data point that the first video frame starts to ensure the most accrate sync of video/audio possible. * Add a required 'frame_size' callback for audio encoders that returns the expected number of frames desired to encode with. This way, the libobs encoder API can handle the circular buffering internally automatically for the encoder modules, so encoder writers don't have to do it themselves. - Fix a few bugs in the serializer interface. It was passing the wrong variable for the data in a few cases. - If a source has video, make obs_source_update defer the actual update callback until the tick function is called to prevent threading issues.
2014-04-07 22:00:10 -07:00
static void obs_source_deferred_update(obs_source_t source)
{
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (source->context.data && source->info.update)
source->info.update(source->context.data,
source->context.settings);
Implement RTMP module (still needs drop code) - Implement the RTMP output module. This time around, we just use a simple FLV muxer, then just write to the stream with RTMP_Write. Easy and effective. - Fix the FLV muxer, the muxer now outputs proper FLV packets. - Output API: * When using encoders, automatically interleave encoded packets before sending it to the output. * Pair encoders and have them automatically wait for the other to start to ensure sync. * Change 'obs_output_signal_start_fail' to 'obs_output_signal_stop' because it was a bit confusing, and doing this makes a lot more sense for outputs that need to stop suddenly (disconnections/etc). - Encoder API: * Remove some unnecessary encoder functions from the actual API and make them internal. Most of the encoder functions are handled automatically by outputs anyway, so there's no real need to expose them and end up inadvertently confusing plugin writers. * Have audio encoders wait for the video encoder to get a frame, then start at the exact data point that the first video frame starts to ensure the most accrate sync of video/audio possible. * Add a required 'frame_size' callback for audio encoders that returns the expected number of frames desired to encode with. This way, the libobs encoder API can handle the circular buffering internally automatically for the encoder modules, so encoder writers don't have to do it themselves. - Fix a few bugs in the serializer interface. It was passing the wrong variable for the data in a few cases. - If a source has video, make obs_source_update defer the actual update callback until the tick function is called to prevent threading issues.
2014-04-07 22:00:10 -07:00
source->defer_update = false;
}
Implement settings interface for plugins Add a fairly easy to use settings interface that can be passed to plugins, and replaced the old character string system that was being used before. The new data interface allows for an easier method of getting/altering settings for plugins, and is built to be serializable to/from JSON. Also, removed another wxFormBuilder file that was no longer in use.
2014-01-27 22:14:58 -08:00
void obs_source_update(obs_source_t source, obs_data_t settings)
first commit
2013-09-30 19:37:13 -07:00
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
if (!source) return;
libobs: Allow deferred source udpate on create This allows sources to optionally defer update on creation in order to prevent updates from being called from threads other than the video thread.
2014-05-30 03:24:15 -07:00
if (settings)
obs_data_apply(source->context.settings, settings);
if (source->info.output_flags & OBS_SOURCE_VIDEO) {
source->defer_update = true;
} else if (source->context.data && source->info.update) {
source->info.update(source->context.data,
source->context.settings);
Implement RTMP module (still needs drop code) - Implement the RTMP output module. This time around, we just use a simple FLV muxer, then just write to the stream with RTMP_Write. Easy and effective. - Fix the FLV muxer, the muxer now outputs proper FLV packets. - Output API: * When using encoders, automatically interleave encoded packets before sending it to the output. * Pair encoders and have them automatically wait for the other to start to ensure sync. * Change 'obs_output_signal_start_fail' to 'obs_output_signal_stop' because it was a bit confusing, and doing this makes a lot more sense for outputs that need to stop suddenly (disconnections/etc). - Encoder API: * Remove some unnecessary encoder functions from the actual API and make them internal. Most of the encoder functions are handled automatically by outputs anyway, so there's no real need to expose them and end up inadvertently confusing plugin writers. * Have audio encoders wait for the video encoder to get a frame, then start at the exact data point that the first video frame starts to ensure the most accrate sync of video/audio possible. * Add a required 'frame_size' callback for audio encoders that returns the expected number of frames desired to encode with. This way, the libobs encoder API can handle the circular buffering internally automatically for the encoder modules, so encoder writers don't have to do it themselves. - Fix a few bugs in the serializer interface. It was passing the wrong variable for the data in a few cases. - If a source has video, make obs_source_update defer the actual update callback until the tick function is called to prevent threading issues.
2014-04-07 22:00:10 -07:00
}
first commit
2013-09-30 19:37:13 -07:00
}
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
static void activate_source(obs_source_t source)
first commit
2013-09-30 19:37:13 -07:00
{
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (source->context.data && source->info.activate)
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
source->info.activate(source->context.data);
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
obs_source_dosignal(source, "source_activate", "activate");
first commit
2013-09-30 19:37:13 -07:00
}
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
static void deactivate_source(obs_source_t source)
first commit
2013-09-30 19:37:13 -07:00
{
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (source->context.data && source->info.deactivate)
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
source->info.deactivate(source->context.data);
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
obs_source_dosignal(source, "source_deactivate", "deactivate");
Separate source activation for main/aux views Split off activate to activate and show callbacks, and split off deactivate to deactivate and hide callbacks. Sources didn't previously have a means to know whether it was actually being displayed in the main view or just happened to be visible somewhere. Now, for things like transition sources, they have a means of knowing when they have actually been "activated" so they can initiate their sequence. A source is now only considered "active" when it's being displayed by the main view. When a source is shown in the main view, the activate callback/signal is triggered. When it's no longer being displayed by the main view, deactivate callback/signal is triggered. When a source is just generally visible to see by any view, the show callback/signal is triggered. If it's no longer visible by any views, then the hide callback/signal is triggered. Presentation volume will now only be active when a source is active in the main view rather than also in auxilary views. Also fix a potential bug where parents wouldn't properly increment or decrement all the activation references of a child source when a child was added or removed.
2014-02-23 16:46:00 -08:00
}
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
Separate source activation for main/aux views Split off activate to activate and show callbacks, and split off deactivate to deactivate and hide callbacks. Sources didn't previously have a means to know whether it was actually being displayed in the main view or just happened to be visible somewhere. Now, for things like transition sources, they have a means of knowing when they have actually been "activated" so they can initiate their sequence. A source is now only considered "active" when it's being displayed by the main view. When a source is shown in the main view, the activate callback/signal is triggered. When it's no longer being displayed by the main view, deactivate callback/signal is triggered. When a source is just generally visible to see by any view, the show callback/signal is triggered. If it's no longer visible by any views, then the hide callback/signal is triggered. Presentation volume will now only be active when a source is active in the main view rather than also in auxilary views. Also fix a potential bug where parents wouldn't properly increment or decrement all the activation references of a child source when a child was added or removed.
2014-02-23 16:46:00 -08:00
static void show_source(obs_source_t source)
{
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (source->context.data && source->info.show)
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
source->info.show(source->context.data);
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
obs_source_dosignal(source, "source_show", "show");
Separate source activation for main/aux views Split off activate to activate and show callbacks, and split off deactivate to deactivate and hide callbacks. Sources didn't previously have a means to know whether it was actually being displayed in the main view or just happened to be visible somewhere. Now, for things like transition sources, they have a means of knowing when they have actually been "activated" so they can initiate their sequence. A source is now only considered "active" when it's being displayed by the main view. When a source is shown in the main view, the activate callback/signal is triggered. When it's no longer being displayed by the main view, deactivate callback/signal is triggered. When a source is just generally visible to see by any view, the show callback/signal is triggered. If it's no longer visible by any views, then the hide callback/signal is triggered. Presentation volume will now only be active when a source is active in the main view rather than also in auxilary views. Also fix a potential bug where parents wouldn't properly increment or decrement all the activation references of a child source when a child was added or removed.
2014-02-23 16:46:00 -08:00
}
static void hide_source(obs_source_t source)
{
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (source->context.data && source->info.hide)
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
source->info.hide(source->context.data);
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
obs_source_dosignal(source, "source_hide", "hide");
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
}
static void activate_tree(obs_source_t parent, obs_source_t child, void *param)
{
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
if (os_atomic_inc_long(&child->activate_refs) == 1)
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
activate_source(child);
Implement volume handling - Remove obs_source::type because it became redundant now that the type is always stored in the obs_source::info variable. - Apply presentation volumes of 1.0 and 0.0 to sources when they activate/deactivate, respectively. It also applies that presentation volume to all sub-sources, with exception of transition sources. Transition sources must apply presentation volume manually to their sub-sources with the new transition functions below. - Add a "transition_volume" variable to obs_source structure, and add three functions for handling volume for transitions: * obs_transition_begin_frame * obs_source_set_transition_vol * obs_transition_end_frame Because the to/from targets of a transition source might both contain some of the same sources, handling the transitioning of volumes for that specific situation becomes an issue. So for transitions, instead of modifying the presentation volumes directly for both sets of sources, we do this: - First, call obs_transition_begin_frame at the beginning of each transition frame, which will reset transition volumes for all sub-sources to 0. Presentation volumes remain unchanged. - Call obs_source_set_transition_vol on each sub-source, which will then add the volume to the transition volume for each source in that source's tree. Presentation volumes still remain unchanged. - Then you call obs_trandition_end_frame when complete, which will then finally set the presentation volumes to the transition volumes. For example, let's say that there's one source that's within both the "transitioning from" sources and "transition to" sources. It would add both the fade in and fade out volumes to that source, and then when the frame is complete, it would set the presentation volume to the sum of those two values, rather than set the presentation volume for that same source twice which would cause weird volume jittering and also set the wrong values.
2014-02-21 18:41:38 -08:00
UNUSED_PARAMETER(parent);
UNUSED_PARAMETER(param);
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
}
static void deactivate_tree(obs_source_t parent, obs_source_t child,
void *param)
{
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
if (os_atomic_dec_long(&child->activate_refs) == 0)
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
deactivate_source(child);
Implement volume handling - Remove obs_source::type because it became redundant now that the type is always stored in the obs_source::info variable. - Apply presentation volumes of 1.0 and 0.0 to sources when they activate/deactivate, respectively. It also applies that presentation volume to all sub-sources, with exception of transition sources. Transition sources must apply presentation volume manually to their sub-sources with the new transition functions below. - Add a "transition_volume" variable to obs_source structure, and add three functions for handling volume for transitions: * obs_transition_begin_frame * obs_source_set_transition_vol * obs_transition_end_frame Because the to/from targets of a transition source might both contain some of the same sources, handling the transitioning of volumes for that specific situation becomes an issue. So for transitions, instead of modifying the presentation volumes directly for both sets of sources, we do this: - First, call obs_transition_begin_frame at the beginning of each transition frame, which will reset transition volumes for all sub-sources to 0. Presentation volumes remain unchanged. - Call obs_source_set_transition_vol on each sub-source, which will then add the volume to the transition volume for each source in that source's tree. Presentation volumes still remain unchanged. - Then you call obs_trandition_end_frame when complete, which will then finally set the presentation volumes to the transition volumes. For example, let's say that there's one source that's within both the "transitioning from" sources and "transition to" sources. It would add both the fade in and fade out volumes to that source, and then when the frame is complete, it would set the presentation volume to the sum of those two values, rather than set the presentation volume for that same source twice which would cause weird volume jittering and also set the wrong values.
2014-02-21 18:41:38 -08:00
UNUSED_PARAMETER(parent);
UNUSED_PARAMETER(param);
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
}
Separate source activation for main/aux views Split off activate to activate and show callbacks, and split off deactivate to deactivate and hide callbacks. Sources didn't previously have a means to know whether it was actually being displayed in the main view or just happened to be visible somewhere. Now, for things like transition sources, they have a means of knowing when they have actually been "activated" so they can initiate their sequence. A source is now only considered "active" when it's being displayed by the main view. When a source is shown in the main view, the activate callback/signal is triggered. When it's no longer being displayed by the main view, deactivate callback/signal is triggered. When a source is just generally visible to see by any view, the show callback/signal is triggered. If it's no longer visible by any views, then the hide callback/signal is triggered. Presentation volume will now only be active when a source is active in the main view rather than also in auxilary views. Also fix a potential bug where parents wouldn't properly increment or decrement all the activation references of a child source when a child was added or removed.
2014-02-23 16:46:00 -08:00
static void show_tree(obs_source_t parent, obs_source_t child, void *param)
{
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
if (os_atomic_inc_long(&child->show_refs) == 1)
Separate source activation for main/aux views Split off activate to activate and show callbacks, and split off deactivate to deactivate and hide callbacks. Sources didn't previously have a means to know whether it was actually being displayed in the main view or just happened to be visible somewhere. Now, for things like transition sources, they have a means of knowing when they have actually been "activated" so they can initiate their sequence. A source is now only considered "active" when it's being displayed by the main view. When a source is shown in the main view, the activate callback/signal is triggered. When it's no longer being displayed by the main view, deactivate callback/signal is triggered. When a source is just generally visible to see by any view, the show callback/signal is triggered. If it's no longer visible by any views, then the hide callback/signal is triggered. Presentation volume will now only be active when a source is active in the main view rather than also in auxilary views. Also fix a potential bug where parents wouldn't properly increment or decrement all the activation references of a child source when a child was added or removed.
2014-02-23 16:46:00 -08:00
show_source(child);
UNUSED_PARAMETER(parent);
UNUSED_PARAMETER(param);
}
static void hide_tree(obs_source_t parent, obs_source_t child, void *param)
{
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
if (os_atomic_dec_long(&child->show_refs) == 0)
Separate source activation for main/aux views Split off activate to activate and show callbacks, and split off deactivate to deactivate and hide callbacks. Sources didn't previously have a means to know whether it was actually being displayed in the main view or just happened to be visible somewhere. Now, for things like transition sources, they have a means of knowing when they have actually been "activated" so they can initiate their sequence. A source is now only considered "active" when it's being displayed by the main view. When a source is shown in the main view, the activate callback/signal is triggered. When it's no longer being displayed by the main view, deactivate callback/signal is triggered. When a source is just generally visible to see by any view, the show callback/signal is triggered. If it's no longer visible by any views, then the hide callback/signal is triggered. Presentation volume will now only be active when a source is active in the main view rather than also in auxilary views. Also fix a potential bug where parents wouldn't properly increment or decrement all the activation references of a child source when a child was added or removed.
2014-02-23 16:46:00 -08:00
hide_source(child);
UNUSED_PARAMETER(parent);
UNUSED_PARAMETER(param);
}
void obs_source_activate(obs_source_t source, enum view_type type)
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
{
if (!source) return;
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
if (os_atomic_inc_long(&source->show_refs) == 1) {
Separate source activation for main/aux views Split off activate to activate and show callbacks, and split off deactivate to deactivate and hide callbacks. Sources didn't previously have a means to know whether it was actually being displayed in the main view or just happened to be visible somewhere. Now, for things like transition sources, they have a means of knowing when they have actually been "activated" so they can initiate their sequence. A source is now only considered "active" when it's being displayed by the main view. When a source is shown in the main view, the activate callback/signal is triggered. When it's no longer being displayed by the main view, deactivate callback/signal is triggered. When a source is just generally visible to see by any view, the show callback/signal is triggered. If it's no longer visible by any views, then the hide callback/signal is triggered. Presentation volume will now only be active when a source is active in the main view rather than also in auxilary views. Also fix a potential bug where parents wouldn't properly increment or decrement all the activation references of a child source when a child was added or removed.
2014-02-23 16:46:00 -08:00
show_source(source);
obs_source_enum_tree(source, show_tree, NULL);
}
if (type == MAIN_VIEW) {
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
if (os_atomic_inc_long(&source->activate_refs) == 1) {
Separate source activation for main/aux views Split off activate to activate and show callbacks, and split off deactivate to deactivate and hide callbacks. Sources didn't previously have a means to know whether it was actually being displayed in the main view or just happened to be visible somewhere. Now, for things like transition sources, they have a means of knowing when they have actually been "activated" so they can initiate their sequence. A source is now only considered "active" when it's being displayed by the main view. When a source is shown in the main view, the activate callback/signal is triggered. When it's no longer being displayed by the main view, deactivate callback/signal is triggered. When a source is just generally visible to see by any view, the show callback/signal is triggered. If it's no longer visible by any views, then the hide callback/signal is triggered. Presentation volume will now only be active when a source is active in the main view rather than also in auxilary views. Also fix a potential bug where parents wouldn't properly increment or decrement all the activation references of a child source when a child was added or removed.
2014-02-23 16:46:00 -08:00
activate_source(source);
obs_source_enum_tree(source, activate_tree, NULL);
obs_source_set_present_volume(source, 1.0f);
}
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
}
}
Separate source activation for main/aux views Split off activate to activate and show callbacks, and split off deactivate to deactivate and hide callbacks. Sources didn't previously have a means to know whether it was actually being displayed in the main view or just happened to be visible somewhere. Now, for things like transition sources, they have a means of knowing when they have actually been "activated" so they can initiate their sequence. A source is now only considered "active" when it's being displayed by the main view. When a source is shown in the main view, the activate callback/signal is triggered. When it's no longer being displayed by the main view, deactivate callback/signal is triggered. When a source is just generally visible to see by any view, the show callback/signal is triggered. If it's no longer visible by any views, then the hide callback/signal is triggered. Presentation volume will now only be active when a source is active in the main view rather than also in auxilary views. Also fix a potential bug where parents wouldn't properly increment or decrement all the activation references of a child source when a child was added or removed.
2014-02-23 16:46:00 -08:00
void obs_source_deactivate(obs_source_t source, enum view_type type)
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
{
if (!source) return;
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
if (os_atomic_dec_long(&source->show_refs) == 0) {
Separate source activation for main/aux views Split off activate to activate and show callbacks, and split off deactivate to deactivate and hide callbacks. Sources didn't previously have a means to know whether it was actually being displayed in the main view or just happened to be visible somewhere. Now, for things like transition sources, they have a means of knowing when they have actually been "activated" so they can initiate their sequence. A source is now only considered "active" when it's being displayed by the main view. When a source is shown in the main view, the activate callback/signal is triggered. When it's no longer being displayed by the main view, deactivate callback/signal is triggered. When a source is just generally visible to see by any view, the show callback/signal is triggered. If it's no longer visible by any views, then the hide callback/signal is triggered. Presentation volume will now only be active when a source is active in the main view rather than also in auxilary views. Also fix a potential bug where parents wouldn't properly increment or decrement all the activation references of a child source when a child was added or removed.
2014-02-23 16:46:00 -08:00
hide_source(source);
obs_source_enum_tree(source, hide_tree, NULL);
}
if (type == MAIN_VIEW) {
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
if (os_atomic_dec_long(&source->activate_refs) == 0) {
Separate source activation for main/aux views Split off activate to activate and show callbacks, and split off deactivate to deactivate and hide callbacks. Sources didn't previously have a means to know whether it was actually being displayed in the main view or just happened to be visible somewhere. Now, for things like transition sources, they have a means of knowing when they have actually been "activated" so they can initiate their sequence. A source is now only considered "active" when it's being displayed by the main view. When a source is shown in the main view, the activate callback/signal is triggered. When it's no longer being displayed by the main view, deactivate callback/signal is triggered. When a source is just generally visible to see by any view, the show callback/signal is triggered. If it's no longer visible by any views, then the hide callback/signal is triggered. Presentation volume will now only be active when a source is active in the main view rather than also in auxilary views. Also fix a potential bug where parents wouldn't properly increment or decrement all the activation references of a child source when a child was added or removed.
2014-02-23 16:46:00 -08:00
deactivate_source(source);
obs_source_enum_tree(source, deactivate_tree, NULL);
obs_source_set_present_volume(source, 0.0f);
}
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
}
first commit
2013-09-30 19:37:13 -07:00
}
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
void obs_source_video_tick(obs_source_t source, float seconds)
first commit
2013-09-30 19:37:13 -07:00
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
if (!source) return;
Implement RTMP module (still needs drop code) - Implement the RTMP output module. This time around, we just use a simple FLV muxer, then just write to the stream with RTMP_Write. Easy and effective. - Fix the FLV muxer, the muxer now outputs proper FLV packets. - Output API: * When using encoders, automatically interleave encoded packets before sending it to the output. * Pair encoders and have them automatically wait for the other to start to ensure sync. * Change 'obs_output_signal_start_fail' to 'obs_output_signal_stop' because it was a bit confusing, and doing this makes a lot more sense for outputs that need to stop suddenly (disconnections/etc). - Encoder API: * Remove some unnecessary encoder functions from the actual API and make them internal. Most of the encoder functions are handled automatically by outputs anyway, so there's no real need to expose them and end up inadvertently confusing plugin writers. * Have audio encoders wait for the video encoder to get a frame, then start at the exact data point that the first video frame starts to ensure the most accrate sync of video/audio possible. * Add a required 'frame_size' callback for audio encoders that returns the expected number of frames desired to encode with. This way, the libobs encoder API can handle the circular buffering internally automatically for the encoder modules, so encoder writers don't have to do it themselves. - Fix a few bugs in the serializer interface. It was passing the wrong variable for the data in a few cases. - If a source has video, make obs_source_update defer the actual update callback until the tick function is called to prevent threading issues.
2014-04-07 22:00:10 -07:00
if (source->defer_update)
obs_source_deferred_update(source);
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
/* reset the filter render texture information once every frame */
if (source->filter_texrender)
texrender_reset(source->filter_texrender);
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (source->context.data && source->info.video_tick)
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
source->info.video_tick(source->context.data, seconds);
first commit
2013-09-30 19:37:13 -07:00
}
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 04:51:06 -08:00
/* unless the value is 3+ hours worth of frames, this won't overflow */
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
static inline uint64_t conv_frames_to_time(size_t frames)
Detect audio timestamp jumps and reset timing - Often, timestamps will go "back" in time with certain.. terrible devices that no one should use. When this occurs, timing is now reset so that the new audio comes in directly after the old audio seamlessly.
2014-01-10 11:45:53 -08:00
{
Simplify media i/o interfaces Completely revamped the entire media i/o data and handlers. The original idea was to have a system that would have connecting media inputs and outputs, but at a certain point I realized that this was an unnecessary complexity for what we wanted to do. (Also, it reminded me of directshow filters, and I HATE directshow with a passion, and wouldn't wish it upon my greatest enemy) Now, audio/video outputs are connected to directly, with better callback handlers, and will eventually have the ability to automatically handle conversions such as 4:4:4 to 4:2:0 when connecting to an input that uses them. Doing this will allow the video/audio i/o handlers to also prevent duplicate conversion, as well as make it easier/simple to use. My true goal for this is to make output and encoder plugins as simple to create as possible. I want to be able to be able to create an output plugin with almost no real hassle of having to worry about image conversions, media inputs/outputs, etc. A plugin developer shouldn't have to handle that sort of stuff when he/she doesn't really need to. Plugins will be able to simply create a callback via obs_video() and/or obs_audio(), and they will automatically receive the audio/video data in the formats requested via a simple callback, without needing to do almost anything else at all.
2014-01-14 00:58:47 -08:00
const struct audio_output_info *info;
info = audio_output_getinfo(obs->audio.audio);
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 04:51:06 -08:00
return (uint64_t)frames * 1000000000ULL /
(uint64_t)info->samples_per_sec;
Detect audio timestamp jumps and reset timing - Often, timestamps will go "back" in time with certain.. terrible devices that no one should use. When this occurs, timing is now reset so that the new audio comes in directly after the old audio seamlessly.
2014-01-10 11:45:53 -08:00
}
add support for texture_rect texture type in shaders, add new form, clear up a few things in the API
2013-12-20 10:56:01 -08:00
/* maximum "direct" timestamp variance in nanoseconds */
Properly clamp audio timing and remove warnings If audio was under, it originally did a full reset of the audio timing. However, resetting the audio timing when this happens is kind of a bad thing. It's better just to clamp the value to the expected timestamp to ensure seamless audio output. Also, implement audio timestamp smoothing to ensure audio tries to be as seamless as possible.
2014-02-18 13:38:51 -08:00
#define MAX_TS_VAR 5000000000ULL
Detect audio timestamp jumps and reset timing - Often, timestamps will go "back" in time with certain.. terrible devices that no one should use. When this occurs, timing is now reset so that the new audio comes in directly after the old audio seamlessly.
2014-01-10 11:45:53 -08:00
/* maximum time that timestamp can jump in nanoseconds */
Properly clamp audio timing and remove warnings If audio was under, it originally did a full reset of the audio timing. However, resetting the audio timing when this happens is kind of a bad thing. It's better just to clamp the value to the expected timestamp to ensure seamless audio output. Also, implement audio timestamp smoothing to ensure audio tries to be as seamless as possible.
2014-02-18 13:38:51 -08:00
#define MAX_TIMESTAMP_JUMP 2000000000ULL
/* time threshold in nanoseconds to ensure audio timing is as seamless as
* possible */
#define TS_SMOOTHING_THRESHOLD 70000000ULL
Detect audio timestamp jumps and reset timing - Often, timestamps will go "back" in time with certain.. terrible devices that no one should use. When this occurs, timing is now reset so that the new audio comes in directly after the old audio seamlessly.
2014-01-10 11:45:53 -08:00
static inline void reset_audio_timing(obs_source_t source, uint64_t timetamp)
{
source->timing_set = true;
source->timing_adjust = os_gettime_ns() - timetamp;
}
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
Properly clamp audio timing and remove warnings If audio was under, it originally did a full reset of the audio timing. However, resetting the audio timing when this happens is kind of a bad thing. It's better just to clamp the value to the expected timestamp to ensure seamless audio output. Also, implement audio timestamp smoothing to ensure audio tries to be as seamless as possible.
2014-02-18 13:38:51 -08:00
static inline void handle_ts_jump(obs_source_t source, uint64_t expected,
uint64_t ts, uint64_t diff)
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
{
Fix inttypes.h usage ...I neglected to put a '%' character before using the PRI* macros.
2014-02-14 15:05:52 -08:00
blog(LOG_DEBUG, "Timestamp for source '%s' jumped by '%"PRIu64"', "
Properly clamp audio timing and remove warnings If audio was under, it originally did a full reset of the audio timing. However, resetting the audio timing when this happens is kind of a bad thing. It's better just to clamp the value to the expected timestamp to ensure seamless audio output. Also, implement audio timestamp smoothing to ensure audio tries to be as seamless as possible.
2014-02-18 13:38:51 -08:00
"expected value %"PRIu64", input value %"PRIu64,
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
source->context.name, diff, expected, ts);
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
/* if has video, ignore audio data until reset */
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
if (source->info.output_flags & OBS_SOURCE_ASYNC)
async vid.: Fix potential endless buffering issue If a source with async video wasn't currently active, it would endlessly buffer the video data, which would cause memory to grow endlessly until available memory was extinguished. This really needs to be replaced with a proper caching mechanism at some point.
2014-04-28 20:38:15 -07:00
os_atomic_dec_long(&source->av_sync_ref);
libobs: Add level/magnitude/peak volume levels This replaces the older code which simply queried the max volume level value for any given audio. I'm still not 100% sure on if this is how I want to approach the problem, particularly, whether this should be done in obs_source or in audio_line, but it can always be moved later if needed. This uses the calculations by the awesome Bill Hamilton that OBS1 used for its volume levels. It calculates the current max (level), magnitude, and current peak. This data then can be used to create awesome volume meter controls later on. NOTE: Will probably need optimization, does one float at a time right now. Also, change some of the naming conventions. I actually need to change a lot of the naming conventions in general so that all words are separated by underscores. Kind of a bad practice there on my part.
2014-06-03 04:43:00 -07:00
else
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
reset_audio_timing(source, ts);
}
libobs: Add level/magnitude/peak volume levels This replaces the older code which simply queried the max volume level value for any given audio. I'm still not 100% sure on if this is how I want to approach the problem, particularly, whether this should be done in obs_source or in audio_line, but it can always be moved later if needed. This uses the calculations by the awesome Bill Hamilton that OBS1 used for its volume levels. It calculates the current max (level), magnitude, and current peak. This data then can be used to create awesome volume meter controls later on. NOTE: Will probably need optimization, does one float at a time right now. Also, change some of the naming conventions. I actually need to change a lot of the naming conventions in general so that all words are separated by underscores. Kind of a bad practice there on my part.
2014-06-03 04:43:00 -07:00
#define VOL_MIN -96.0f
#define VOL_MAX 0.0f
static inline float to_db(float val)
{
float db = 20.0f * log10f(val);
return isfinite(db) ? db : VOL_MIN;
}
static void calc_volume_levels(struct obs_source *source, float *array,
libobs: Account for volume with audio levels
2014-06-06 08:56:37 -07:00
size_t frames, float volume)
libobs: Add level/magnitude/peak volume levels This replaces the older code which simply queried the max volume level value for any given audio. I'm still not 100% sure on if this is how I want to approach the problem, particularly, whether this should be done in obs_source or in audio_line, but it can always be moved later if needed. This uses the calculations by the awesome Bill Hamilton that OBS1 used for its volume levels. It calculates the current max (level), magnitude, and current peak. This data then can be used to create awesome volume meter controls later on. NOTE: Will probably need optimization, does one float at a time right now. Also, change some of the naming conventions. I actually need to change a lot of the naming conventions in general so that all words are separated by underscores. Kind of a bad practice there on my part.
2014-06-03 04:43:00 -07:00
{
float sum_val = 0.0f;
float max_val = 0.0f;
float rms_val = 0.0f;
const uint32_t sample_rate = audio_output_samplerate(obs_audio());
const size_t channels = audio_output_channels(obs_audio());
const size_t count = frames * channels;
const size_t vol_peak_delay = sample_rate * 3;
const float alpha = 0.15f;
for (size_t i = 0; i < count; i++) {
float val = array[i];
float val_pow2 = val * val;
sum_val += val_pow2;
max_val = fmaxf(max_val, val_pow2);
}
libobs: Account for volume with audio levels
2014-06-06 08:56:37 -07:00
rms_val = to_db(sqrtf(sum_val / (float)count * volume));
max_val = to_db(sqrtf(max_val * volume));
libobs: Add level/magnitude/peak volume levels This replaces the older code which simply queried the max volume level value for any given audio. I'm still not 100% sure on if this is how I want to approach the problem, particularly, whether this should be done in obs_source or in audio_line, but it can always be moved later if needed. This uses the calculations by the awesome Bill Hamilton that OBS1 used for its volume levels. It calculates the current max (level), magnitude, and current peak. This data then can be used to create awesome volume meter controls later on. NOTE: Will probably need optimization, does one float at a time right now. Also, change some of the naming conventions. I actually need to change a lot of the naming conventions in general so that all words are separated by underscores. Kind of a bad practice there on my part.
2014-06-03 04:43:00 -07:00
if (max_val > source->vol_max)
source->vol_max = max_val;
else
source->vol_max = alpha * source->vol_max +
(1.0f - alpha) * max_val;
if (source->vol_max > source->vol_peak ||
source->vol_update_count > vol_peak_delay) {
source->vol_peak = source->vol_max;
source->vol_update_count = 0;
} else {
source->vol_update_count += count;
}
source->vol_mag = alpha * rms_val + source->vol_mag * (1.0f - alpha);
}
/* TODO update peak/etc later */
static void obs_source_update_volume_level(obs_source_t source,
struct audio_data *in)
{
if (source && in) {
struct calldata data = {0};
libobs: Account for volume with audio levels
2014-06-06 08:56:37 -07:00
calc_volume_levels(source, (float*)in->data[0], in->frames,
in->volume);
libobs: Add level/magnitude/peak volume levels This replaces the older code which simply queried the max volume level value for any given audio. I'm still not 100% sure on if this is how I want to approach the problem, particularly, whether this should be done in obs_source or in audio_line, but it can always be moved later if needed. This uses the calculations by the awesome Bill Hamilton that OBS1 used for its volume levels. It calculates the current max (level), magnitude, and current peak. This data then can be used to create awesome volume meter controls later on. NOTE: Will probably need optimization, does one float at a time right now. Also, change some of the naming conventions. I actually need to change a lot of the naming conventions in general so that all words are separated by underscores. Kind of a bad practice there on my part.
2014-06-03 04:43:00 -07:00
calldata_setptr (&data, "source", source);
calldata_setfloat(&data, "level", source->vol_max);
calldata_setfloat(&data, "magnitude", source->vol_mag);
calldata_setfloat(&data, "peak", source->vol_peak);
signal_handler_signal(source->context.signals, "volume_level",
&data);
signal_handler_signal(obs->signals, "source_volume_level",
&data);
calldata_free(&data);
}
}
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
static void source_output_audio_line(obs_source_t source,
const struct audio_data *data)
{
struct audio_data in = *data;
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
uint64_t diff;
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
if (!source->timing_set) {
Detect audio timestamp jumps and reset timing - Often, timestamps will go "back" in time with certain.. terrible devices that no one should use. When this occurs, timing is now reset so that the new audio comes in directly after the old audio seamlessly.
2014-01-10 11:45:53 -08:00
reset_audio_timing(source, in.timestamp);
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
/* detects 'directly' set timestamps as long as they're within
add support for texture_rect texture type in shaders, add new form, clear up a few things in the API
2013-12-20 10:56:01 -08:00
* a certain threshold */
Detect audio timestamp jumps and reset timing - Often, timestamps will go "back" in time with certain.. terrible devices that no one should use. When this occurs, timing is now reset so that the new audio comes in directly after the old audio seamlessly.
2014-01-10 11:45:53 -08:00
if ((source->timing_adjust + MAX_TS_VAR) < MAX_TS_VAR * 2)
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
source->timing_adjust = 0;
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
Detect audio timestamp jumps and reset timing - Often, timestamps will go "back" in time with certain.. terrible devices that no one should use. When this occurs, timing is now reset so that the new audio comes in directly after the old audio seamlessly.
2014-01-10 11:45:53 -08:00
} else {
Properly clamp audio timing and remove warnings If audio was under, it originally did a full reset of the audio timing. However, resetting the audio timing when this happens is kind of a bad thing. It's better just to clamp the value to the expected timestamp to ensure seamless audio output. Also, implement audio timestamp smoothing to ensure audio tries to be as seamless as possible.
2014-02-18 13:38:51 -08:00
bool ts_under = (in.timestamp < source->next_audio_ts_min);
Detect audio timestamp jumps and reset timing - Often, timestamps will go "back" in time with certain.. terrible devices that no one should use. When this occurs, timing is now reset so that the new audio comes in directly after the old audio seamlessly.
2014-01-10 11:45:53 -08:00
Properly clamp audio timing and remove warnings If audio was under, it originally did a full reset of the audio timing. However, resetting the audio timing when this happens is kind of a bad thing. It's better just to clamp the value to the expected timestamp to ensure seamless audio output. Also, implement audio timestamp smoothing to ensure audio tries to be as seamless as possible.
2014-02-18 13:38:51 -08:00
diff = ts_under ?
(source->next_audio_ts_min - in.timestamp) :
(in.timestamp - source->next_audio_ts_min);
/* smooth audio if lower or within threshold */
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
if (diff > MAX_TIMESTAMP_JUMP)
Properly clamp audio timing and remove warnings If audio was under, it originally did a full reset of the audio timing. However, resetting the audio timing when this happens is kind of a bad thing. It's better just to clamp the value to the expected timestamp to ensure seamless audio output. Also, implement audio timestamp smoothing to ensure audio tries to be as seamless as possible.
2014-02-18 13:38:51 -08:00
handle_ts_jump(source, source->next_audio_ts_min,
in.timestamp, diff);
else if (ts_under || diff < TS_SMOOTHING_THRESHOLD)
in.timestamp = source->next_audio_ts_min;
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
}
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
source->next_audio_ts_min = in.timestamp +
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
conv_frames_to_time(in.frames);
Detect audio timestamp jumps and reset timing - Often, timestamps will go "back" in time with certain.. terrible devices that no one should use. When this occurs, timing is now reset so that the new audio comes in directly after the old audio seamlessly.
2014-01-10 11:45:53 -08:00
async vid.: Fix potential endless buffering issue If a source with async video wasn't currently active, it would endlessly buffer the video data, which would cause memory to grow endlessly until available memory was extinguished. This really needs to be replaced with a proper caching mechanism at some point.
2014-04-28 20:38:15 -07:00
if (source->av_sync_ref != 0)
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
return;
Add source audio sync offset setting
2014-02-20 15:16:25 -08:00
in.timestamp += source->timing_adjust + source->sync_offset;
Add more volume options Added a "master" volume for the entire audio subsystem. Also, added a "presentation" volume for both the master volume and for each invidiaul source. The presentation volume is used to control things like transitioning volumes, preventing sources from outputting any audio when they're inactive, as well as some other uses in the future.
2014-02-20 14:53:16 -08:00
in.volume = source->user_volume * source->present_volume *
obs->audio.user_volume * obs->audio.present_volume;
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 04:51:06 -08:00
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
audio_line_output(source->audio_line, &in);
libobs: Add level/magnitude/peak volume levels This replaces the older code which simply queried the max volume level value for any given audio. I'm still not 100% sure on if this is how I want to approach the problem, particularly, whether this should be done in obs_source or in audio_line, but it can always be moved later if needed. This uses the calculations by the awesome Bill Hamilton that OBS1 used for its volume levels. It calculates the current max (level), magnitude, and current peak. This data then can be used to create awesome volume meter controls later on. NOTE: Will probably need optimization, does one float at a time right now. Also, change some of the naming conventions. I actually need to change a lot of the naming conventions in general so that all words are separated by underscores. Kind of a bad practice there on my part.
2014-06-03 04:43:00 -07:00
obs_source_update_volume_level(source, &in);
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
}
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
enum convert_type {
CONVERT_NONE,
CONVERT_NV12,
CONVERT_420,
CONVERT_422_U,
CONVERT_422_Y,
};
finish up most of the source audio stuff and rename some variables/structs/enum to be a bit more consistent
2013-10-31 10:28:47 -07:00
static inline enum convert_type get_convert_type(enum video_format format)
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
{
finish up most of the source audio stuff and rename some variables/structs/enum to be a bit more consistent
2013-10-31 10:28:47 -07:00
switch (format) {
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
case VIDEO_FORMAT_I420:
return CONVERT_420;
case VIDEO_FORMAT_NV12:
return CONVERT_NV12;
case VIDEO_FORMAT_YVYU:
case VIDEO_FORMAT_YUY2:
return CONVERT_422_Y;
case VIDEO_FORMAT_UYVY:
return CONVERT_422_U;
Add preliminary ffmpeg plugin (still testing) - Added some code for FFmpeg output that I'm still playing around with. Right now I'm just trying to get it to output to file and try to understand the FFmpeg/libav APIs. Hopefully in the future this plugin can be used for any sort of output to FFmpeg. - Fixed a cast warning in audio-io.c with size_t -> uint32_t - Renamed the 'video_info' and 'audio_info' structures to 'video_conver_info' and 'audio_convert_info' to better represent their actual purpose, and to avoid confusion with 'audio_output_info' and 'video_output_info' structures. - Removed a few macros from obs-def.h that were at one point going to be used but no longer going to be used (at least for now)
2014-01-19 02:16:41 -08:00
case VIDEO_FORMAT_NONE:
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
case VIDEO_FORMAT_RGBA:
case VIDEO_FORMAT_BGRA:
case VIDEO_FORMAT_BGRX:
return CONVERT_NONE;
}
return CONVERT_NONE;
}
Add GPU based frame decompression for async video sources
2014-04-23 20:57:56 -07:00
static inline bool set_packed422_sizes(struct obs_source *source,
struct source_frame *frame)
{
source->async_convert_height = frame->height;
libobs: Add planar 4:2:0 async texture support This uses the reverse planar YUV 4:2:0 conversion shader to output a YUV texture without having to convert it via CPU. Again, this will reduce video upload bandwidth usage to 37.5% of the original rate. I suspect this will be particularly useful for when an FFmpeg or libav input plugin for playing videos is made. NOTE: There's an issue with certain texture sizes right now I haven't been able to identify, if the full size of texture data divided by the base texture width is an uneven number, the V chroma plane seems like it can potentially shift, though I only had this happen with 160x90 resolution C920. Almost all resolutions tend to be even. Needs further testing with more devices that support planar YUV 4:2:0 output.
2014-05-30 02:23:36 -07:00
source->async_convert_width = frame->width / 2;
source->async_texture_format = GS_BGRA;
return true;
}
static inline bool set_planar420_sizes(struct obs_source *source,
struct source_frame *frame)
{
uint32_t size = frame->width * frame->height;
size += size/2;
source->async_convert_width = frame->width;
source->async_convert_height = (size / frame->width + 1) & 0xFFFFFFFE;
source->async_texture_format = GS_R8;
source->async_plane_offset[0] = frame->width * frame->height;
source->async_plane_offset[1] = source->async_plane_offset[0] +
frame->width * frame->height / 4;
Add GPU based frame decompression for async video sources
2014-04-23 20:57:56 -07:00
return true;
}
static inline bool init_gpu_conversion(struct obs_source *source,
struct source_frame *frame)
{
switch (get_convert_type(frame->format)) {
case CONVERT_422_Y:
case CONVERT_422_U:
return set_packed422_sizes(source, frame);
case CONVERT_420:
libobs: Add planar 4:2:0 async texture support This uses the reverse planar YUV 4:2:0 conversion shader to output a YUV texture without having to convert it via CPU. Again, this will reduce video upload bandwidth usage to 37.5% of the original rate. I suspect this will be particularly useful for when an FFmpeg or libav input plugin for playing videos is made. NOTE: There's an issue with certain texture sizes right now I haven't been able to identify, if the full size of texture data divided by the base texture width is an uneven number, the V chroma plane seems like it can potentially shift, though I only had this happen with 160x90 resolution C920. Almost all resolutions tend to be even. Needs further testing with more devices that support planar YUV 4:2:0 output.
2014-05-30 02:23:36 -07:00
return set_planar420_sizes(source, frame);
case CONVERT_NV12:
assert(false && "NV12 not yet implemented");
Add GPU based frame decompression for async video sources
2014-04-23 20:57:56 -07:00
/* TODO: implement conversion */
break;
case CONVERT_NONE:
assert(false && "No conversion requested");
break;
}
return false;
}
libobs: Add planar 4:2:0 async texture support This uses the reverse planar YUV 4:2:0 conversion shader to output a YUV texture without having to convert it via CPU. Again, this will reduce video upload bandwidth usage to 37.5% of the original rate. I suspect this will be particularly useful for when an FFmpeg or libav input plugin for playing videos is made. NOTE: There's an issue with certain texture sizes right now I haven't been able to identify, if the full size of texture data divided by the base texture width is an uneven number, the V chroma plane seems like it can potentially shift, though I only had this happen with 160x90 resolution C920. Almost all resolutions tend to be even. Needs further testing with more devices that support planar YUV 4:2:0 output.
2014-05-30 02:23:36 -07:00
static inline enum gs_color_format convert_video_format(
enum video_format format)
{
if (format == VIDEO_FORMAT_RGBA)
return GS_RGBA;
else if (format == VIDEO_FORMAT_BGRA)
return GS_BGRA;
return GS_BGRX;
}
Add GPU based frame decompression for async video sources
2014-04-23 20:57:56 -07:00
static inline bool set_async_texture_size(struct obs_source *source,
struct source_frame *frame)
{
enum convert_type prev, cur;
prev = get_convert_type(source->async_format);
cur = get_convert_type(frame->format);
if (source->async_texture) {
if (source->async_width == frame->width &&
source->async_height == frame->height &&
prev == cur)
return true;
}
texture_destroy(source->async_texture);
texrender_destroy(source->async_convert_texrender);
source->async_convert_texrender = NULL;
if (cur != CONVERT_NONE && init_gpu_conversion(source, frame)) {
source->async_gpu_conversion = true;
source->async_convert_texrender =
libobs: Add planar 4:2:0 async texture support This uses the reverse planar YUV 4:2:0 conversion shader to output a YUV texture without having to convert it via CPU. Again, this will reduce video upload bandwidth usage to 37.5% of the original rate. I suspect this will be particularly useful for when an FFmpeg or libav input plugin for playing videos is made. NOTE: There's an issue with certain texture sizes right now I haven't been able to identify, if the full size of texture data divided by the base texture width is an uneven number, the V chroma plane seems like it can potentially shift, though I only had this happen with 160x90 resolution C920. Almost all resolutions tend to be even. Needs further testing with more devices that support planar YUV 4:2:0 output.
2014-05-30 02:23:36 -07:00
texrender_create(GS_BGRX, GS_ZS_NONE);
Add GPU based frame decompression for async video sources
2014-04-23 20:57:56 -07:00
source->async_texture = gs_create_texture(
source->async_convert_width,
source->async_convert_height,
libobs: Add planar 4:2:0 async texture support This uses the reverse planar YUV 4:2:0 conversion shader to output a YUV texture without having to convert it via CPU. Again, this will reduce video upload bandwidth usage to 37.5% of the original rate. I suspect this will be particularly useful for when an FFmpeg or libav input plugin for playing videos is made. NOTE: There's an issue with certain texture sizes right now I haven't been able to identify, if the full size of texture data divided by the base texture width is an uneven number, the V chroma plane seems like it can potentially shift, though I only had this happen with 160x90 resolution C920. Almost all resolutions tend to be even. Needs further testing with more devices that support planar YUV 4:2:0 output.
2014-05-30 02:23:36 -07:00
source->async_texture_format,
1, NULL, GS_DYNAMIC);
Add GPU based frame decompression for async video sources
2014-04-23 20:57:56 -07:00
} else {
libobs: Add planar 4:2:0 async texture support This uses the reverse planar YUV 4:2:0 conversion shader to output a YUV texture without having to convert it via CPU. Again, this will reduce video upload bandwidth usage to 37.5% of the original rate. I suspect this will be particularly useful for when an FFmpeg or libav input plugin for playing videos is made. NOTE: There's an issue with certain texture sizes right now I haven't been able to identify, if the full size of texture data divided by the base texture width is an uneven number, the V chroma plane seems like it can potentially shift, though I only had this happen with 160x90 resolution C920. Almost all resolutions tend to be even. Needs further testing with more devices that support planar YUV 4:2:0 output.
2014-05-30 02:23:36 -07:00
enum gs_color_format format = convert_video_format(
frame->format);
Add GPU based frame decompression for async video sources
2014-04-23 20:57:56 -07:00
source->async_gpu_conversion = false;
source->async_texture = gs_create_texture(
frame->width, frame->height,
libobs: Add planar 4:2:0 async texture support This uses the reverse planar YUV 4:2:0 conversion shader to output a YUV texture without having to convert it via CPU. Again, this will reduce video upload bandwidth usage to 37.5% of the original rate. I suspect this will be particularly useful for when an FFmpeg or libav input plugin for playing videos is made. NOTE: There's an issue with certain texture sizes right now I haven't been able to identify, if the full size of texture data divided by the base texture width is an uneven number, the V chroma plane seems like it can potentially shift, though I only had this happen with 160x90 resolution C920. Almost all resolutions tend to be even. Needs further testing with more devices that support planar YUV 4:2:0 output.
2014-05-30 02:23:36 -07:00
format, 1, NULL, GS_DYNAMIC);
Add GPU based frame decompression for async video sources
2014-04-23 20:57:56 -07:00
}
if (!source->async_texture)
return false;
source->async_width = frame->width;
source->async_height = frame->height;
return true;
}
static void upload_raw_frame(texture_t tex, const struct source_frame *frame)
{
switch (get_convert_type(frame->format)) {
case CONVERT_422_U:
case CONVERT_422_Y:
texture_setimage(tex, frame->data[0],
frame->linesize[0], false);
break;
case CONVERT_420:
libobs: Add planar 4:2:0 async texture support This uses the reverse planar YUV 4:2:0 conversion shader to output a YUV texture without having to convert it via CPU. Again, this will reduce video upload bandwidth usage to 37.5% of the original rate. I suspect this will be particularly useful for when an FFmpeg or libav input plugin for playing videos is made. NOTE: There's an issue with certain texture sizes right now I haven't been able to identify, if the full size of texture data divided by the base texture width is an uneven number, the V chroma plane seems like it can potentially shift, though I only had this happen with 160x90 resolution C920. Almost all resolutions tend to be even. Needs further testing with more devices that support planar YUV 4:2:0 output.
2014-05-30 02:23:36 -07:00
texture_setimage(tex, frame->data[0],
frame->width, false);
break;
case CONVERT_NV12:
Add GPU based frame decompression for async video sources
2014-04-23 20:57:56 -07:00
assert(false && "Conversion not yet implemented");
break;
case CONVERT_NONE:
assert(false && "No conversion requested");
break;
}
}
static const char *select_conversion_technique(enum video_format format)
{
switch (format) {
case VIDEO_FORMAT_UYVY:
Fix typo in conversion technique name (there is no UYUV, only UYVY)
2014-06-02 07:38:20 -07:00
return "UYVY_Reverse";
Add GPU based frame decompression for async video sources
2014-04-23 20:57:56 -07:00
case VIDEO_FORMAT_YUY2:
return "YUY2_Reverse";
case VIDEO_FORMAT_YVYU:
return "YVYU_Reverse";
case VIDEO_FORMAT_I420:
libobs: Add planar 4:2:0 async texture support This uses the reverse planar YUV 4:2:0 conversion shader to output a YUV texture without having to convert it via CPU. Again, this will reduce video upload bandwidth usage to 37.5% of the original rate. I suspect this will be particularly useful for when an FFmpeg or libav input plugin for playing videos is made. NOTE: There's an issue with certain texture sizes right now I haven't been able to identify, if the full size of texture data divided by the base texture width is an uneven number, the V chroma plane seems like it can potentially shift, though I only had this happen with 160x90 resolution C920. Almost all resolutions tend to be even. Needs further testing with more devices that support planar YUV 4:2:0 output.
2014-05-30 02:23:36 -07:00
return "I420_Reverse";
case VIDEO_FORMAT_NV12:
Add GPU based frame decompression for async video sources
2014-04-23 20:57:56 -07:00
assert(false && "Conversion not yet implemented");
break;
case VIDEO_FORMAT_BGRA:
case VIDEO_FORMAT_BGRX:
case VIDEO_FORMAT_RGBA:
case VIDEO_FORMAT_NONE:
assert(false && "No conversion requested");
break;
}
return NULL;
}
static inline void set_eparam(effect_t effect, const char *name, float val)
{
eparam_t param = effect_getparambyname(effect, name);
effect_setfloat(effect, param, val);
}
static bool update_async_texrender(struct obs_source *source,
const struct source_frame *frame)
{
texture_t tex = source->async_texture;
texrender_t texrender = source->async_convert_texrender;
texrender_reset(texrender);
upload_raw_frame(tex, frame);
uint32_t cx = source->async_width;
uint32_t cy = source->async_height;
libobs: Add planar 4:2:0 async texture support This uses the reverse planar YUV 4:2:0 conversion shader to output a YUV texture without having to convert it via CPU. Again, this will reduce video upload bandwidth usage to 37.5% of the original rate. I suspect this will be particularly useful for when an FFmpeg or libav input plugin for playing videos is made. NOTE: There's an issue with certain texture sizes right now I haven't been able to identify, if the full size of texture data divided by the base texture width is an uneven number, the V chroma plane seems like it can potentially shift, though I only had this happen with 160x90 resolution C920. Almost all resolutions tend to be even. Needs further testing with more devices that support planar YUV 4:2:0 output.
2014-05-30 02:23:36 -07:00
float convert_width = (float)source->async_convert_width;
float convert_height = (float)source->async_convert_height;
Add GPU based frame decompression for async video sources
2014-04-23 20:57:56 -07:00
effect_t conv = obs->video.conversion_effect;
technique_t tech = effect_gettechnique(conv,
select_conversion_technique(frame->format));
if (!texrender_begin(texrender, cx, cy))
return false;
technique_begin(tech);
technique_beginpass(tech, 0);
libobs: Add planar 4:2:0 async texture support This uses the reverse planar YUV 4:2:0 conversion shader to output a YUV texture without having to convert it via CPU. Again, this will reduce video upload bandwidth usage to 37.5% of the original rate. I suspect this will be particularly useful for when an FFmpeg or libav input plugin for playing videos is made. NOTE: There's an issue with certain texture sizes right now I haven't been able to identify, if the full size of texture data divided by the base texture width is an uneven number, the V chroma plane seems like it can potentially shift, though I only had this happen with 160x90 resolution C920. Almost all resolutions tend to be even. Needs further testing with more devices that support planar YUV 4:2:0 output.
2014-05-30 02:23:36 -07:00
effect_settexture(conv, effect_getparambyname(conv, "image"), tex);
Add GPU based frame decompression for async video sources
2014-04-23 20:57:56 -07:00
set_eparam(conv, "width", (float)cx);
set_eparam(conv, "height", (float)cy);
set_eparam(conv, "width_i", 1.0f / cx);
set_eparam(conv, "height_i", 1.0f / cy);
libobs: Add planar 4:2:0 async texture support This uses the reverse planar YUV 4:2:0 conversion shader to output a YUV texture without having to convert it via CPU. Again, this will reduce video upload bandwidth usage to 37.5% of the original rate. I suspect this will be particularly useful for when an FFmpeg or libav input plugin for playing videos is made. NOTE: There's an issue with certain texture sizes right now I haven't been able to identify, if the full size of texture data divided by the base texture width is an uneven number, the V chroma plane seems like it can potentially shift, though I only had this happen with 160x90 resolution C920. Almost all resolutions tend to be even. Needs further testing with more devices that support planar YUV 4:2:0 output.
2014-05-30 02:23:36 -07:00
set_eparam(conv, "width_d2", cx * 0.5f);
Add GPU based frame decompression for async video sources
2014-04-23 20:57:56 -07:00
set_eparam(conv, "height_d2", cy * 0.5f);
libobs: Add planar 4:2:0 async texture support This uses the reverse planar YUV 4:2:0 conversion shader to output a YUV texture without having to convert it via CPU. Again, this will reduce video upload bandwidth usage to 37.5% of the original rate. I suspect this will be particularly useful for when an FFmpeg or libav input plugin for playing videos is made. NOTE: There's an issue with certain texture sizes right now I haven't been able to identify, if the full size of texture data divided by the base texture width is an uneven number, the V chroma plane seems like it can potentially shift, though I only had this happen with 160x90 resolution C920. Almost all resolutions tend to be even. Needs further testing with more devices that support planar YUV 4:2:0 output.
2014-05-30 02:23:36 -07:00
set_eparam(conv, "width_d2_i", 1.0f / (cx * 0.5f));
Add GPU based frame decompression for async video sources
2014-04-23 20:57:56 -07:00
set_eparam(conv, "height_d2_i", 1.0f / (cy * 0.5f));
libobs: Add planar 4:2:0 async texture support This uses the reverse planar YUV 4:2:0 conversion shader to output a YUV texture without having to convert it via CPU. Again, this will reduce video upload bandwidth usage to 37.5% of the original rate. I suspect this will be particularly useful for when an FFmpeg or libav input plugin for playing videos is made. NOTE: There's an issue with certain texture sizes right now I haven't been able to identify, if the full size of texture data divided by the base texture width is an uneven number, the V chroma plane seems like it can potentially shift, though I only had this happen with 160x90 resolution C920. Almost all resolutions tend to be even. Needs further testing with more devices that support planar YUV 4:2:0 output.
2014-05-30 02:23:36 -07:00
set_eparam(conv, "input_width", convert_width);
set_eparam(conv, "input_height", convert_height);
set_eparam(conv, "input_width_i", 1.0f / convert_width);
set_eparam(conv, "input_height_i", 1.0f / convert_height);
set_eparam(conv, "input_width_i_d2", (1.0f / convert_width) * 0.5f);
set_eparam(conv, "input_height_i_d2", (1.0f / convert_height) * 0.5f);
set_eparam(conv, "u_plane_offset",
(float)source->async_plane_offset[0]);
set_eparam(conv, "v_plane_offset",
(float)source->async_plane_offset[1]);
Add GPU based frame decompression for async video sources
2014-04-23 20:57:56 -07:00
gs_ortho(0.f, (float)cx, 0.f, (float)cy, -100.f, 100.f);
gs_draw_sprite(tex, 0, cx, cy);
technique_endpass(tech);
technique_end(tech);
texrender_end(texrender);
return true;
}
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
static bool update_async_texture(struct obs_source *source,
const struct source_frame *frame)
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
{
Add GPU based frame decompression for async video sources
2014-04-23 20:57:56 -07:00
texture_t tex = source->async_texture;
texrender_t texrender = source->async_convert_texrender;
enum convert_type type = get_convert_type(frame->format);
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
void *ptr;
uint32_t linesize;
Add limited range rendering for rendering YUV non-full range sources
2014-04-23 15:24:51 -07:00
source->async_format = frame->format;
source->async_flip = frame->flip;
source->async_full_range = frame->full_range;
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
memcpy(source->async_color_matrix, frame->color_matrix,
sizeof(frame->color_matrix));
Add limited range rendering for rendering YUV non-full range sources
2014-04-23 15:24:51 -07:00
memcpy(source->async_color_range_min, frame->color_range_min,
sizeof frame->color_range_min);
memcpy(source->async_color_range_max, frame->color_range_max,
sizeof frame->color_range_max);
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
Add GPU based frame decompression for async video sources
2014-04-23 20:57:56 -07:00
if (source->async_gpu_conversion && texrender)
return update_async_texrender(source, frame);
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
if (type == CONVERT_NONE) {
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 04:51:06 -08:00
texture_setimage(tex, frame->data[0], frame->linesize[0],
Add planar audio support, improve test output - Add planar audio support. FFmpeg and libav use planar audio for many encoders, so it was somewhat necessary to add support in libobs itself. - Improve/adjust FFmpeg test output plugin. The exports were somewhat messed up (making me rethink how exports should be done). Not yet functional; it handles video properly, but it still does not handle audio properly. - Improve planar video code. The planar video code was not properly accounting for row sizes for each plane. Specifying row sizes for each plane has now been added. This will also make it more compatible with FFmpeg/libav. - Fixed a bug where callbacks wouldn't create properly in audio-io and video-io code. - Implement 'blogva' function to allow for va_list usage with libobs logging.
2014-02-07 02:03:54 -08:00
false);
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
return true;
}
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 04:51:06 -08:00
if (!texture_map(tex, &ptr, &linesize))
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
return false;
if (type == CONVERT_420)
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
decompress_420((const uint8_t* const*)frame->data,
frame->linesize,
0, frame->height, ptr, linesize);
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
else if (type == CONVERT_NV12)
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
decompress_nv12((const uint8_t* const*)frame->data,
frame->linesize,
0, frame->height, ptr, linesize);
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
else if (type == CONVERT_422_Y)
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 04:51:06 -08:00
decompress_422(frame->data[0], frame->linesize[0],
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
0, frame->height, ptr, linesize, true);
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
else if (type == CONVERT_422_U)
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 04:51:06 -08:00
decompress_422(frame->data[0], frame->linesize[0],
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
0, frame->height, ptr, linesize, false);
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
texture_unmap(tex);
return true;
}
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
static inline void obs_source_draw_texture(struct obs_source *source,
Add limited range rendering for rendering YUV non-full range sources
2014-04-23 15:24:51 -07:00
effect_t effect, float *color_matrix,
float const *color_range_min, float const *color_range_max)
fill in the texture_setimage function, fill in a few other functions, and change certain names to be a little more consistent
2013-10-25 10:25:28 -07:00
{
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
texture_t tex = source->async_texture;
eparam_t param;
fill in the texture_setimage function, fill in a few other functions, and change certain names to be a little more consistent
2013-10-25 10:25:28 -07:00
Add GPU based frame decompression for async video sources
2014-04-23 20:57:56 -07:00
if (source->async_convert_texrender)
tex = texrender_gettexture(source->async_convert_texrender);
Fix defaults for DrawMatrix
2014-04-24 13:33:02 -07:00
if (color_range_min) {
Add limited range rendering for rendering YUV non-full range sources
2014-04-23 15:24:51 -07:00
size_t const size = sizeof(float) * 3;
param = effect_getparambyname(effect, "color_range_min");
effect_setval(effect, param, color_range_min, size);
Fix defaults for DrawMatrix
2014-04-24 13:33:02 -07:00
}
libobs: Add level/magnitude/peak volume levels This replaces the older code which simply queried the max volume level value for any given audio. I'm still not 100% sure on if this is how I want to approach the problem, particularly, whether this should be done in obs_source or in audio_line, but it can always be moved later if needed. This uses the calculations by the awesome Bill Hamilton that OBS1 used for its volume levels. It calculates the current max (level), magnitude, and current peak. This data then can be used to create awesome volume meter controls later on. NOTE: Will probably need optimization, does one float at a time right now. Also, change some of the naming conventions. I actually need to change a lot of the naming conventions in general so that all words are separated by underscores. Kind of a bad practice there on my part.
2014-06-03 04:43:00 -07:00
Fix defaults for DrawMatrix
2014-04-24 13:33:02 -07:00
if (color_range_max) {
size_t const size = sizeof(float) * 3;
Add limited range rendering for rendering YUV non-full range sources
2014-04-23 15:24:51 -07:00
param = effect_getparambyname(effect, "color_range_max");
effect_setval(effect, param, color_range_max, size);
Fix defaults for DrawMatrix
2014-04-24 13:33:02 -07:00
}
libobs: Add level/magnitude/peak volume levels This replaces the older code which simply queried the max volume level value for any given audio. I'm still not 100% sure on if this is how I want to approach the problem, particularly, whether this should be done in obs_source or in audio_line, but it can always be moved later if needed. This uses the calculations by the awesome Bill Hamilton that OBS1 used for its volume levels. It calculates the current max (level), magnitude, and current peak. This data then can be used to create awesome volume meter controls later on. NOTE: Will probably need optimization, does one float at a time right now. Also, change some of the naming conventions. I actually need to change a lot of the naming conventions in general so that all words are separated by underscores. Kind of a bad practice there on my part.
2014-06-03 04:43:00 -07:00
Fix defaults for DrawMatrix
2014-04-24 13:33:02 -07:00
if (color_matrix) {
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-05 19:36:21 -08:00
param = effect_getparambyname(effect, "color_matrix");
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
effect_setval(effect, param, color_matrix, sizeof(float) * 16);
fill in the texture_setimage function, fill in a few other functions, and change certain names to be a little more consistent
2013-10-25 10:25:28 -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
param = effect_getparambyname(effect, "image");
fill in the texture_setimage function, fill in a few other functions, and change certain names to be a little more consistent
2013-10-25 10:25:28 -07:00
effect_settexture(effect, param, tex);
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
gs_draw_sprite(tex, source->async_flip ? GS_FLIP_V : 0, 0, 0);
}
fill in the texture_setimage function, fill in a few other functions, and change certain names to be a little more consistent
2013-10-25 10:25:28 -07:00
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
static void obs_source_draw_async_texture(struct obs_source *source)
{
Add limited range rendering for rendering YUV non-full range sources
2014-04-23 15:24:51 -07:00
effect_t effect = gs_geteffect();
bool yuv = format_is_yuv(source->async_format);
bool limited_range = yuv && !source->async_full_range;
const char *type = yuv ? "DrawMatrix" : "Draw";
bool def_draw = (!effect);
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
technique_t tech;
if (def_draw) {
effect = obs_get_default_effect();
tech = effect_gettechnique(effect, type);
technique_begin(tech);
technique_beginpass(tech, 0);
}
obs_source_draw_texture(source, effect,
Add limited range rendering for rendering YUV non-full range sources
2014-04-23 15:24:51 -07:00
yuv ? source->async_color_matrix : NULL,
limited_range ? source->async_color_range_min : NULL,
limited_range ? source->async_color_range_max : NULL);
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
if (def_draw) {
technique_endpass(tech);
technique_end(tech);
}
fill in the texture_setimage function, fill in a few other functions, and change certain names to be a little more consistent
2013-10-25 10:25:28 -07:00
}
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
static void obs_source_render_async_video(obs_source_t source)
{
struct source_frame *frame = obs_source_getframe(source);
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
if (frame) {
if (!set_async_texture_size(source, frame))
return;
if (!update_async_texture(source, frame))
return;
}
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
if (source->async_texture)
obs_source_draw_async_texture(source);
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
obs_source_releaseframe(source, frame);
}
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
static inline void obs_source_render_filters(obs_source_t source)
{
source->rendering_filter = true;
obs_source_video_render(source->filters.array[0]);
source->rendering_filter = false;
}
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 void obs_source_default_render(obs_source_t source,
bool color_matrix)
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
{
effect_t effect = obs->video.default_effect;
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
const char *tech_name = color_matrix ? "DrawMatrix" : "Draw";
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
technique_t tech = effect_gettechnique(effect, tech_name);
size_t passes, i;
passes = technique_begin(tech);
for (i = 0; i < passes; i++) {
technique_beginpass(tech, i);
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (source->context.data)
source->info.video_render(source->context.data, effect);
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
technique_endpass(tech);
}
technique_end(tech);
}
static inline void obs_source_main_render(obs_source_t source)
{
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
uint32_t flags = source->info.output_flags;
bool color_matrix = (flags & OBS_SOURCE_COLOR_MATRIX) != 0;
bool custom_draw = (flags & OBS_SOURCE_CUSTOM_DRAW) != 0;
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
bool default_effect = !source->filter_parent &&
source->filters.num == 0 &&
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
!custom_draw;
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
if (default_effect)
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_source_default_render(source, color_matrix);
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
else if (source->context.data)
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
source->info.video_render(source->context.data,
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
custom_draw ? NULL : gs_geteffect());
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
}
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
void obs_source_video_render(obs_source_t source)
first commit
2013-09-30 19:37:13 -07:00
{
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (!source_valid(source)) return;
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
if (source->filters.num && !source->rendering_filter)
obs_source_render_filters(source);
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
else if (source->info.video_render)
obs_source_main_render(source);
else if (source->filter_target)
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
obs_source_video_render(source->filter_target);
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
else
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
obs_source_render_async_video(source);
first commit
2013-09-30 19:37:13 -07:00
}
some static analysis cleanup
2013-10-17 17:21:42 -07:00
uint32_t obs_source_getwidth(obs_source_t source)
first commit
2013-09-30 19:37:13 -07:00
{
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (!source_valid(source)) return 0;
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
if (source->info.getwidth)
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
return source->info.getwidth(source->context.data);
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
return source->async_width;
first commit
2013-09-30 19:37:13 -07:00
}
some static analysis cleanup
2013-10-17 17:21:42 -07:00
uint32_t obs_source_getheight(obs_source_t source)
first commit
2013-09-30 19:37:13 -07:00
{
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (!source_valid(source)) return 0;
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
if (source->info.getheight)
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
return source->info.getheight(source->context.data);
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
return source->async_height;
first commit
2013-09-30 19:37:13 -07:00
}
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
obs_source_t obs_filter_getparent(obs_source_t filter)
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
return filter ? filter->filter_parent : NULL;
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
}
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
obs_source_t obs_filter_gettarget(obs_source_t filter)
first commit
2013-09-30 19:37:13 -07:00
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
return filter ? filter->filter_target : NULL;
first commit
2013-09-30 19:37:13 -07:00
}
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
void obs_source_filter_add(obs_source_t source, obs_source_t filter)
first commit
2013-09-30 19:37:13 -07:00
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
if (!source || !filter)
return;
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
pthread_mutex_lock(&source->filter_mutex);
some static analysis cleanup
2013-10-17 17:21:42 -07:00
if (da_find(source->filters, &filter, 0) != DARRAY_INVALID) {
first commit
2013-09-30 19:37:13 -07:00
blog(LOG_WARNING, "Tried to add a filter that was already "
"present on the source");
return;
}
if (source->filters.num) {
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
obs_source_t *back = da_end(source->filters);
first commit
2013-09-30 19:37:13 -07:00
(*back)->filter_target = filter;
}
da_push_back(source->filters, &filter);
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
pthread_mutex_unlock(&source->filter_mutex);
filter->filter_parent = source;
first commit
2013-09-30 19:37:13 -07:00
filter->filter_target = source;
}
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
void obs_source_filter_remove(obs_source_t source, obs_source_t filter)
first commit
2013-09-30 19:37:13 -07:00
{
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
size_t idx;
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
if (!source || !filter)
return;
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
pthread_mutex_lock(&source->filter_mutex);
idx = da_find(source->filters, &filter, 0);
some static analysis cleanup
2013-10-17 17:21:42 -07:00
if (idx == DARRAY_INVALID)
first commit
2013-09-30 19:37:13 -07:00
return;
if (idx > 0) {
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
obs_source_t prev = source->filters.array[idx-1];
first commit
2013-09-30 19:37:13 -07:00
prev->filter_target = filter->filter_target;
}
da_erase(source->filters, idx);
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
pthread_mutex_unlock(&source->filter_mutex);
filter->filter_parent = NULL;
first commit
2013-09-30 19:37:13 -07:00
filter->filter_target = NULL;
}
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
void obs_source_filter_setorder(obs_source_t source, obs_source_t filter,
first commit
2013-09-30 19:37:13 -07:00
enum order_movement movement)
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
size_t idx, i;
if (!source || !filter)
return;
idx = da_find(source->filters, &filter, 0);
some static analysis cleanup
2013-10-17 17:21:42 -07:00
if (idx == DARRAY_INVALID)
first commit
2013-09-30 19:37:13 -07:00
return;
if (movement == ORDER_MOVE_UP) {
if (idx == source->filters.num-1)
return;
da_move_item(source->filters, idx, idx+1);
} else if (movement == ORDER_MOVE_DOWN) {
if (idx == 0)
return;
da_move_item(source->filters, idx, idx-1);
} else if (movement == ORDER_MOVE_TOP) {
if (idx == source->filters.num-1)
return;
da_move_item(source->filters, idx, source->filters.num-1);
} else if (movement == ORDER_MOVE_BOTTOM) {
if (idx == 0)
return;
da_move_item(source->filters, idx, 0);
}
add support for texture_rect texture type in shaders, add new form, clear up a few things in the API
2013-12-20 10:56:01 -08:00
/* reorder filter targets, not the nicest way of dealing with things */
first commit
2013-09-30 19:37:13 -07:00
for (i = 0; i < source->filters.num; i++) {
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
obs_source_t next_filter = (i == source->filters.num-1) ?
first commit
2013-09-30 19:37:13 -07:00
source : source->filters.array[idx+1];
source->filters.array[i]->filter_target = next_filter;
}
}
Implement settings interface for plugins Add a fairly easy to use settings interface that can be passed to plugins, and replaced the old character string system that was being used before. The new data interface allows for an easier method of getting/altering settings for plugins, and is built to be serializable to/from JSON. Also, removed another wxFormBuilder file that was no longer in use.
2014-01-27 22:14:58 -08:00
obs_data_t obs_source_getsettings(obs_source_t source)
first commit
2013-09-30 19:37:13 -07:00
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
if (!source) return NULL;
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
obs_data_addref(source->context.settings);
return source->context.settings;
first commit
2013-09-30 19:37:13 -07:00
}
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
static inline struct source_frame *filter_async_video(obs_source_t source,
struct source_frame *in)
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
{
size_t i;
for (i = source->filters.num; i > 0; i--) {
struct obs_source *filter = source->filters.array[i-1];
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (filter->context.data && filter->info.filter_video) {
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
in = filter->info.filter_video(filter->context.data,
in);
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
if (!in)
return NULL;
}
}
return in;
}
Add planar audio support, improve test output - Add planar audio support. FFmpeg and libav use planar audio for many encoders, so it was somewhat necessary to add support in libobs itself. - Improve/adjust FFmpeg test output plugin. The exports were somewhat messed up (making me rethink how exports should be done). Not yet functional; it handles video properly, but it still does not handle audio properly. - Improve planar video code. The planar video code was not properly accounting for row sizes for each plane. Specifying row sizes for each plane has now been added. This will also make it more compatible with FFmpeg/libav. - Fixed a bug where callbacks wouldn't create properly in audio-io and video-io code. - Implement 'blogva' function to allow for va_list usage with libobs logging.
2014-02-07 02:03:54 -08:00
static inline void copy_frame_data_line(struct source_frame *dst,
const struct source_frame *src, uint32_t plane, uint32_t y)
{
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 04:51:06 -08:00
uint32_t pos_src = y * src->linesize[plane];
uint32_t pos_dst = y * dst->linesize[plane];
uint32_t bytes = dst->linesize[plane] < src->linesize[plane] ?
dst->linesize[plane] : src->linesize[plane];
Add planar audio support, improve test output - Add planar audio support. FFmpeg and libav use planar audio for many encoders, so it was somewhat necessary to add support in libobs itself. - Improve/adjust FFmpeg test output plugin. The exports were somewhat messed up (making me rethink how exports should be done). Not yet functional; it handles video properly, but it still does not handle audio properly. - Improve planar video code. The planar video code was not properly accounting for row sizes for each plane. Specifying row sizes for each plane has now been added. This will also make it more compatible with FFmpeg/libav. - Fixed a bug where callbacks wouldn't create properly in audio-io and video-io code. - Implement 'blogva' function to allow for va_list usage with libobs logging.
2014-02-07 02:03:54 -08:00
memcpy(dst->data[plane] + pos_dst, src->data[plane] + pos_src, bytes);
}
static inline void copy_frame_data_plane(struct source_frame *dst,
const struct source_frame *src, uint32_t plane, uint32_t lines)
{
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 04:51:06 -08:00
if (dst->linesize[plane] != src->linesize[plane])
Add planar audio support, improve test output - Add planar audio support. FFmpeg and libav use planar audio for many encoders, so it was somewhat necessary to add support in libobs itself. - Improve/adjust FFmpeg test output plugin. The exports were somewhat messed up (making me rethink how exports should be done). Not yet functional; it handles video properly, but it still does not handle audio properly. - Improve planar video code. The planar video code was not properly accounting for row sizes for each plane. Specifying row sizes for each plane has now been added. This will also make it more compatible with FFmpeg/libav. - Fixed a bug where callbacks wouldn't create properly in audio-io and video-io code. - Implement 'blogva' function to allow for va_list usage with libobs logging.
2014-02-07 02:03:54 -08:00
for (uint32_t y = 0; y < lines; y++)
copy_frame_data_line(dst, src, plane, y);
else
memcpy(dst->data[plane], src->data[plane],
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 04:51:06 -08:00
dst->linesize[plane] * lines);
Add planar audio support, improve test output - Add planar audio support. FFmpeg and libav use planar audio for many encoders, so it was somewhat necessary to add support in libobs itself. - Improve/adjust FFmpeg test output plugin. The exports were somewhat messed up (making me rethink how exports should be done). Not yet functional; it handles video properly, but it still does not handle audio properly. - Improve planar video code. The planar video code was not properly accounting for row sizes for each plane. Specifying row sizes for each plane has now been added. This will also make it more compatible with FFmpeg/libav. - Fixed a bug where callbacks wouldn't create properly in audio-io and video-io code. - Implement 'blogva' function to allow for va_list usage with libobs logging.
2014-02-07 02:03:54 -08:00
}
static void copy_frame_data(struct source_frame *dst,
const struct source_frame *src)
{
dst->flip = src->flip;
Add limited range rendering for rendering YUV non-full range sources
2014-04-23 15:24:51 -07:00
dst->full_range = src->full_range;
Add planar audio support, improve test output - Add planar audio support. FFmpeg and libav use planar audio for many encoders, so it was somewhat necessary to add support in libobs itself. - Improve/adjust FFmpeg test output plugin. The exports were somewhat messed up (making me rethink how exports should be done). Not yet functional; it handles video properly, but it still does not handle audio properly. - Improve planar video code. The planar video code was not properly accounting for row sizes for each plane. Specifying row sizes for each plane has now been added. This will also make it more compatible with FFmpeg/libav. - Fixed a bug where callbacks wouldn't create properly in audio-io and video-io code. - Implement 'blogva' function to allow for va_list usage with libobs logging.
2014-02-07 02:03:54 -08:00
dst->timestamp = src->timestamp;
memcpy(dst->color_matrix, src->color_matrix, sizeof(float) * 16);
Add limited range rendering for rendering YUV non-full range sources
2014-04-23 15:24:51 -07:00
if (!dst->full_range) {
size_t const size = sizeof(float) * 3;
memcpy(dst->color_range_min, src->color_range_min, size);
memcpy(dst->color_range_max, src->color_range_max, size);
}
Add planar audio support, improve test output - Add planar audio support. FFmpeg and libav use planar audio for many encoders, so it was somewhat necessary to add support in libobs itself. - Improve/adjust FFmpeg test output plugin. The exports were somewhat messed up (making me rethink how exports should be done). Not yet functional; it handles video properly, but it still does not handle audio properly. - Improve planar video code. The planar video code was not properly accounting for row sizes for each plane. Specifying row sizes for each plane has now been added. This will also make it more compatible with FFmpeg/libav. - Fixed a bug where callbacks wouldn't create properly in audio-io and video-io code. - Implement 'blogva' function to allow for va_list usage with libobs logging.
2014-02-07 02:03:54 -08:00
switch (dst->format) {
case VIDEO_FORMAT_I420:
copy_frame_data_plane(dst, src, 0, dst->height);
copy_frame_data_plane(dst, src, 1, dst->height/2);
copy_frame_data_plane(dst, src, 2, dst->height/2);
break;
case VIDEO_FORMAT_NV12:
copy_frame_data_plane(dst, src, 0, dst->height);
copy_frame_data_plane(dst, src, 1, dst->height/2);
break;
case VIDEO_FORMAT_YVYU:
case VIDEO_FORMAT_YUY2:
case VIDEO_FORMAT_UYVY:
case VIDEO_FORMAT_NONE:
case VIDEO_FORMAT_RGBA:
case VIDEO_FORMAT_BGRA:
case VIDEO_FORMAT_BGRX:
copy_frame_data_plane(dst, src, 0, dst->height);
}
}
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
static inline struct source_frame *cache_video(const struct source_frame *frame)
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
{
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
/* TODO: use an actual cache */
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 04:51:06 -08:00
struct source_frame *new_frame = source_frame_create(frame->format,
Add planar audio support, improve test output - Add planar audio support. FFmpeg and libav use planar audio for many encoders, so it was somewhat necessary to add support in libobs itself. - Improve/adjust FFmpeg test output plugin. The exports were somewhat messed up (making me rethink how exports should be done). Not yet functional; it handles video properly, but it still does not handle audio properly. - Improve planar video code. The planar video code was not properly accounting for row sizes for each plane. Specifying row sizes for each plane has now been added. This will also make it more compatible with FFmpeg/libav. - Fixed a bug where callbacks wouldn't create properly in audio-io and video-io code. - Implement 'blogva' function to allow for va_list usage with libobs logging.
2014-02-07 02:03:54 -08:00
frame->width, frame->height);
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
Add planar audio support, improve test output - Add planar audio support. FFmpeg and libav use planar audio for many encoders, so it was somewhat necessary to add support in libobs itself. - Improve/adjust FFmpeg test output plugin. The exports were somewhat messed up (making me rethink how exports should be done). Not yet functional; it handles video properly, but it still does not handle audio properly. - Improve planar video code. The planar video code was not properly accounting for row sizes for each plane. Specifying row sizes for each plane has now been added. This will also make it more compatible with FFmpeg/libav. - Fixed a bug where callbacks wouldn't create properly in audio-io and video-io code. - Implement 'blogva' function to allow for va_list usage with libobs logging.
2014-02-07 02:03:54 -08:00
copy_frame_data(new_frame, frame);
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
return new_frame;
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
}
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
static bool ready_async_frame(obs_source_t source, uint64_t sys_time);
async vid.: Fix potential endless buffering issue If a source with async video wasn't currently active, it would endlessly buffer the video data, which would cause memory to grow endlessly until available memory was extinguished. This really needs to be replaced with a proper caching mechanism at some point.
2014-04-28 20:38:15 -07:00
static inline void cycle_frames(struct obs_source *source)
{
if (source->video_frames.num && !source->activate_refs)
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
ready_async_frame(source, os_gettime_ns());
async vid.: Fix potential endless buffering issue If a source with async video wasn't currently active, it would endlessly buffer the video data, which would cause memory to grow endlessly until available memory was extinguished. This really needs to be replaced with a proper caching mechanism at some point.
2014-04-28 20:38:15 -07:00
}
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
void obs_source_output_video(obs_source_t source,
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
const struct source_frame *frame)
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
if (!source || !frame)
return;
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
struct source_frame *output = cache_video(frame);
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
pthread_mutex_lock(&source->filter_mutex);
output = filter_async_video(source, output);
pthread_mutex_unlock(&source->filter_mutex);
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
if (output) {
pthread_mutex_lock(&source->video_mutex);
async vid.: Fix potential endless buffering issue If a source with async video wasn't currently active, it would endlessly buffer the video data, which would cause memory to grow endlessly until available memory was extinguished. This really needs to be replaced with a proper caching mechanism at some point.
2014-04-28 20:38:15 -07:00
cycle_frames(source);
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
da_push_back(source->video_frames, &output);
pthread_mutex_unlock(&source->video_mutex);
}
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
}
finish up most of the source audio stuff and rename some variables/structs/enum to be a bit more consistent
2013-10-31 10:28:47 -07:00
static inline struct filtered_audio *filter_async_audio(obs_source_t source,
struct filtered_audio *in)
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
{
size_t i;
for (i = source->filters.num; i > 0; i--) {
struct obs_source *filter = source->filters.array[i-1];
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (filter->context.data && filter->info.filter_audio) {
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
in = filter->info.filter_audio(filter->context.data,
in);
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
if (!in)
return NULL;
}
}
return in;
}
finish up most of the source audio stuff and rename some variables/structs/enum to be a bit more consistent
2013-10-31 10:28:47 -07:00
static inline void reset_resampler(obs_source_t source,
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
const struct source_audio *audio)
{
Simplify media i/o interfaces Completely revamped the entire media i/o data and handlers. The original idea was to have a system that would have connecting media inputs and outputs, but at a certain point I realized that this was an unnecessary complexity for what we wanted to do. (Also, it reminded me of directshow filters, and I HATE directshow with a passion, and wouldn't wish it upon my greatest enemy) Now, audio/video outputs are connected to directly, with better callback handlers, and will eventually have the ability to automatically handle conversions such as 4:4:4 to 4:2:0 when connecting to an input that uses them. Doing this will allow the video/audio i/o handlers to also prevent duplicate conversion, as well as make it easier/simple to use. My true goal for this is to make output and encoder plugins as simple to create as possible. I want to be able to be able to create an output plugin with almost no real hassle of having to worry about image conversions, media inputs/outputs, etc. A plugin developer shouldn't have to handle that sort of stuff when he/she doesn't really need to. Plugins will be able to simply create a callback via obs_video() and/or obs_audio(), and they will automatically receive the audio/video data in the formats requested via a simple callback, without needing to do almost anything else at all.
2014-01-14 00:58:47 -08:00
const struct audio_output_info *obs_info;
finish up most of the source audio stuff and rename some variables/structs/enum to be a bit more consistent
2013-10-31 10:28:47 -07:00
struct resample_info output_info;
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
obs_info = audio_output_getinfo(obs->audio.audio);
finish up most of the source audio stuff and rename some variables/structs/enum to be a bit more consistent
2013-10-31 10:28:47 -07:00
output_info.format = obs_info->format;
output_info.samples_per_sec = obs_info->samples_per_sec;
output_info.speakers = obs_info->speakers;
source->sample_info.format = audio->format;
source->sample_info.samples_per_sec = audio->samples_per_sec;
source->sample_info.speakers = audio->speakers;
if (source->sample_info.samples_per_sec == obs_info->samples_per_sec &&
source->sample_info.format == obs_info->format &&
source->sample_info.speakers == obs_info->speakers) {
source->audio_failed = false;
return;
}
audio_resampler_destroy(source->resampler);
source->resampler = audio_resampler_create(&output_info,
&source->sample_info);
source->audio_failed = source->resampler == NULL;
if (source->resampler == NULL)
blog(LOG_ERROR, "creation of resampler failed");
}
static inline void copy_audio_data(obs_source_t source,
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
const uint8_t *const data[], uint32_t frames, uint64_t ts)
finish up most of the source audio stuff and rename some variables/structs/enum to be a bit more consistent
2013-10-31 10:28:47 -07:00
{
Add planar audio support, improve test output - Add planar audio support. FFmpeg and libav use planar audio for many encoders, so it was somewhat necessary to add support in libobs itself. - Improve/adjust FFmpeg test output plugin. The exports were somewhat messed up (making me rethink how exports should be done). Not yet functional; it handles video properly, but it still does not handle audio properly. - Improve planar video code. The planar video code was not properly accounting for row sizes for each plane. Specifying row sizes for each plane has now been added. This will also make it more compatible with FFmpeg/libav. - Fixed a bug where callbacks wouldn't create properly in audio-io and video-io code. - Implement 'blogva' function to allow for va_list usage with libobs logging.
2014-02-07 02:03:54 -08:00
size_t planes = audio_output_planes(obs->audio.audio);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
size_t blocksize = audio_output_blocksize(obs->audio.audio);
Add planar audio support, improve test output - Add planar audio support. FFmpeg and libav use planar audio for many encoders, so it was somewhat necessary to add support in libobs itself. - Improve/adjust FFmpeg test output plugin. The exports were somewhat messed up (making me rethink how exports should be done). Not yet functional; it handles video properly, but it still does not handle audio properly. - Improve planar video code. The planar video code was not properly accounting for row sizes for each plane. Specifying row sizes for each plane has now been added. This will also make it more compatible with FFmpeg/libav. - Fixed a bug where callbacks wouldn't create properly in audio-io and video-io code. - Implement 'blogva' function to allow for va_list usage with libobs logging.
2014-02-07 02:03:54 -08:00
size_t size = (size_t)frames * blocksize;
bool resize = source->audio_storage_size < size;
finish up most of the source audio stuff and rename some variables/structs/enum to be a bit more consistent
2013-10-31 10:28:47 -07:00
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
source->audio_data.frames = frames;
source->audio_data.timestamp = ts;
Add planar audio support, improve test output - Add planar audio support. FFmpeg and libav use planar audio for many encoders, so it was somewhat necessary to add support in libobs itself. - Improve/adjust FFmpeg test output plugin. The exports were somewhat messed up (making me rethink how exports should be done). Not yet functional; it handles video properly, but it still does not handle audio properly. - Improve planar video code. The planar video code was not properly accounting for row sizes for each plane. Specifying row sizes for each plane has now been added. This will also make it more compatible with FFmpeg/libav. - Fixed a bug where callbacks wouldn't create properly in audio-io and video-io code. - Implement 'blogva' function to allow for va_list usage with libobs logging.
2014-02-07 02:03:54 -08:00
for (size_t i = 0; i < planes; i++) {
/* ensure audio storage capacity */
if (resize) {
bfree(source->audio_data.data[i]);
source->audio_data.data[i] = bmalloc(size);
}
memcpy(source->audio_data.data[i], data[i], size);
}
if (resize)
source->audio_storage_size = size;
finish up most of the source audio stuff and rename some variables/structs/enum to be a bit more consistent
2013-10-31 10:28:47 -07:00
}
/* resamples/remixes new audio to the designated main audio output format */
static void process_audio(obs_source_t source, const struct source_audio *audio)
{
if (source->sample_info.samples_per_sec != audio->samples_per_sec ||
source->sample_info.format != audio->format ||
source->sample_info.speakers != audio->speakers)
reset_resampler(source, audio);
if (source->audio_failed)
return;
if (source->resampler) {
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
uint8_t *output[MAX_AV_PLANES];
finish up most of the source audio stuff and rename some variables/structs/enum to be a bit more consistent
2013-10-31 10:28:47 -07:00
uint32_t frames;
uint64_t offset;
Add planar audio support, improve test output - Add planar audio support. FFmpeg and libav use planar audio for many encoders, so it was somewhat necessary to add support in libobs itself. - Improve/adjust FFmpeg test output plugin. The exports were somewhat messed up (making me rethink how exports should be done). Not yet functional; it handles video properly, but it still does not handle audio properly. - Improve planar video code. The planar video code was not properly accounting for row sizes for each plane. Specifying row sizes for each plane has now been added. This will also make it more compatible with FFmpeg/libav. - Fixed a bug where callbacks wouldn't create properly in audio-io and video-io code. - Implement 'blogva' function to allow for va_list usage with libobs logging.
2014-02-07 02:03:54 -08:00
memset(output, 0, sizeof(output));
audio_resampler_resample(source->resampler,
output, &frames, &offset,
audio->data, audio->frames);
finish up most of the source audio stuff and rename some variables/structs/enum to be a bit more consistent
2013-10-31 10:28:47 -07:00
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
copy_audio_data(source, (const uint8_t *const *)output, frames,
finish up most of the source audio stuff and rename some variables/structs/enum to be a bit more consistent
2013-10-31 10:28:47 -07:00
audio->timestamp - offset);
} else {
copy_audio_data(source, audio->data, audio->frames,
audio->timestamp);
}
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
}
void obs_source_output_audio(obs_source_t source,
const struct source_audio *audio)
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
uint32_t flags;
finish up most of the source audio stuff and rename some variables/structs/enum to be a bit more consistent
2013-10-31 10:28:47 -07:00
struct filtered_audio *output;
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
if (!source || !audio)
return;
flags = source->info.output_flags;
finish up most of the source audio stuff and rename some variables/structs/enum to be a bit more consistent
2013-10-31 10:28:47 -07:00
process_audio(source, audio);
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
pthread_mutex_lock(&source->filter_mutex);
finish up most of the source audio stuff and rename some variables/structs/enum to be a bit more consistent
2013-10-31 10:28:47 -07:00
output = filter_async_audio(source, &source->audio_data);
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
if (output) {
Fix drawing bug with async video sources Before, async video sources would flicker because they were only being drawn when they were updated. So when updated, they'd draw that frame, then it would stop drawing it until it updated again. This fixes that issue and they should now draw properly. Also, fix a few other minor bugs and issues relating to async video, and make it so that non-async video filters can be properly applied to them. For the purposes of testing, change the 'test-random' source to an async video source that updates every quarter of a second with a new random face. Also fix a bug where non-async video sources wouldn't have filter effects applied properly.
2014-04-13 02:22:28 -07:00
bool async = (flags & OBS_SOURCE_ASYNC) != 0;
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
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
pthread_mutex_lock(&source->audio_mutex);
add support for texture_rect texture type in shaders, add new form, clear up a few things in the API
2013-12-20 10:56:01 -08:00
/* wait for video to start before outputting any audio so we
* have a base for sync */
Fix video reset and apply new video settings This allows the changing of bideo settings without having to completely reset all graphics data. Will recreate internal output/conversion buffers and such and reset the main preview.
2014-02-22 19:14:19 -08:00
if (source->timing_set || !async) {
finish up most of the source audio stuff and rename some variables/structs/enum to be a bit more consistent
2013-10-31 10:28:47 -07:00
struct audio_data data;
Add planar audio support, improve test output - Add planar audio support. FFmpeg and libav use planar audio for many encoders, so it was somewhat necessary to add support in libobs itself. - Improve/adjust FFmpeg test output plugin. The exports were somewhat messed up (making me rethink how exports should be done). Not yet functional; it handles video properly, but it still does not handle audio properly. - Improve planar video code. The planar video code was not properly accounting for row sizes for each plane. Specifying row sizes for each plane has now been added. This will also make it more compatible with FFmpeg/libav. - Fixed a bug where callbacks wouldn't create properly in audio-io and video-io code. - Implement 'blogva' function to allow for va_list usage with libobs logging.
2014-02-07 02:03:54 -08:00
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
for (int i = 0; i < MAX_AV_PLANES; i++)
Add planar audio support, improve test output - Add planar audio support. FFmpeg and libav use planar audio for many encoders, so it was somewhat necessary to add support in libobs itself. - Improve/adjust FFmpeg test output plugin. The exports were somewhat messed up (making me rethink how exports should be done). Not yet functional; it handles video properly, but it still does not handle audio properly. - Improve planar video code. The planar video code was not properly accounting for row sizes for each plane. Specifying row sizes for each plane has now been added. This will also make it more compatible with FFmpeg/libav. - Fixed a bug where callbacks wouldn't create properly in audio-io and video-io code. - Implement 'blogva' function to allow for va_list usage with libobs logging.
2014-02-07 02:03:54 -08:00
data.data[i] = output->data[i];
finish up most of the source audio stuff and rename some variables/structs/enum to be a bit more consistent
2013-10-31 10:28:47 -07:00
data.frames = output->frames;
data.timestamp = output->timestamp;
source_output_audio_line(source, &data);
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
}
pthread_mutex_unlock(&source->audio_mutex);
}
pthread_mutex_unlock(&source->filter_mutex);
}
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
static inline bool frame_out_of_bounds(obs_source_t source, uint64_t ts)
{
return ((ts - source->last_frame_ts) > MAX_TIMESTAMP_JUMP);
}
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
static bool ready_async_frame(obs_source_t source, uint64_t sys_time)
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
{
struct source_frame *next_frame = source->video_frames.array[0];
struct source_frame *frame = NULL;
uint64_t sys_offset = sys_time - source->last_sys_timestamp;
uint64_t frame_time = next_frame->timestamp;
uint64_t frame_offset = 0;
/* account for timestamp invalidation */
if (frame_out_of_bounds(source, frame_time)) {
source->last_frame_ts = next_frame->timestamp;
async vid.: Fix potential endless buffering issue If a source with async video wasn't currently active, it would endlessly buffer the video data, which would cause memory to grow endlessly until available memory was extinguished. This really needs to be replaced with a proper caching mechanism at some point.
2014-04-28 20:38:15 -07:00
os_atomic_inc_long(&source->av_sync_ref);
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
} else {
frame_offset = frame_time - source->last_frame_ts;
async vid.: Fix potential endless buffering issue If a source with async video wasn't currently active, it would endlessly buffer the video data, which would cause memory to grow endlessly until available memory was extinguished. This really needs to be replaced with a proper caching mechanism at some point.
2014-04-28 20:38:15 -07:00
source->last_frame_ts += frame_offset;
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
}
while (frame_offset <= sys_offset) {
source_frame_destroy(frame);
async vid.: Fix potential endless buffering issue If a source with async video wasn't currently active, it would endlessly buffer the video data, which would cause memory to grow endlessly until available memory was extinguished. This really needs to be replaced with a proper caching mechanism at some point.
2014-04-28 20:38:15 -07:00
if (source->video_frames.num == 1)
return true;
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
frame = next_frame;
da_erase(source->video_frames, 0);
next_frame = source->video_frames.array[0];
/* more timestamp checking and compensating */
if ((next_frame->timestamp - frame_time) > MAX_TIMESTAMP_JUMP) {
source->last_frame_ts =
next_frame->timestamp - frame_offset;
async vid.: Fix potential endless buffering issue If a source with async video wasn't currently active, it would endlessly buffer the video data, which would cause memory to grow endlessly until available memory was extinguished. This really needs to be replaced with a proper caching mechanism at some point.
2014-04-28 20:38:15 -07:00
os_atomic_inc_long(&source->av_sync_ref);
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
}
frame_time = next_frame->timestamp;
frame_offset = frame_time - source->last_frame_ts;
}
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
source_frame_destroy(frame);
async vid.: Fix potential endless buffering issue If a source with async video wasn't currently active, it would endlessly buffer the video data, which would cause memory to grow endlessly until available memory was extinguished. This really needs to be replaced with a proper caching mechanism at some point.
2014-04-28 20:38:15 -07:00
return frame != NULL;
}
static inline struct source_frame *get_closest_frame(obs_source_t source,
uint64_t sys_time)
{
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (ready_async_frame(source, sys_time)) {
async vid.: Fix potential endless buffering issue If a source with async video wasn't currently active, it would endlessly buffer the video data, which would cause memory to grow endlessly until available memory was extinguished. This really needs to be replaced with a proper caching mechanism at some point.
2014-04-28 20:38:15 -07:00
struct source_frame *frame = source->video_frames.array[0];
da_erase(source->video_frames, 0);
return frame;
}
return NULL;
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
}
make text lookup use a simple linked lists rather than an unnecessary array of pointers
2013-12-07 10:23:49 -08:00
/*
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
* Ensures that cached frames are displayed on time. If multiple frames
* were cached between renders, then releases the unnecessary frames and uses
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
* the frame with the closest timing to ensure sync. Also ensures that timing
* with audio is synchronized.
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
*/
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
struct source_frame *obs_source_getframe(obs_source_t source)
first commit
2013-09-30 19:37:13 -07:00
{
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
struct source_frame *frame = NULL;
uint64_t sys_time;
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
if (!source)
return NULL;
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
pthread_mutex_lock(&source->video_mutex);
if (!source->video_frames.num)
goto unlock;
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
sys_time = os_gettime_ns();
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
if (!source->last_frame_ts) {
frame = source->video_frames.array[0];
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
da_erase(source->video_frames, 0);
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
source->last_frame_ts = frame->timestamp;
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
} else {
async vid.: Fix potential endless buffering issue If a source with async video wasn't currently active, it would endlessly buffer the video data, which would cause memory to grow endlessly until available memory was extinguished. This really needs to be replaced with a proper caching mechanism at some point.
2014-04-28 20:38:15 -07:00
frame = get_closest_frame(source, sys_time);
Fix one minor bug with new timing code When the first async video frame is used it would not set audio timing, moved that code into obs_source_getframe. Also, might consider renaming obs_source_getframe. "Query frame" instead perhaps? Will sleep on it, might not even bother.
2014-01-12 02:24:01 -08:00
}
/* reset timing to current system time */
if (frame) {
source->timing_adjust = sys_time - frame->timestamp;
source->timing_set = true;
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
}
source->last_sys_timestamp = sys_time;
unlock:
pthread_mutex_unlock(&source->video_mutex);
made the getframe function a bit more safe and modified a few names for clarity
2013-11-22 15:18:31 -08:00
Add preliminary handling of timestamp invalidation - Add preliminary (yet to be tested) handling of timestamp invalidation issues that can happen with specific devices, where timestamps can reset or go backward/forward in time with no rhyme or reason. Spent the entire day just trying to figure out the best way to handle this. If both audio and video are present, it will increment a reference counter if video timestamps invalidate, and decrement the reference counter when the audio timestamps invalidate. When the reference counter is not 0, it will not send audio as the audio will have invalid timing. What this does is it ensures audio data will never go out of bounds in relation to the video, and waits for both audio and video timestamps to "jump" together before resuming audio. - Moved async video frame timing adjustment code into obs_source_getframe instead so it's automatically handled whenever called. - Removed the 'audio wait buffer' as it was an unnecessary complexity that could have had problems in the future. Instead, audio will not be added until video starts for sources that have both async audio/video. Audio could have buffered for too long of a time anyway, who knows what devices are going to do. - Fixed a minor conversion warning in audio-io.c
2014-01-12 01:40:51 -08:00
if (frame)
made the getframe function a bit more safe and modified a few names for clarity
2013-11-22 15:18:31 -08:00
obs_source_addref(source);
fill out the rest of the source video frame functions, added nv12 decompression function, and cleaned up the design of the source video frame stuff
2013-10-26 14:32:06 -07:00
return frame;
first commit
2013-09-30 19:37:13 -07:00
}
added intial async audio/video code, fixed a few bugs, improved thread safety, and made a few other minor adjustments
2013-10-24 00:57:55 -07:00
void obs_source_releaseframe(obs_source_t source, struct source_frame *frame)
first commit
2013-09-30 19:37:13 -07:00
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
if (source && frame) {
made the getframe function a bit more safe and modified a few names for clarity
2013-11-22 15:18:31 -08:00
source_frame_destroy(frame);
obs_source_release(source);
}
first commit
2013-09-30 19:37:13 -07:00
}
add obs_source functions to allow name manipulation and lookup based upon name, and a few other functions related to getting/setting source information
2013-12-20 18:35:12 -08:00
const char *obs_source_getname(obs_source_t source)
{
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
return source ? source->context.name : NULL;
add obs_source functions to allow name manipulation and lookup based upon name, and a few other functions related to getting/setting source information
2013-12-20 18:35:12 -08:00
}
void obs_source_setname(obs_source_t source, const char *name)
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
if (!source) return;
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
obs_context_data_setname(&source->context, name);
add obs_source functions to allow name manipulation and lookup based upon name, and a few other functions related to getting/setting source information
2013-12-20 18:35:12 -08:00
}
implement scene adding callbacks, make a few API tweaks
2013-12-28 04:33:16 -08:00
void obs_source_gettype(obs_source_t source, enum obs_source_type *type,
add obs_source functions to allow name manipulation and lookup based upon name, and a few other functions related to getting/setting source information
2013-12-20 18:35:12 -08:00
const char **id)
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
if (!source) return;
Implement volume handling - Remove obs_source::type because it became redundant now that the type is always stored in the obs_source::info variable. - Apply presentation volumes of 1.0 and 0.0 to sources when they activate/deactivate, respectively. It also applies that presentation volume to all sub-sources, with exception of transition sources. Transition sources must apply presentation volume manually to their sub-sources with the new transition functions below. - Add a "transition_volume" variable to obs_source structure, and add three functions for handling volume for transitions: * obs_transition_begin_frame * obs_source_set_transition_vol * obs_transition_end_frame Because the to/from targets of a transition source might both contain some of the same sources, handling the transitioning of volumes for that specific situation becomes an issue. So for transitions, instead of modifying the presentation volumes directly for both sets of sources, we do this: - First, call obs_transition_begin_frame at the beginning of each transition frame, which will reset transition volumes for all sub-sources to 0. Presentation volumes remain unchanged. - Call obs_source_set_transition_vol on each sub-source, which will then add the volume to the transition volume for each source in that source's tree. Presentation volumes still remain unchanged. - Then you call obs_trandition_end_frame when complete, which will then finally set the presentation volumes to the transition volumes. For example, let's say that there's one source that's within both the "transitioning from" sources and "transition to" sources. It would add both the fade in and fade out volumes to that source, and then when the frame is complete, it would set the presentation volume to the sum of those two values, rather than set the presentation volume for that same source twice which would cause weird volume jittering and also set the wrong values.
2014-02-21 18:41:38 -08:00
if (type) *type = source->info.type;
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
if (id) *id = source->info.id;
add obs_source functions to allow name manipulation and lookup based upon name, and a few other functions related to getting/setting source information
2013-12-20 18:35:12 -08:00
}
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
static inline void render_filter_bypass(obs_source_t target, effect_t effect,
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
bool use_matrix)
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -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
const char *tech_name = use_matrix ? "DrawMatrix" : "Draw";
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
technique_t tech = effect_gettechnique(effect, tech_name);
size_t passes, i;
passes = technique_begin(tech);
for (i = 0; i < passes; i++) {
technique_beginpass(tech, i);
obs_source_video_render(target);
technique_endpass(tech);
}
technique_end(tech);
}
static inline void render_filter_tex(texture_t tex, effect_t effect,
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
uint32_t width, uint32_t height, bool use_matrix)
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -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
const char *tech_name = use_matrix ? "DrawMatrix" : "Draw";
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
technique_t tech = effect_gettechnique(effect, tech_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
eparam_t image = effect_getparambyname(effect, "image");
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
size_t passes, i;
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
effect_settexture(effect, image, tex);
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
passes = technique_begin(tech);
for (i = 0; i < passes; i++) {
technique_beginpass(tech, i);
gs_draw_sprite(tex, width, height, 0);
technique_endpass(tech);
}
technique_end(tech);
}
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_source_process_filter(obs_source_t filter, effect_t effect,
uint32_t width, uint32_t height, enum gs_color_format format,
make direct filter rendering optional (can be useful for certain cases)
2013-12-22 01:03:40 -08:00
enum allow_direct_render allow_direct)
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
obs_source_t target, parent;
uint32_t target_flags, parent_flags;
int cx, cy;
bool use_matrix, expects_def, can_directly;
if (!filter) return;
target = obs_filter_gettarget(filter);
parent = obs_filter_getparent(filter);
target_flags = target->info.output_flags;
parent_flags = parent->info.output_flags;
cx = obs_source_getwidth(target);
cy = obs_source_getheight(target);
use_matrix = !!(target_flags & OBS_SOURCE_COLOR_MATRIX);
expects_def = !(parent_flags & OBS_SOURCE_CUSTOM_DRAW);
can_directly = allow_direct == ALLOW_DIRECT_RENDERING;
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
/* if the parent does not use any custom effects, and this is the last
* filter in the chain for the parent, then render the parent directly
* using the filter effect instead of rendering to texture to reduce
* the total number of passes */
make direct filter rendering optional (can be useful for certain cases)
2013-12-22 01:03:40 -08:00
if (can_directly && expects_def && target == parent) {
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
render_filter_bypass(target, effect, use_matrix);
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
return;
}
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
if (!filter->filter_texrender)
filter->filter_texrender = texrender_create(format,
GS_ZS_NONE);
if (texrender_begin(filter->filter_texrender, cx, cy)) {
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
gs_ortho(0.0f, (float)cx, 0.0f, (float)cy, -100.0f, 100.0f);
make direct filter rendering optional (can be useful for certain cases)
2013-12-22 01:03:40 -08:00
if (expects_def && parent == target)
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_source_default_render(parent, use_matrix);
make direct filter rendering optional (can be useful for certain cases)
2013-12-22 01:03:40 -08:00
else
obs_source_video_render(target);
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
texrender_end(filter->filter_texrender);
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -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
render_filter_tex(texrender_gettexture(filter->filter_texrender),
effect, width, height, use_matrix);
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
}
implement signal/procedure handling into libobs and individual sources
2013-12-26 22:10:15 -08:00
signal_handler_t obs_source_signalhandler(obs_source_t source)
{
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
return source ? source->context.signals : NULL;
implement signal/procedure handling into libobs and individual sources
2013-12-26 22:10:15 -08:00
}
proc_handler_t obs_source_prochandler(obs_source_t source)
{
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
return source ? source->context.procs : NULL;
implement signal/procedure handling into libobs and individual sources
2013-12-26 22:10:15 -08:00
}
Implement volumes for sources - Added a volume variable to the obs_source structure and implemented functions for manipulating source volume. - Added a volume variable to the audio_data structure so that the volume will be applied when mixing.
2014-01-07 10:03:15 -08:00
void obs_source_setvolume(obs_source_t source, float volume)
{
Add volume signals
2014-02-21 16:51:16 -08:00
if (source) {
struct calldata data = {0};
calldata_setptr(&data, "source", source);
calldata_setfloat(&data, "volume", volume);
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
signal_handler_signal(source->context.signals, "volume", &data);
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
signal_handler_signal(obs->signals, "source_volume", &data);
Add volume signals
2014-02-21 16:51:16 -08:00
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
volume = (float)calldata_float(&data, "volume");
Add volume signals
2014-02-21 16:51:16 -08:00
calldata_free(&data);
Add source audio sync offset setting
2014-02-20 15:16:25 -08:00
source->user_volume = volume;
Add volume signals
2014-02-21 16:51:16 -08:00
}
Add more volume options Added a "master" volume for the entire audio subsystem. Also, added a "presentation" volume for both the master volume and for each invidiaul source. The presentation volume is used to control things like transitioning volumes, preventing sources from outputting any audio when they're inactive, as well as some other uses in the future.
2014-02-20 14:53:16 -08:00
}
Implement volume handling - Remove obs_source::type because it became redundant now that the type is always stored in the obs_source::info variable. - Apply presentation volumes of 1.0 and 0.0 to sources when they activate/deactivate, respectively. It also applies that presentation volume to all sub-sources, with exception of transition sources. Transition sources must apply presentation volume manually to their sub-sources with the new transition functions below. - Add a "transition_volume" variable to obs_source structure, and add three functions for handling volume for transitions: * obs_transition_begin_frame * obs_source_set_transition_vol * obs_transition_end_frame Because the to/from targets of a transition source might both contain some of the same sources, handling the transitioning of volumes for that specific situation becomes an issue. So for transitions, instead of modifying the presentation volumes directly for both sets of sources, we do this: - First, call obs_transition_begin_frame at the beginning of each transition frame, which will reset transition volumes for all sub-sources to 0. Presentation volumes remain unchanged. - Call obs_source_set_transition_vol on each sub-source, which will then add the volume to the transition volume for each source in that source's tree. Presentation volumes still remain unchanged. - Then you call obs_trandition_end_frame when complete, which will then finally set the presentation volumes to the transition volumes. For example, let's say that there's one source that's within both the "transitioning from" sources and "transition to" sources. It would add both the fade in and fade out volumes to that source, and then when the frame is complete, it would set the presentation volume to the sum of those two values, rather than set the presentation volume for that same source twice which would cause weird volume jittering and also set the wrong values.
2014-02-21 18:41:38 -08:00
static void set_tree_preset_vol(obs_source_t parent, obs_source_t child,
void *param)
{
float *vol = param;
child->present_volume = *vol;
UNUSED_PARAMETER(parent);
}
Add more volume options Added a "master" volume for the entire audio subsystem. Also, added a "presentation" volume for both the master volume and for each invidiaul source. The presentation volume is used to control things like transitioning volumes, preventing sources from outputting any audio when they're inactive, as well as some other uses in the future.
2014-02-20 14:53:16 -08:00
void obs_source_set_present_volume(obs_source_t source, float volume)
{
Implement volume handling - Remove obs_source::type because it became redundant now that the type is always stored in the obs_source::info variable. - Apply presentation volumes of 1.0 and 0.0 to sources when they activate/deactivate, respectively. It also applies that presentation volume to all sub-sources, with exception of transition sources. Transition sources must apply presentation volume manually to their sub-sources with the new transition functions below. - Add a "transition_volume" variable to obs_source structure, and add three functions for handling volume for transitions: * obs_transition_begin_frame * obs_source_set_transition_vol * obs_transition_end_frame Because the to/from targets of a transition source might both contain some of the same sources, handling the transitioning of volumes for that specific situation becomes an issue. So for transitions, instead of modifying the presentation volumes directly for both sets of sources, we do this: - First, call obs_transition_begin_frame at the beginning of each transition frame, which will reset transition volumes for all sub-sources to 0. Presentation volumes remain unchanged. - Call obs_source_set_transition_vol on each sub-source, which will then add the volume to the transition volume for each source in that source's tree. Presentation volumes still remain unchanged. - Then you call obs_trandition_end_frame when complete, which will then finally set the presentation volumes to the transition volumes. For example, let's say that there's one source that's within both the "transitioning from" sources and "transition to" sources. It would add both the fade in and fade out volumes to that source, and then when the frame is complete, it would set the presentation volume to the sum of those two values, rather than set the presentation volume for that same source twice which would cause weird volume jittering and also set the wrong values.
2014-02-21 18:41:38 -08:00
if (source) {
Add source audio sync offset setting
2014-02-20 15:16:25 -08:00
source->present_volume = volume;
Implement volume handling - Remove obs_source::type because it became redundant now that the type is always stored in the obs_source::info variable. - Apply presentation volumes of 1.0 and 0.0 to sources when they activate/deactivate, respectively. It also applies that presentation volume to all sub-sources, with exception of transition sources. Transition sources must apply presentation volume manually to their sub-sources with the new transition functions below. - Add a "transition_volume" variable to obs_source structure, and add three functions for handling volume for transitions: * obs_transition_begin_frame * obs_source_set_transition_vol * obs_transition_end_frame Because the to/from targets of a transition source might both contain some of the same sources, handling the transitioning of volumes for that specific situation becomes an issue. So for transitions, instead of modifying the presentation volumes directly for both sets of sources, we do this: - First, call obs_transition_begin_frame at the beginning of each transition frame, which will reset transition volumes for all sub-sources to 0. Presentation volumes remain unchanged. - Call obs_source_set_transition_vol on each sub-source, which will then add the volume to the transition volume for each source in that source's tree. Presentation volumes still remain unchanged. - Then you call obs_trandition_end_frame when complete, which will then finally set the presentation volumes to the transition volumes. For example, let's say that there's one source that's within both the "transitioning from" sources and "transition to" sources. It would add both the fade in and fade out volumes to that source, and then when the frame is complete, it would set the presentation volume to the sum of those two values, rather than set the presentation volume for that same source twice which would cause weird volume jittering and also set the wrong values.
2014-02-21 18:41:38 -08:00
/* don't set the presentation volume of the tree if a
* transition source, let the transition handle presentation
* volume for the child sources itself. */
if (source->info.type != OBS_SOURCE_TYPE_TRANSITION)
obs_source_enum_tree(source, set_tree_preset_vol,
&volume);
}
Implement volumes for sources - Added a volume variable to the obs_source structure and implemented functions for manipulating source volume. - Added a volume variable to the audio_data structure so that the volume will be applied when mixing.
2014-01-07 10:03:15 -08:00
}
float obs_source_getvolume(obs_source_t source)
{
Add source audio sync offset setting
2014-02-20 15:16:25 -08:00
return source ? source->user_volume : 0.0f;
Add more volume options Added a "master" volume for the entire audio subsystem. Also, added a "presentation" volume for both the master volume and for each invidiaul source. The presentation volume is used to control things like transitioning volumes, preventing sources from outputting any audio when they're inactive, as well as some other uses in the future.
2014-02-20 14:53:16 -08:00
}
float obs_source_get_present_volume(obs_source_t source)
{
Add source audio sync offset setting
2014-02-20 15:16:25 -08:00
return source ? source->present_volume : 0.0f;
}
void obs_source_set_sync_offset(obs_source_t source, int64_t offset)
{
if (source)
source->sync_offset = offset;
}
int64_t obs_source_get_sync_offset(obs_source_t source)
{
return source ? source->sync_offset : 0;
Implement volumes for sources - Added a volume variable to the obs_source structure and implemented functions for manipulating source volume. - Added a volume variable to the audio_data structure so that the volume will be applied when mixing.
2014-01-07 10:03:15 -08:00
}
Add functions to enumerate source children/tree
2014-02-20 16:44:42 -08:00
struct source_enum_data {
obs_source_enum_proc_t enum_callback;
void *param;
};
static void enum_source_tree_callback(obs_source_t parent, obs_source_t child,
void *param)
{
struct source_enum_data *data = param;
if (child->info.enum_sources && !child->enum_refs) {
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
os_atomic_inc_long(&child->enum_refs);
Add functions to enumerate source children/tree
2014-02-20 16:44:42 -08:00
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (child->context.data)
child->info.enum_sources(child->context.data,
enum_source_tree_callback, data);
Add functions to enumerate source children/tree
2014-02-20 16:44:42 -08:00
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
os_atomic_dec_long(&child->enum_refs);
Add functions to enumerate source children/tree
2014-02-20 16:44:42 -08:00
}
data->enum_callback(parent, child, data->param);
}
void obs_source_enum_sources(obs_source_t source,
obs_source_enum_proc_t enum_callback,
void *param)
{
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (!source_valid(source) ||
!source->info.enum_sources ||
source->enum_refs)
Add functions to enumerate source children/tree
2014-02-20 16:44:42 -08:00
return;
obs_source_addref(source);
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
os_atomic_inc_long(&source->enum_refs);
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
source->info.enum_sources(source->context.data, enum_callback, param);
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
os_atomic_dec_long(&source->enum_refs);
Add functions to enumerate source children/tree
2014-02-20 16:44:42 -08:00
obs_source_release(source);
}
void obs_source_enum_tree(obs_source_t source,
obs_source_enum_proc_t enum_callback,
void *param)
{
struct source_enum_data data = {enum_callback, param};
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (!source_valid(source) ||
!source->info.enum_sources ||
source->enum_refs)
Add functions to enumerate source children/tree
2014-02-20 16:44:42 -08:00
return;
obs_source_addref(source);
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
os_atomic_inc_long(&source->enum_refs);
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
source->info.enum_sources(source->context.data,
enum_source_tree_callback,
Add functions to enumerate source children/tree
2014-02-20 16:44:42 -08:00
&data);
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
os_atomic_dec_long(&source->enum_refs);
Add functions to enumerate source children/tree
2014-02-20 16:44:42 -08:00
obs_source_release(source);
}
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
void obs_source_add_child(obs_source_t parent, obs_source_t child)
{
if (!parent || !child) return;
Separate source activation for main/aux views Split off activate to activate and show callbacks, and split off deactivate to deactivate and hide callbacks. Sources didn't previously have a means to know whether it was actually being displayed in the main view or just happened to be visible somewhere. Now, for things like transition sources, they have a means of knowing when they have actually been "activated" so they can initiate their sequence. A source is now only considered "active" when it's being displayed by the main view. When a source is shown in the main view, the activate callback/signal is triggered. When it's no longer being displayed by the main view, deactivate callback/signal is triggered. When a source is just generally visible to see by any view, the show callback/signal is triggered. If it's no longer visible by any views, then the hide callback/signal is triggered. Presentation volume will now only be active when a source is active in the main view rather than also in auxilary views. Also fix a potential bug where parents wouldn't properly increment or decrement all the activation references of a child source when a child was added or removed.
2014-02-23 16:46:00 -08:00
for (int i = 0; i < parent->show_refs; i++) {
enum view_type type;
type = (i < parent->activate_refs) ? MAIN_VIEW : AUX_VIEW;
obs_source_activate(child, type);
}
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
}
void obs_source_remove_child(obs_source_t parent, obs_source_t child)
{
if (!parent || !child) return;
Separate source activation for main/aux views Split off activate to activate and show callbacks, and split off deactivate to deactivate and hide callbacks. Sources didn't previously have a means to know whether it was actually being displayed in the main view or just happened to be visible somewhere. Now, for things like transition sources, they have a means of knowing when they have actually been "activated" so they can initiate their sequence. A source is now only considered "active" when it's being displayed by the main view. When a source is shown in the main view, the activate callback/signal is triggered. When it's no longer being displayed by the main view, deactivate callback/signal is triggered. When a source is just generally visible to see by any view, the show callback/signal is triggered. If it's no longer visible by any views, then the hide callback/signal is triggered. Presentation volume will now only be active when a source is active in the main view rather than also in auxilary views. Also fix a potential bug where parents wouldn't properly increment or decrement all the activation references of a child source when a child was added or removed.
2014-02-23 16:46:00 -08:00
for (int i = 0; i < parent->show_refs; i++) {
enum view_type type;
type = (i < parent->activate_refs) ? MAIN_VIEW : AUX_VIEW;
obs_source_deactivate(child, type);
}
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
}
Implement volume handling - Remove obs_source::type because it became redundant now that the type is always stored in the obs_source::info variable. - Apply presentation volumes of 1.0 and 0.0 to sources when they activate/deactivate, respectively. It also applies that presentation volume to all sub-sources, with exception of transition sources. Transition sources must apply presentation volume manually to their sub-sources with the new transition functions below. - Add a "transition_volume" variable to obs_source structure, and add three functions for handling volume for transitions: * obs_transition_begin_frame * obs_source_set_transition_vol * obs_transition_end_frame Because the to/from targets of a transition source might both contain some of the same sources, handling the transitioning of volumes for that specific situation becomes an issue. So for transitions, instead of modifying the presentation volumes directly for both sets of sources, we do this: - First, call obs_transition_begin_frame at the beginning of each transition frame, which will reset transition volumes for all sub-sources to 0. Presentation volumes remain unchanged. - Call obs_source_set_transition_vol on each sub-source, which will then add the volume to the transition volume for each source in that source's tree. Presentation volumes still remain unchanged. - Then you call obs_trandition_end_frame when complete, which will then finally set the presentation volumes to the transition volumes. For example, let's say that there's one source that's within both the "transitioning from" sources and "transition to" sources. It would add both the fade in and fade out volumes to that source, and then when the frame is complete, it would set the presentation volume to the sum of those two values, rather than set the presentation volume for that same source twice which would cause weird volume jittering and also set the wrong values.
2014-02-21 18:41:38 -08:00
static void reset_transition_vol(obs_source_t parent, obs_source_t child,
void *param)
{
child->transition_volume = 0.0f;
UNUSED_PARAMETER(parent);
UNUSED_PARAMETER(param);
}
static void add_transition_vol(obs_source_t parent, obs_source_t child,
void *param)
{
float *vol = param;
child->transition_volume += *vol;
UNUSED_PARAMETER(parent);
}
static void apply_transition_vol(obs_source_t parent, obs_source_t child,
void *param)
{
child->present_volume = child->transition_volume;
UNUSED_PARAMETER(parent);
UNUSED_PARAMETER(param);
}
void obs_transition_begin_frame(obs_source_t transition)
{
if (!transition) return;
obs_source_enum_tree(transition, reset_transition_vol, NULL);
}
void obs_source_set_transition_vol(obs_source_t source, float vol)
{
if (!source) return;
add_transition_vol(NULL, source, &vol);
obs_source_enum_tree(source, add_transition_vol, &vol);
}
void obs_transition_end_frame(obs_source_t transition)
{
if (!transition) return;
obs_source_enum_tree(transition, apply_transition_vol, NULL);
}
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
void obs_source_save(obs_source_t source)
{
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (!source_valid(source) || !source->info.save) return;
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
source->info.save(source->context.data, source->context.settings);
}
void obs_source_load(obs_source_t source)
{
obs-source.c: Fix a few potential concerns First, if the private data of the source fails to be created, then do not destroy the source. If the source is destroyed, all the user's data associated with that source is lost, which could end up being a potential problem. Instead, let it linger as a 'dead' source until the user chooses to fix the problem (though this should never really happen, the source module functions should be programmed to handle this scenario) Secondly, rename new_frame_ready to ready_async_frame, and fix a potential memory leak with it.
2014-05-04 16:20:11 -07:00
if (!source_valid(source) || !source->info.load) return;
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
source->info.load(source->context.data, source->context.settings);
}