OBS/obs-studio
OBS/obs-studio
1
0
Fork 0
mirror of https://github.com/obsproject/obs-studio.git synced 2024-07-19 17:49:14 +00:00
Code Issues Packages Projects Releases Wiki Activity
obs-studio/libobs/obs-output.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

3306 lines
86 KiB
C
Raw Normal View History

first commit
2013-10-01 02:37:13 +00:00
/******************************************************************************
Update copyrights/names
2023-05-19 00:37:26 +00:00
Copyright (C) 2023 by Lain Bailey <lain@obsproject.com>
first commit
2013-10-01 02:37:13 +00: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-03 05:24:38 +00:00
the Free Software Foundation, either version 2 of the License, or
first commit
2013-10-01 02:37:13 +00: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/>.
******************************************************************************/
Log total/skipped frames on output stop This makes it easier to do two things: 1.) Get the skipped frames count relative to each specific output 2.) Make it so that getting the 'current' log will always contain information about skipped frames. Before, you'd have to force the user to restart the program and get the last log, which was really annoying when you just wanted to see how the encoders were performing.
2014-08-25 00:32:44 +00:00
#include <inttypes.h>
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
#include "util/platform.h"
libobs: Implement and use better scaling function for 64-bit integers As os_gettime_ns() gets large the current scaling methods, mostly by casting to uint64_t, may lead to numerical overflows. Sweep the code and use util_mul_div64() where applicable. Signed-off-by: Hans Petter Selasky <hps@selasky.org>
2020-03-21 09:55:12 +00:00
#include "util/util_uint64.h"
libobs: Improve exponential backoff functionality - Changes the default base exponent value to 1.5 from 2.0 - Applies a random skew of +-0.05 to the exponent to lessen the "water hammer" effect caused by predictable backoff techniques - Fixes the logging associated with exponential backoff to log the true reconnect delay value
2022-06-25 23:19:48 +00:00
#include "graphics/math-extra.h"
first commit
2013-10-01 02:37:13 +00:00
#include "obs.h"
Rename obs-data.h to obs-internal.h Renaming obs-data.h to avoid confusion about its usage
2014-01-27 01:48:14 +00:00
#include "obs-internal.h"
libobs: Add caption support for AV1 Extract the itut_t35 caption data buffer from existing caption data and repackage in a metadata OBU instead of an AVC/HEVC SEI.
2024-03-11 21:06:33 +00:00
#include "obs-av1.h"
first commit
2013-10-01 02:37:13 +00:00
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
#include <caption/caption.h>
libobs: Update libcaption library (This commit also modifies deps/libcaption) Closes obsproject/obs-studio#1354
2018-06-28 18:22:44 +00:00
#include <caption/mpeg.h>
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
libobs: Add obs_object abstraction and functions With this, you can now cast normal obs objects (services, outputs, sources, encoders) to an obs_object_t, and then use obs_object_* functions to get references, release references, and similar for weak object references as well. This allows the ability for the frontend to use an object of any of those types interchangeably in certain situations without having to handle each specific type individually. This is useful because the properties view in particular doesn't care what type of object it uses, it just needs to be able to hold weak references to abstract OBS objects.
2022-02-03 05:56:30 +00:00
#define get_weak(output) ((obs_weak_output_t *)output->context.control)
libobs: Improve exponential backoff functionality - Changes the default base exponent value to 1.5 from 2.0 - Applies a random skew of +-0.05 to the exponent to lessen the "water hammer" effect caused by predictable backoff techniques - Fixes the logging associated with exponential backoff to log the true reconnect delay value
2022-06-25 23:19:48 +00:00
#define RECONNECT_RETRY_MAX_MSEC (15 * 60 * 1000)
libobs: Fix warnings about type usage
2022-06-26 07:28:00 +00:00
#define RECONNECT_RETRY_BASE_EXP 1.5f
libobs: Improve exponential backoff functionality - Changes the default base exponent value to 1.5 from 2.0 - Applies a random skew of +-0.05 to the exponent to lessen the "water hammer" effect caused by predictable backoff techniques - Fixes the logging associated with exponential backoff to log the true reconnect delay value
2022-06-25 23:19:48 +00:00
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
static inline bool active(const struct obs_output *output)
{
return os_atomic_load_bool(&output->active);
}
static inline bool reconnecting(const struct obs_output *output)
{
return os_atomic_load_bool(&output->reconnecting);
}
libobs: Do not allow output stop calls more than once
2016-06-21 00:09:21 +00:00
static inline bool stopping(const struct obs_output *output)
{
return os_event_try(output->stopping_event) == EAGAIN;
}
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
static inline bool delay_active(const struct obs_output *output)
{
return os_atomic_load_bool(&output->delay_active);
}
static inline bool delay_capturing(const struct obs_output *output)
{
return os_atomic_load_bool(&output->delay_capturing);
}
libobs: Move output/encoder shutdown to independent thread obs_output_end_data_capture could cause a hard lock due to mutex lock ordering, depending on what thread it was called in.
2016-06-22 00:25:26 +00:00
static inline bool data_capture_ending(const struct obs_output *output)
{
return os_atomic_load_bool(&output->end_data_capture_thread_active);
}
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
static inline bool flag_encoded(const struct obs_output *output)
{
return (output->info.flags & OBS_OUTPUT_ENCODED) != 0;
}
static inline bool log_flag_encoded(const struct obs_output *output,
const char *func_name, bool inverse_log)
{
const char *prefix = inverse_log ? "n encoded" : " raw";
bool ret = flag_encoded(output);
if ((!inverse_log && !ret) || (inverse_log && ret))
blog(LOG_WARNING, "Output '%s': Tried to use %s on a%s output",
output->context.name, func_name, prefix);
return ret;
}
static inline bool flag_video(const struct obs_output *output)
{
return (output->info.flags & OBS_OUTPUT_VIDEO) != 0;
}
static inline bool log_flag_video(const struct obs_output *output,
const char *func_name)
{
bool ret = flag_video(output);
if (!ret)
blog(LOG_WARNING,
"Output '%s': Tried to use %s on a non-video output",
output->context.name, func_name);
return ret;
}
static inline bool flag_audio(const struct obs_output *output)
{
return (output->info.flags & OBS_OUTPUT_AUDIO) != 0;
}
static inline bool log_flag_audio(const struct obs_output *output,
const char *func_name)
{
bool ret = flag_audio(output);
if (!ret)
blog(LOG_WARNING,
"Output '%s': Tried to use %s on a non-audio output",
output->context.name, func_name);
return ret;
}
static inline bool flag_service(const struct obs_output *output)
{
return (output->info.flags & OBS_OUTPUT_SERVICE) != 0;
}
static inline bool log_flag_service(const struct obs_output *output,
const char *func_name)
{
bool ret = flag_service(output);
if (!ret)
blog(LOG_WARNING,
"Output '%s': Tried to use %s on a non-service output",
output->context.name, func_name);
return ret;
}
Check for duplicate sources/outputs/encoders/etc With the recent change to module handling by BtbN, I felt that having this information might be useful in case someone is actually using make install to set up their libraries.
2014-07-28 23:08:56 +00:00
const struct obs_output_info *find_output(const char *id)
first commit
2013-10-01 02:37:13 +00:00
{
size_t i;
for (i = 0; i < obs->output_types.num; i++)
add names to sources, use 'id' for the internal source identifier names rather than 'name'
2013-12-21 00:23:19 +00:00
if (strcmp(obs->output_types.array[i].id, id) == 0)
first commit
2013-10-01 02:37:13 +00:00
return obs->output_types.array + i;
return NULL;
}
(API Change) Unsquish libobs (base) names Previous names: New names: ----------------------------------------------------------- obs_view_setsource obs_view_set_source obs_view_getsource obs_view_get_source obs_source_getdisplayname obs_source_get_display_name obs_source_getwidth obs_source_get_width obs_source_getheight obs_source_get_height obs_filter_getparent obs_filter_get_parent obs_filter_gettarget obs_filter_get_target obs_source_filter_setorder obs_source_filter_set_order obs_source_getsettings obs_source_get_settings obs_source_getname obs_source_get_name obs_source_setname obs_source_set_name obs_source_setvolume obs_source_set_volume obs_source_getvolume obs_source_get_volume obs_scene_getsource obs_scene_get_source obs_scene_fromsource obs_scene_from_source obs_scene_findsource obs_scene_find_source obs_output_getdisplayname obs_output_get_display_name obs_output_getname obs_output_get_name obs_encoder_getname obs_encoder_get_name obs_service_getdisplayname obs_service_get_display_name obs_service_getname obs_service_get_name
2014-08-04 15:41:15 +00:00
const char *obs_output_get_display_name(const char *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-20 03:38:53 +00:00
{
const struct obs_output_info *info = find_output(id);
(API Change) libobs: Pass type data to get_name callbacks API changed from: obs_source_info::get_name(void) obs_output_info::get_name(void) obs_encoder_info::get_name(void) obs_service_info::get_name(void) API changed to: obs_source_info::get_name(void *type_data) obs_output_info::get_name(void *type_data) obs_encoder_info::get_name(void *type_data) obs_service_info::get_name(void *type_data) This allows the type data to be used when getting the name of the object (useful for plugin wrappers primarily). NOTE: Though a parameter was added, this is backward-compatible with older plugins due to calling convention. The new parameter will simply be ignored by older plugins, and the stack (if used) will be cleaned up by the caller.
2015-09-16 08:30:51 +00:00
return (info != NULL) ? info->get_name(info->type_data) : 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-20 03:38:53 +00:00
}
Add preliminary FLV/RTMP output (incomplete) - obs-outputs module: Add preliminary code to send out data, and add an FLV muxer. This time we don't really need to build the packets ourselves, we can just use the FLV muxer and send it directly to RTMP_Write and it should automatically parse the entire stream for us without us having to do much manual code at all. We'll see how it goes. - libobs: Add AVC NAL packet parsing code - libobs/media-io: Add quick helper functions for audio/video to get the width/height/fps/samplerate/etc rather than having to query the info structures each time. - libobs (obs-output.c): Change 'connect' signal to 'start' and 'stop' signals. 'start' now specifies an error code rather than whether it simply failed, that way the client can actually know *why* a failure occurred. Added those error codes to obs-defs.h. - libobs: Add a few functions to duplicate/free encoder packets
2014-04-01 18:55:18 +00:00
static const char *output_signals[] = {
UI: Add popup warnings for connection failure Also, check for null stream path/key in the RTMP output module.
2014-05-12 22:30:36 +00:00
"void start(ptr output)",
"void stop(ptr output, int code)",
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
"void pause(ptr output)",
"void unpause(ptr output)",
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
"void starting(ptr output)",
"void stopping(ptr output)",
libobs: Add activate/deactivate output signals Indicates when an output is considered active/inactive.
2015-09-10 18:02:20 +00:00
"void activate(ptr output)",
"void deactivate(ptr output)",
UI: Add popup warnings for connection failure Also, check for null stream path/key in the RTMP output module.
2014-05-12 22:30:36 +00:00
"void reconnect(ptr output)",
"void reconnect_success(ptr output)",
Add preliminary FLV/RTMP output (incomplete) - obs-outputs module: Add preliminary code to send out data, and add an FLV muxer. This time we don't really need to build the packets ourselves, we can just use the FLV muxer and send it directly to RTMP_Write and it should automatically parse the entire stream for us without us having to do much manual code at all. We'll see how it goes. - libobs: Add AVC NAL packet parsing code - libobs/media-io: Add quick helper functions for audio/video to get the width/height/fps/samplerate/etc rather than having to query the info structures each time. - libobs (obs-output.c): Change 'connect' signal to 'start' and 'stop' signals. 'start' now specifies an error code rather than whether it simply failed, that way the client can actually know *why* a failure occurred. Added those error codes to obs-defs.h. - libobs: Add a few functions to duplicate/free encoder packets
2014-04-01 18:55:18 +00: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-20 03:38:53 +00:00
static bool init_output_handlers(struct obs_output *output, const char *name,
(API Change) libobs: Add hotkey data to *_create functions
2014-11-01 20:41:17 +00:00
obs_data_t *settings, obs_data_t *hotkey_data)
Add preliminary FLV/RTMP output (incomplete) - obs-outputs module: Add preliminary code to send out data, and add an FLV muxer. This time we don't really need to build the packets ourselves, we can just use the FLV muxer and send it directly to RTMP_Write and it should automatically parse the entire stream for us without us having to do much manual code at all. We'll see how it goes. - libobs: Add AVC NAL packet parsing code - libobs/media-io: Add quick helper functions for audio/video to get the width/height/fps/samplerate/etc rather than having to query the info structures each time. - libobs (obs-output.c): Change 'connect' signal to 'start' and 'stop' signals. 'start' now specifies an error code rather than whether it simply failed, that way the client can actually know *why* a failure occurred. Added those error codes to obs-defs.h. - libobs: Add a few functions to duplicate/free encoder packets
2014-04-01 18:55:18 +00:00
{
libobs: Add function to get obs object type
2016-02-27 02:18:00 +00:00
if (!obs_context_data_init(&output->context, OBS_OBJ_TYPE_OUTPUT,
libobs: Add UUIDs to obs_source objects
2023-02-25 14:01:17 +00:00
settings, name, NULL, hotkey_data, false))
Add preliminary FLV/RTMP output (incomplete) - obs-outputs module: Add preliminary code to send out data, and add an FLV muxer. This time we don't really need to build the packets ourselves, we can just use the FLV muxer and send it directly to RTMP_Write and it should automatically parse the entire stream for us without us having to do much manual code at all. We'll see how it goes. - libobs: Add AVC NAL packet parsing code - libobs/media-io: Add quick helper functions for audio/video to get the width/height/fps/samplerate/etc rather than having to query the info structures each time. - libobs (obs-output.c): Change 'connect' signal to 'start' and 'stop' signals. 'start' now specifies an error code rather than whether it simply failed, that way the client can actually know *why* a failure occurred. Added those error codes to obs-defs.h. - libobs: Add a few functions to duplicate/free encoder packets
2014-04-01 18:55:18 +00: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-20 03:38:53 +00:00
signal_handler_add_array(output->context.signals, output_signals);
Add preliminary FLV/RTMP output (incomplete) - obs-outputs module: Add preliminary code to send out data, and add an FLV muxer. This time we don't really need to build the packets ourselves, we can just use the FLV muxer and send it directly to RTMP_Write and it should automatically parse the entire stream for us without us having to do much manual code at all. We'll see how it goes. - libobs: Add AVC NAL packet parsing code - libobs/media-io: Add quick helper functions for audio/video to get the width/height/fps/samplerate/etc rather than having to query the info structures each time. - libobs (obs-output.c): Change 'connect' signal to 'start' and 'stop' signals. 'start' now specifies an error code rather than whether it simply failed, that way the client can actually know *why* a failure occurred. Added those error codes to obs-defs.h. - libobs: Add a few functions to duplicate/free encoder packets
2014-04-01 18:55:18 +00:00
return true;
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
obs_output_t *obs_output_create(const char *id, const char *name,
(API Change) libobs: Add hotkey data to *_create functions
2014-11-01 20:41:17 +00:00
obs_data_t *settings, obs_data_t *hotkey_data)
first commit
2013-10-01 02:37:13 +00: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 15:04:50 +00:00
const struct obs_output_info *info = find_output(id);
first commit
2013-10-01 02:37:13 +00:00
struct obs_output *output;
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
int ret;
first commit
2013-10-01 02:37:13 +00:00
Add preliminary streaming code for testing - Add some temporary streaming code using FFmpeg. FFmpeg itself is not very ideal for streaming; lack of direct control of the sockets and no framedrop handling means that FFmpeg is definitely not something you want to use without wrapper code. I'd prefer writing my own network framework in this particular case just because you give away so much control of the network interface. Wasted an entire day trying to go through FFmpeg issues. There's just no way FFmpeg should be used for real streaming (at least without being patched or submitting some sort of patch, but I'm sort of feeling "meh" on that idea) I had to end up writing multiple threads just to handle both connecting and writing, because av_interleaved_write_frame blocks every call, stalling the main encoder thread, and thus also stalling draw signals. - Add some temporary user interface for streaming settings. This is just temporary for the time being. It's in the outputs section of the basic-mode settings - Make it so that dynamic arrays do not free all their data when the size just happens to be reduced to 0. This prevents constant reallocation when an array keeps going from 1 item to 0 items. Also, it was bad to become dependent upon that functionality. You must now always explicitly call "free" on it to ensure the data is free, and that's how it should be. Implicit functionality can lead to confusion and maintainability issues.
2014-03-10 20:10:35 +00:00
output = bzalloc(sizeof(struct obs_output));
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 07:30:37 +00:00
pthread_mutex_init_value(&output->interleaved_mutex);
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
pthread_mutex_init_value(&output->delay_mutex);
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
pthread_mutex_init_value(&output->pause.mutex);
Add preliminary streaming code for testing - Add some temporary streaming code using FFmpeg. FFmpeg itself is not very ideal for streaming; lack of direct control of the sockets and no framedrop handling means that FFmpeg is definitely not something you want to use without wrapper code. I'd prefer writing my own network framework in this particular case just because you give away so much control of the network interface. Wasted an entire day trying to go through FFmpeg issues. There's just no way FFmpeg should be used for real streaming (at least without being patched or submitting some sort of patch, but I'm sort of feeling "meh" on that idea) I had to end up writing multiple threads just to handle both connecting and writing, because av_interleaved_write_frame blocks every call, stalling the main encoder thread, and thus also stalling draw signals. - Add some temporary user interface for streaming settings. This is just temporary for the time being. It's in the outputs section of the basic-mode settings - Make it so that dynamic arrays do not free all their data when the size just happens to be reduced to 0. This prevents constant reallocation when an array keeps going from 1 item to 0 items. Also, it was bad to become dependent upon that functionality. You must now always explicitly call "free" on it to ensure the data is free, and that's how it should be. Implicit functionality can lead to confusion and maintainability issues.
2014-03-10 20:10:35 +00: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 07:30:37 +00:00
if (pthread_mutex_init(&output->interleaved_mutex, NULL) != 0)
goto fail;
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
if (pthread_mutex_init(&output->delay_mutex, NULL) != 0)
goto fail;
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
if (pthread_mutex_init(&output->pause.mutex, NULL) != 0)
goto fail;
libobs: Do not allow output stop calls more than once
2016-06-21 00:09:21 +00:00
if (os_event_init(&output->stopping_event, OS_EVENT_TYPE_MANUAL) != 0)
goto fail;
(API Change) libobs: Add hotkey data to *_create functions
2014-11-01 20:41:17 +00:00
if (!init_output_handlers(output, name, settings, hotkey_data))
Add preliminary streaming code for testing - Add some temporary streaming code using FFmpeg. FFmpeg itself is not very ideal for streaming; lack of direct control of the sockets and no framedrop handling means that FFmpeg is definitely not something you want to use without wrapper code. I'd prefer writing my own network framework in this particular case just because you give away so much control of the network interface. Wasted an entire day trying to go through FFmpeg issues. There's just no way FFmpeg should be used for real streaming (at least without being patched or submitting some sort of patch, but I'm sort of feeling "meh" on that idea) I had to end up writing multiple threads just to handle both connecting and writing, because av_interleaved_write_frame blocks every call, stalling the main encoder thread, and thus also stalling draw signals. - Add some temporary user interface for streaming settings. This is just temporary for the time being. It's in the outputs section of the basic-mode settings - Make it so that dynamic arrays do not free all their data when the size just happens to be reduced to 0. This prevents constant reallocation when an array keeps going from 1 item to 0 items. Also, it was bad to become dependent upon that functionality. You must now always explicitly call "free" on it to ensure the data is free, and that's how it should be. Implicit functionality can lead to confusion and maintainability issues.
2014-03-10 20:10:35 +00:00
goto fail;
libobs: Do not allow output stop calls more than once
2016-06-21 00:09:21 +00:00
os_event_signal(output->stopping_event);
libobs: Allow object creation if id not found Allows objects to be created regardless of whether the actual id exists or not. This is a precaution that preserves objects/settings if for some reason the id was removed for whatever reason (plugin removed, or hardware encoder that disappeared). This was already added for sources, but really needs to be added for other libobs objects as well: outputs, encoders, services.
2015-09-13 18:55:06 +00:00
if (!info) {
blog(LOG_ERROR, "Output ID '%s' not found", id);
output->info.id = bstrdup(id);
output->owns_info_id = true;
} else {
output->info = *info;
}
libobs: Fix holding possibly released pointer in obs_output_t When `obs_output_t` is an encoded output, `obs_output_set_media` will ignore the video and audio so that `obs_output_t` will keep holding the `video_t` and `audio_t` pointer when the output was created. By this commit, `video` and `audio` member variables in `obs_output_t` will never set if it is an encoded output. In the auto-configuration wizard, `video_t` is released and created to have a different video size while `obs_output_t` is not released. This resulted in accessing the released `video_t` pointer.
2023-08-11 04:05:57 +00:00
if (!flag_encoded(output)) {
output->video = obs_get_video();
output->audio = obs_get_audio();
}
(API Change) Use 'get' convention: API callbacks Renamed: To: ------------------------------------------------------- obs_source_info::defaults obs_source_info::get_defaults obs_source_info::properties obs_source_info::get_properties obs_output_info::defaults obs_output_info::get_defaults obs_output_info::properties obs_output_info::get_properties obs_output_info::total_bytes obs_output_info::get_total_bytes obs_output_info::dropped_frames obs_output_info::get_dropped_frames obs_encoder_info::defaults obs_encoder_info::get_defaults obs_encoder_info::properties obs_encoder_info::get_properties obs_encoder_info::extra_data obs_encoder_info::get_extra_data obs_encoder_info::sei_data obs_encoder_info::get_sei_data obs_encoder_info::audio_info obs_encoder_info::get_audio_info obs_encoder_info::video_info obs_encoder_info::get_video_fino obs_service_info::defaults obs_service_info::get_defaults obs_service_info::properties obs_service_info::get_properties
2014-08-05 04:27:52 +00:00
if (output->info.get_defaults)
output->info.get_defaults(output->context.settings);
Set defaults automatically Automatically query defaults for sources/outputs/encoders and set them before calling create
2014-03-17 00:42:37 +00:00
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
ret = os_event_init(&output->reconnect_stop_event,
OS_EVENT_TYPE_MANUAL);
if (ret < 0)
goto fail;
output->reconnect_retry_sec = 2;
output->reconnect_retry_max = 20;
libobs: Improve exponential backoff functionality - Changes the default base exponent value to 1.5 from 2.0 - Applies a random skew of +-0.05 to the exponent to lessen the "water hammer" effect caused by predictable backoff techniques - Fixes the logging associated with exponential backoff to log the true reconnect delay value
2022-06-25 23:19:48 +00:00
output->reconnect_retry_exp =
libobs: Fix warnings about type usage
2022-06-26 07:28:00 +00:00
RECONNECT_RETRY_BASE_EXP + (rand_float(0) * 0.05f);
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
output->valid = true;
Add preliminary streaming code for testing - Add some temporary streaming code using FFmpeg. FFmpeg itself is not very ideal for streaming; lack of direct control of the sockets and no framedrop handling means that FFmpeg is definitely not something you want to use without wrapper code. I'd prefer writing my own network framework in this particular case just because you give away so much control of the network interface. Wasted an entire day trying to go through FFmpeg issues. There's just no way FFmpeg should be used for real streaming (at least without being patched or submitting some sort of patch, but I'm sort of feeling "meh" on that idea) I had to end up writing multiple threads just to handle both connecting and writing, because av_interleaved_write_frame blocks every call, stalling the main encoder thread, and thus also stalling draw signals. - Add some temporary user interface for streaming settings. This is just temporary for the time being. It's in the outputs section of the basic-mode settings - Make it so that dynamic arrays do not free all their data when the size just happens to be reduced to 0. This prevents constant reallocation when an array keeps going from 1 item to 0 items. Also, it was bad to become dependent upon that functionality. You must now always explicitly call "free" on it to ensure the data is free, and that's how it should be. Implicit functionality can lead to confusion and maintainability issues.
2014-03-10 20:10:35 +00:00
libobs: Add obs_object abstraction and functions With this, you can now cast normal obs objects (services, outputs, sources, encoders) to an obs_object_t, and then use obs_object_* functions to get references, release references, and similar for weak object references as well. This allows the ability for the frontend to use an object of any of those types interchangeably in certain situations without having to handle each specific type individually. This is useful because the properties view in particular doesn't care what type of object it uses, it just needs to be able to hold weak references to abstract OBS objects.
2022-02-03 05:56:30 +00:00
obs_context_init_control(&output->context, output,
(obs_destroy_cb)obs_output_destroy);
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-20 03:38:53 +00:00
obs_context_data_insert(&output->context, &obs->data.outputs_mutex,
&obs->data.first_output);
libobs: Fix bug where outputs cannot initialize hotkeys When an output's context data is being created, it cannot register any hotkeys because the output has not initialized its reference counting capability. This is due to the fact that when a hotkey is registered, it creates a weak reference to the source/output/service/encoder. The solution to this is to make sure the output's reference counter data is created before calling the create callback.
2016-12-07 10:55:06 +00:00
if (info)
output->context.data =
info->create(output->context.settings, output);
if (!output->context.data)
blog(LOG_ERROR, "Failed to create output '%s'!", name);
libobs: Reduce unnecessary logging (info -> debug) (Note: This commit also modifies coreaudio-encoder, win-capture, and win-mf modules) This reduces logging to the user's log file. Most of the things specified are not useful for examining log files, and make reading log files more painful. The things that are useful to log should be up to the front-end to implement. The core and core plugins should have minimal mandatory logging.
2016-08-05 22:36:10 +00:00
blog(LOG_DEBUG, "output '%s' (%s) created", name, id);
first commit
2013-10-01 02:37:13 +00:00
return output;
Add preliminary streaming code for testing - Add some temporary streaming code using FFmpeg. FFmpeg itself is not very ideal for streaming; lack of direct control of the sockets and no framedrop handling means that FFmpeg is definitely not something you want to use without wrapper code. I'd prefer writing my own network framework in this particular case just because you give away so much control of the network interface. Wasted an entire day trying to go through FFmpeg issues. There's just no way FFmpeg should be used for real streaming (at least without being patched or submitting some sort of patch, but I'm sort of feeling "meh" on that idea) I had to end up writing multiple threads just to handle both connecting and writing, because av_interleaved_write_frame blocks every call, stalling the main encoder thread, and thus also stalling draw signals. - Add some temporary user interface for streaming settings. This is just temporary for the time being. It's in the outputs section of the basic-mode settings - Make it so that dynamic arrays do not free all their data when the size just happens to be reduced to 0. This prevents constant reallocation when an array keeps going from 1 item to 0 items. Also, it was bad to become dependent upon that functionality. You must now always explicitly call "free" on it to ensure the data is free, and that's how it should be. Implicit functionality can lead to confusion and maintainability issues.
2014-03-10 20:10:35 +00:00
fail:
obs_output_destroy(output);
return NULL;
first commit
2013-10-01 02:37:13 +00: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 07:30:37 +00:00
static inline void free_packets(struct obs_output *output)
{
for (size_t i = 0; i < output->interleaved_packets.num; i++)
libobs: Use reference counting for encoder packets Prevents reallocation of encoded packet data. Deprecates: obs_duplicate_encoder_packet obs_free_encoder_packet Replaces those functions with: obs_encoder_packet_ref obs_encoder_packet_release
2016-12-07 20:45:25 +00:00
obs_encoder_packet_release(output->interleaved_packets.array +
i);
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 07:30:37 +00:00
da_free(output->interleaved_packets);
}
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
static inline void clear_raw_audio_buffers(obs_output_t *output)
libobs: Correct raw output starting audio data If the audio subsystem was buffered to any extent, the audio of a raw output would start off at a negative offset, requiring each raw output to implement a "prepare_audio" function (as seen in the FFmpeg output) in order to ensure proper synchronization with video. This did not apply to encoded outputs because it was already being performed by the obs-encoder code.
2019-07-07 03:07:37 +00:00
{
for (size_t i = 0; i < MAX_AUDIO_MIXES; i++) {
for (size_t j = 0; j < MAX_AV_PLANES; j++) {
libobs: Replace circlebuf with deque
2023-11-30 15:11:18 +00:00
deque_free(&output->audio_buffer[i][j]);
libobs: Correct raw output starting audio data If the audio subsystem was buffered to any extent, the audio of a raw output would start off at a negative offset, requiring each raw output to implement a "prepare_audio" function (as seen in the FFmpeg output) in order to ensure proper synchronization with video. This did not apply to encoded outputs because it was already being performed by the obs-encoder code.
2019-07-07 03:07:37 +00:00
}
}
}
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
static void destroy_caption_track(struct caption_track_data **ctrack_ptr)
{
if (!ctrack_ptr || !*ctrack_ptr) {
return;
}
struct caption_track_data *ctrack = *ctrack_ptr;
pthread_mutex_destroy(&ctrack->caption_mutex);
deque_free(&ctrack->caption_data);
bfree(ctrack);
*ctrack_ptr = NULL;
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
void obs_output_destroy(obs_output_t *output)
first commit
2013-10-01 02:37:13 +00:00
{
if (output) {
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-20 03:38:53 +00:00
obs_context_data_remove(&output->context);
Add preliminary streaming code for testing - Add some temporary streaming code using FFmpeg. FFmpeg itself is not very ideal for streaming; lack of direct control of the sockets and no framedrop handling means that FFmpeg is definitely not something you want to use without wrapper code. I'd prefer writing my own network framework in this particular case just because you give away so much control of the network interface. Wasted an entire day trying to go through FFmpeg issues. There's just no way FFmpeg should be used for real streaming (at least without being patched or submitting some sort of patch, but I'm sort of feeling "meh" on that idea) I had to end up writing multiple threads just to handle both connecting and writing, because av_interleaved_write_frame blocks every call, stalling the main encoder thread, and thus also stalling draw signals. - Add some temporary user interface for streaming settings. This is just temporary for the time being. It's in the outputs section of the basic-mode settings - Make it so that dynamic arrays do not free all their data when the size just happens to be reduced to 0. This prevents constant reallocation when an array keeps going from 1 item to 0 items. Also, it was bad to become dependent upon that functionality. You must now always explicitly call "free" on it to ensure the data is free, and that's how it should be. Implicit functionality can lead to confusion and maintainability issues.
2014-03-10 20:10:35 +00:00
libobs: Reduce unnecessary logging (info -> debug) (Note: This commit also modifies coreaudio-encoder, win-capture, and win-mf modules) This reduces logging to the user's log file. Most of the things specified are not useful for examining log files, and make reading log files more painful. The things that are useful to log should be up to the front-end to implement. The core and core plugins should have minimal mandatory logging.
2016-08-05 22:36:10 +00:00
blog(LOG_DEBUG, "output '%s' destroyed", output->context.name);
Log when any libobs objects are created/destroyed
2014-07-13 12:01:02 +00:00
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
if (output->valid && active(output))
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
obs_output_actual_stop(output, true, 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 10:03:54 +00:00
libobs: Fix output shutdown order When obs_output_actual_stop is called on shutdown, it should wait for the output to fully stop before doing anything, and then it should wait for the data capture to end. The service should not be removed until after the output has stopped, otherwise it could result in a possible memory leak on stop. Packets should be freed last.
2016-06-21 11:06:35 +00:00
os_event_wait(output->stopping_event);
libobs: Move output/encoder shutdown to independent thread obs_output_end_data_capture could cause a hard lock due to mutex lock ordering, depending on what thread it was called in.
2016-06-22 00:25:26 +00:00
if (data_capture_ending(output))
pthread_join(output->end_data_capture_thread, NULL);
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 07:30:37 +00:00
libobs: Fix output shutdown order When obs_output_actual_stop is called on shutdown, it should wait for the output to fully stop before doing anything, and then it should wait for the data capture to end. The service should not be removed until after the output has stopped, otherwise it could result in a possible memory leak on stop. Packets should be freed last.
2016-06-21 11:06:35 +00:00
if (output->service)
output->service->output = 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-20 03:38:53 +00:00
if (output->context.data)
output->info.destroy(output->context.data);
Add preliminary output/encoder interface - First, I redid the output interface for libobs. I feel like it's going in a pretty good direction in terms of design. Right now, the design is so that outputs and encoders are separate. One or more outputs can connect to a specific encoder to receive its data, or the output can connect directly to raw data from libobs output itself, if the output doesn't want to use a designated encoder. Data is received via callbacks set when you connect to the encoder or raw output. Multiple outputs can receive the data from a single encoder context if need be (such as for streaming to multiple channels at once, and/or recording with the same data). When an encoder is first connected to, it will connect to raw output, and start encoding. Additional connections will receive that same data being encoded as well after that. When the last encoder has disconnected, it will stop encoding. If for some reason the encoder needs to stop, it will use the callback with NULL to signal that encoding has stopped. Some of these things may be subject to change in the future, though it feels pretty good with this design so far. Will have to see how well it works out in practice versus theory. - Second, Started adding preliminary RTMP/x264 output plugin code. To speed things up, I might just make a direct raw->FFmpeg output to create a quick output plugin that we can start using for testing all the subsystems.
2014-01-17 05:34:51 +00:00
libobs: Fix output shutdown order When obs_output_actual_stop is called on shutdown, it should wait for the output to fully stop before doing anything, and then it should wait for the data capture to end. The service should not be removed until after the output has stopped, otherwise it could result in a possible memory leak on stop. Packets should be freed last.
2016-06-21 11:06:35 +00:00
free_packets(output);
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
if (output->video_encoders[i]) {
obs_encoder_remove_output(
output->video_encoders[i], output);
}
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
if (output->caption_tracks[i]) {
destroy_caption_track(
&output->caption_tracks[i]);
}
Remove output from encoder when output is destroyed. This fixes an issue reported by valgrind where a destroyed output is still referenced by the encoder.
2014-05-13 19:53:13 +00:00
}
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
if (output->audio_encoders[i]) {
obs_encoder_remove_output(
output->audio_encoders[i], output);
}
Remove output from encoder when output is destroyed. This fixes an issue reported by valgrind where a destroyed output is still referenced by the encoder.
2014-05-13 19:53:13 +00:00
}
libobs: Track keyframe alignment for keyframe aligned encoder groups
2023-09-07 13:56:45 +00:00
da_free(output->keyframe_group_tracking);
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
clear_raw_audio_buffers(output);
libobs: Correct raw output starting audio data If the audio subsystem was buffered to any extent, the audio of a raw output would start off at a negative offset, requiring each raw output to implement a "prepare_audio" function (as seen in the FFmpeg output) in order to ensure proper synchronization with video. This did not apply to encoded outputs because it was already being performed by the obs-encoder code.
2019-07-07 03:07:37 +00:00
libobs: Do not allow output stop calls more than once
2016-06-21 00:09:21 +00:00
os_event_destroy(output->stopping_event);
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
pthread_mutex_destroy(&output->pause.mutex);
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 07:30:37 +00:00
pthread_mutex_destroy(&output->interleaved_mutex);
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
pthread_mutex_destroy(&output->delay_mutex);
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
os_event_destroy(output->reconnect_stop_event);
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-20 03:38:53 +00:00
obs_context_data_free(&output->context);
libobs: Replace circlebuf with deque
2023-11-30 15:11:18 +00:00
deque_free(&output->delay_data);
libobs: Allow object creation if id not found Allows objects to be created regardless of whether the actual id exists or not. This is a precaution that preserves objects/settings if for some reason the id was removed for whatever reason (plugin removed, or hardware encoder that disappeared). This was already added for sources, but really needs to be added for other libobs objects as well: outputs, encoders, services.
2015-09-13 18:55:06 +00:00
if (output->owns_info_id)
bfree((void *)output->info.id);
libobs: Add support for output error messages
2017-05-15 10:04:11 +00:00
if (output->last_error_message)
bfree(output->last_error_message);
first commit
2013-10-01 02:37:13 +00:00
bfree(output);
}
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 22:25:59 +00:00
const char *obs_output_get_name(const obs_output_t *output)
Add obs_output_getname This will get the user-defined name of the output (if any)
2014-07-01 23:29:38 +00:00
{
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
return obs_output_valid(output, "obs_output_get_name")
? output->context.name
: NULL;
Add obs_output_getname This will get the user-defined name of the output (if any)
2014-07-01 23:29:38 +00:00
}
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
bool obs_output_actual_start(obs_output_t *output)
first commit
2013-10-01 02:37:13 +00:00
{
libobs: Allow object creation if id not found Allows objects to be created regardless of whether the actual id exists or not. This is a precaution that preserves objects/settings if for some reason the id was removed for whatever reason (plugin removed, or hardware encoder that disappeared). This was already added for sources, but really needs to be added for other libobs objects as well: outputs, encoders, services.
2015-09-13 18:55:06 +00:00
bool success = false;
Log total/skipped frames on output stop This makes it easier to do two things: 1.) Get the skipped frames count relative to each specific output 2.) Make it so that getting the 'current' log will always contain information about skipped frames. Before, you'd have to force the user to restart the program and get the last log, which was really annoying when you just wanted to see how the encoders were performing.
2014-08-25 00:32:44 +00:00
libobs: Do not allow output stop calls more than once
2016-06-21 00:09:21 +00:00
os_event_wait(output->stopping_event);
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
output->stop_code = 0;
libobs: Add support for output error messages
2017-05-15 10:04:11 +00:00
if (output->last_error_message) {
bfree(output->last_error_message);
output->last_error_message = NULL;
}
libobs: Fix potential crash on output stop In certain circumstances where the output was stopping, and where data took a long enough time to send (such as when using an encoding preset that causes high CPU usage), the output would sometimes still send data even after it was stopped, typically causing the output to crash.
2014-12-31 09:30:54 +00:00
libobs: Allow object creation if id not found Allows objects to be created regardless of whether the actual id exists or not. This is a precaution that preserves objects/settings if for some reason the id was removed for whatever reason (plugin removed, or hardware encoder that disappeared). This was already added for sources, but really needs to be added for other libobs objects as well: outputs, encoders, services.
2015-09-13 18:55:06 +00:00
if (output->context.data)
success = output->info.start(output->context.data);
Log total/skipped frames on output stop This makes it easier to do two things: 1.) Get the skipped frames count relative to each specific output 2.) Make it so that getting the 'current' log will always contain information about skipped frames. Before, you'd have to force the user to restart the program and get the last log, which was really annoying when you just wanted to see how the encoders were performing.
2014-08-25 00:32:44 +00:00
libobs: Fix holding possibly released pointer in obs_output_t When `obs_output_t` is an encoded output, `obs_output_set_media` will ignore the video and audio so that `obs_output_t` will keep holding the `video_t` and `audio_t` pointer when the output was created. By this commit, `video` and `audio` member variables in `obs_output_t` will never set if it is an encoded output. In the auto-configuration wizard, `video_t` is released and created to have a different video size while `obs_output_t` is not released. This resulted in accessing the released `video_t` pointer.
2023-08-11 04:05:57 +00:00
if (success) {
libobs: Report lost frame count due to rendering lag This has been missing for a bit too long, and should make it easier/faster to diagnose issues users might be having.
2016-01-25 11:58:51 +00:00
output->starting_drawn_count = obs->video.total_frames;
output->starting_lagged_count = obs->video.lagged_frames;
Log total/skipped frames on output stop This makes it easier to do two things: 1.) Get the skipped frames count relative to each specific output 2.) Make it so that getting the 'current' log will always contain information about skipped frames. Before, you'd have to force the user to restart the program and get the last log, which was really annoying when you just wanted to see how the encoders were performing.
2014-08-25 00:32:44 +00:00
}
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
if (os_atomic_load_long(&output->delay_restart_refs))
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
os_atomic_dec_long(&output->delay_restart_refs);
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
struct caption_track_data *ctrack = output->caption_tracks[i];
if (!ctrack) {
continue;
}
pthread_mutex_lock(&ctrack->caption_mutex);
ctrack->caption_timestamp = 0;
deque_free(&ctrack->caption_data);
deque_init(&ctrack->caption_data);
pthread_mutex_unlock(&ctrack->caption_mutex);
}
Log total/skipped frames on output stop This makes it easier to do two things: 1.) Get the skipped frames count relative to each specific output 2.) Make it so that getting the 'current' log will always contain information about skipped frames. Before, you'd have to force the user to restart the program and get the last log, which was really annoying when you just wanted to see how the encoders were performing.
2014-08-25 00:32:44 +00:00
return success;
}
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
bool obs_output_start(obs_output_t *output)
{
if (!obs_output_valid(output, "obs_output_start"))
return false;
libobs: Allow object creation if id not found Allows objects to be created regardless of whether the actual id exists or not. This is a precaution that preserves objects/settings if for some reason the id was removed for whatever reason (plugin removed, or hardware encoder that disappeared). This was already added for sources, but really needs to be added for other libobs objects as well: outputs, encoders, services.
2015-09-13 18:55:06 +00:00
if (!output->context.data)
return false;
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
if (flag_service(output) &&
!(obs_service_can_try_to_connect(output->service) &&
obs_service_initialize(output->service, output)))
libobs: Initialize service before starting output This fixes the case where initialize is not called on a service if the output is not encoded.
2018-10-11 01:11:37 +00:00
return false;
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
if (output->delay_sec) {
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
return obs_output_delay_start(output);
} else {
if (obs_output_actual_start(output)) {
do_output_signal(output, "starting");
return true;
}
return false;
}
}
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
static inline bool data_active(struct obs_output *output)
{
return os_atomic_load_bool(&output->data_active);
}
Log total/skipped frames on output stop This makes it easier to do two things: 1.) Get the skipped frames count relative to each specific output 2.) Make it so that getting the 'current' log will always contain information about skipped frames. Before, you'd have to force the user to restart the program and get the last log, which was really annoying when you just wanted to see how the encoders were performing.
2014-08-25 00:32:44 +00:00
static void log_frame_info(struct obs_output *output)
{
libobs: Report lost frame count due to rendering lag This has been missing for a bit too long, and should make it easier/faster to diagnose issues users might be having.
2016-01-25 11:58:51 +00:00
struct obs_core_video *video = &obs->video;
Revert "libobs: Fix an int underflow in log_frame_info" This reverts commit 4e3e67bb8cf6cb508b4d30b85451c0c4f20b7539. The way this is handled will erroneously report 0 frames encoded when frames have actually been properly encoded, which is best avoided. Additionally, and overflow would be generated for drawn frames where none occurred before. The encoded value should probably not even be present in the log for the output due to the way it's handled.
2017-08-02 20:59:24 +00:00
uint32_t drawn = video->total_frames - output->starting_drawn_count;
uint32_t lagged = video->lagged_frames - output->starting_lagged_count;
libobs: Report lost frame count due to rendering lag This has been missing for a bit too long, and should make it easier/faster to diagnose issues users might be having.
2016-01-25 11:58:51 +00:00
Log dropped frame count This was sorely needed for debugging stream issues.
2014-10-13 02:22:04 +00:00
int dropped = obs_output_get_frames_dropped(output);
libobs: Log output frame count instead of encoded count Instead of logging the relative encoded count (which is susceptible to integer overflow), log the output frame count instead. If there's an issue with encoding, it'll show up when all encoding stops regardless.
2017-08-02 21:25:06 +00:00
int total = output->total_frames;
Log dropped frame count This was sorely needed for debugging stream issues.
2014-10-13 02:22:04 +00:00
libobs: Report lost frame count due to rendering lag This has been missing for a bit too long, and should make it easier/faster to diagnose issues users might be having.
2016-01-25 11:58:51 +00:00
double percentage_lagged = 0.0f;
double percentage_dropped = 0.0f;
if (drawn)
percentage_lagged = (double)lagged / (double)drawn * 100.0;
libobs: Log output frame count instead of encoded count Instead of logging the relative encoded count (which is susceptible to integer overflow), log the output frame count instead. If there's an issue with encoding, it'll show up when all encoding stops regardless.
2017-08-02 21:25:06 +00:00
if (dropped)
percentage_dropped = (double)dropped / (double)total * 100.0;
Log total/skipped frames on output stop This makes it easier to do two things: 1.) Get the skipped frames count relative to each specific output 2.) Make it so that getting the 'current' log will always contain information about skipped frames. Before, you'd have to force the user to restart the program and get the last log, which was really annoying when you just wanted to see how the encoders were performing.
2014-08-25 00:32:44 +00:00
blog(LOG_INFO, "Output '%s': stopping", output->context.name);
libobs: Log output frame count instead of encoded count Instead of logging the relative encoded count (which is susceptible to integer overflow), log the output frame count instead. If there's an issue with encoding, it'll show up when all encoding stops regardless.
2017-08-02 21:25:06 +00:00
if (!dropped || !total)
blog(LOG_INFO, "Output '%s': Total frames output: %d",
output->context.name, total);
else
blog(LOG_INFO,
"Output '%s': Total frames output: %d"
" (%d attempted)",
output->context.name, total - dropped, total);
if (!lagged || !drawn)
blog(LOG_INFO, "Output '%s': Total drawn frames: %" PRIu32,
output->context.name, drawn);
else
blog(LOG_INFO,
"Output '%s': Total drawn frames: %" PRIu32 " (%" PRIu32
" attempted)",
output->context.name, drawn - lagged, drawn);
Log total/skipped frames on output stop This makes it easier to do two things: 1.) Get the skipped frames count relative to each specific output 2.) Make it so that getting the 'current' log will always contain information about skipped frames. Before, you'd have to force the user to restart the program and get the last log, which was really annoying when you just wanted to see how the encoders were performing.
2014-08-25 00:32:44 +00:00
libobs: Report lost frame count due to rendering lag This has been missing for a bit too long, and should make it easier/faster to diagnose issues users might be having.
2016-01-25 11:58:51 +00:00
if (drawn && lagged)
blog(LOG_INFO,
"Output '%s': Number of lagged frames due "
"to rendering lag/stalls: %" PRIu32 " (%0.1f%%)",
output->context.name, lagged, percentage_lagged);
Revert "libobs: Fix an int underflow in log_frame_info" This reverts commit 4e3e67bb8cf6cb508b4d30b85451c0c4f20b7539. The way this is handled will erroneously report 0 frames encoded when frames have actually been properly encoded, which is best avoided. Additionally, and overflow would be generated for drawn frames where none occurred before. The encoded value should probably not even be present in the log for the output due to the way it's handled.
2017-08-02 20:59:24 +00:00
if (total && dropped)
libobs: Report lost frame count due to rendering lag This has been missing for a bit too long, and should make it easier/faster to diagnose issues users might be having.
2016-01-25 11:58:51 +00:00
blog(LOG_INFO,
"Output '%s': Number of dropped frames due "
"to insufficient bandwidth/connection stalls: "
"%d (%0.1f%%)",
Log dropped frame count This was sorely needed for debugging stream issues.
2014-10-13 02:22:04 +00:00
output->context.name, dropped, percentage_dropped);
first commit
2013-10-01 02:37:13 +00:00
}
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
static inline void signal_stop(struct obs_output *output);
void obs_output_actual_stop(obs_output_t *output, bool force, uint64_t ts)
first commit
2013-10-01 02:37:13 +00:00
{
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
bool call_stop = true;
bool was_reconnecting = false;
libobs: Allow forced stop even when already stopping Allow outputs to force a stop even when already in the process of stopping. If for example a stream is heavily congested and taking a very long time to stop, this allows frontends to give the users the option to forcibly stop the stream to make it stop as quickly as possible.
2016-09-09 11:45:27 +00:00
if (stopping(output) && !force)
libobs: Do not allow output stop calls more than once
2016-06-21 00:09:21 +00:00
return;
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
obs_output_pause(output, false);
libobs: Do not allow output stop calls more than once
2016-06-21 00:09:21 +00:00
os_event_reset(output->stopping_event);
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
was_reconnecting = reconnecting(output) && !delay_active(output);
if (reconnecting(output)) {
os_event_signal(output->reconnect_stop_event);
if (output->reconnect_thread_active)
pthread_join(output->reconnect_thread, NULL);
}
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
if (force) {
if (delay_active(output)) {
call_stop = delay_capturing(output);
os_atomic_set_bool(&output->delay_active, false);
os_atomic_set_bool(&output->delay_capturing, false);
output->stop_code = OBS_OUTPUT_SUCCESS;
obs_output_end_data_capture(output);
os_event_signal(output->stopping_event);
} else {
libobs: Always call stop callback Rather than have the back-end try to determine whether the output can or cannot stop, allow the stop callback to continue in the plugin either way and let the plugin itself make that determination. This fixes a bug where the back-end wouldn't have data active while connecting, therefore the stop callback wouldn't be called, and once connected it wouldn't know that it was supposed to stop. In other words trying to call obs_output_stop on an output that was in a state of connecting would do nothing and the output would never stop.
2017-05-20 19:27:02 +00:00
call_stop = true;
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
}
} else {
libobs: Always call stop callback Rather than have the back-end try to determine whether the output can or cannot stop, allow the stop callback to continue in the plugin either way and let the plugin itself make that determination. This fixes a bug where the back-end wouldn't have data active while connecting, therefore the stop callback wouldn't be called, and once connected it wouldn't know that it was supposed to stop. In other words trying to call obs_output_stop on an output that was in a state of connecting would do nothing and the output would never stop.
2017-05-20 19:27:02 +00:00
call_stop = true;
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
}
libobs: Fix potential crash on output stop In certain circumstances where the output was stopping, and where data took a long enough time to send (such as when using an encoding preset that causes high CPU usage), the output would sometimes still send data even after it was stopped, typically causing the output to crash.
2014-12-31 09:30:54 +00:00
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
if (output->context.data && call_stop) {
output->info.stop(output->context.data, ts);
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
} else if (was_reconnecting) {
output->stop_code = OBS_OUTPUT_SUCCESS;
signal_stop(output);
os_event_signal(output->stopping_event);
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
}
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
struct caption_track_data *ctrack = output->caption_tracks[i];
if (!ctrack) {
continue;
}
while (ctrack->caption_head) {
ctrack->caption_tail = ctrack->caption_head->next;
bfree(ctrack->caption_head);
ctrack->caption_head = ctrack->caption_tail;
}
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
}
libobs: Track keyframe alignment for keyframe aligned encoder groups
2023-09-07 13:56:45 +00:00
da_clear(output->keyframe_group_tracking);
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
}
Log total/skipped frames on output stop This makes it easier to do two things: 1.) Get the skipped frames count relative to each specific output 2.) Make it so that getting the 'current' log will always contain information about skipped frames. Before, you'd have to force the user to restart the program and get the last log, which was really annoying when you just wanted to see how the encoders were performing.
2014-08-25 00:32:44 +00:00
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
void obs_output_stop(obs_output_t *output)
{
if (!obs_output_valid(output, "obs_output_stop"))
return;
libobs: Allow object creation if id not found Allows objects to be created regardless of whether the actual id exists or not. This is a precaution that preserves objects/settings if for some reason the id was removed for whatever reason (plugin removed, or hardware encoder that disappeared). This was already added for sources, but really needs to be added for other libobs objects as well: outputs, encoders, services.
2015-09-13 18:55:06 +00:00
if (!output->context.data)
return;
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
if (!active(output) && !reconnecting(output))
return;
libobs: Forcibly stop output if stopped during reconnect This fixes an design flaw where a delayed output would schedule a stop even while in the process of reconnecting instead of just shutting down right away.
2016-06-21 11:10:25 +00:00
if (reconnecting(output)) {
obs_output_force_stop(output);
return;
}
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
if (flag_encoded(output) && output->active_delay_ns) {
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
obs_output_delay_stop(output);
libobs: Do not allow output stop calls more than once
2016-06-21 00:09:21 +00:00
} else if (!stopping(output)) {
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
do_output_signal(output, "stopping");
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
obs_output_actual_stop(output, false, os_gettime_ns());
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-08 05:00:10 +00:00
}
first commit
2013-10-01 02:37:13 +00:00
}
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
void obs_output_force_stop(obs_output_t *output)
{
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
if (!obs_output_valid(output, "obs_output_force_stop"))
return;
if (!stopping(output)) {
output->stop_code = 0;
do_output_signal(output, "stopping");
}
libobs: Allow forced stop even when already stopping Allow outputs to force a stop even when already in the process of stopping. If for example a stream is heavily congested and taking a very long time to stop, this allows frontends to give the users the option to forcibly stop the stream to make it stop as quickly as possible.
2016-09-09 11:45:27 +00:00
obs_output_actual_stop(output, true, 0);
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 22:25:59 +00:00
bool obs_output_active(const obs_output_t *output)
first commit
2013-10-01 02:37:13 +00:00
{
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
return (output != NULL) ? (active(output) || reconnecting(output))
: false;
first commit
2013-10-01 02:37:13 +00:00
}
libobs: Add functions to get output capability flags Closes obsproject/obs-studio#1263
2018-04-18 17:10:30 +00:00
uint32_t obs_output_get_flags(const obs_output_t *output)
{
return obs_output_valid(output, "obs_output_get_flags")
? output->info.flags
: 0;
}
uint32_t obs_get_output_flags(const char *id)
{
const struct obs_output_info *info = find_output(id);
return info ? info->flags : 0;
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
static inline obs_data_t *get_defaults(const struct obs_output_info *info)
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 07:30:37 +00:00
{
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
obs_data_t *settings = obs_data_create();
(API Change) Use 'get' convention: API callbacks Renamed: To: ------------------------------------------------------- obs_source_info::defaults obs_source_info::get_defaults obs_source_info::properties obs_source_info::get_properties obs_output_info::defaults obs_output_info::get_defaults obs_output_info::properties obs_output_info::get_properties obs_output_info::total_bytes obs_output_info::get_total_bytes obs_output_info::dropped_frames obs_output_info::get_dropped_frames obs_encoder_info::defaults obs_encoder_info::get_defaults obs_encoder_info::properties obs_encoder_info::get_properties obs_encoder_info::extra_data obs_encoder_info::get_extra_data obs_encoder_info::sei_data obs_encoder_info::get_sei_data obs_encoder_info::audio_info obs_encoder_info::get_audio_info obs_encoder_info::video_info obs_encoder_info::get_video_fino obs_service_info::defaults obs_service_info::get_defaults obs_service_info::properties obs_service_info::get_properties
2014-08-05 04:27:52 +00:00
if (info->get_defaults)
info->get_defaults(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 07:30:37 +00:00
return settings;
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
obs_data_t *obs_output_defaults(const char *id)
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 13:55:21 +00:00
{
const struct obs_output_info *info = find_output(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 07:30:37 +00: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 13:55:21 +00:00
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
obs_properties_t *obs_get_output_properties(const char *id)
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-02 05:46:13 +00: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 15:04:50 +00:00
const struct obs_output_info *info = find_output(id);
(API Change) Use 'get' convention: API callbacks Renamed: To: ------------------------------------------------------- obs_source_info::defaults obs_source_info::get_defaults obs_source_info::properties obs_source_info::get_properties obs_output_info::defaults obs_output_info::get_defaults obs_output_info::properties obs_output_info::get_properties obs_output_info::total_bytes obs_output_info::get_total_bytes obs_output_info::dropped_frames obs_output_info::get_dropped_frames obs_encoder_info::defaults obs_encoder_info::get_defaults obs_encoder_info::properties obs_encoder_info::get_properties obs_encoder_info::extra_data obs_encoder_info::get_extra_data obs_encoder_info::sei_data obs_encoder_info::get_sei_data obs_encoder_info::audio_info obs_encoder_info::get_audio_info obs_encoder_info::video_info obs_encoder_info::get_video_fino obs_service_info::defaults obs_service_info::get_defaults obs_service_info::properties obs_service_info::get_properties
2014-08-05 04:27:52 +00:00
if (info && info->get_properties) {
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
obs_data_t *defaults = get_defaults(info);
obs_properties_t *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 07:30:37 +00:00
(API Change) Pass data to get_properties when possible
2014-09-29 15:36:13 +00:00
properties = info->get_properties(NULL);
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 07:30:37 +00:00
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-02 05:46:13 +00:00
return NULL;
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 22:25:59 +00:00
obs_properties_t *obs_output_properties(const obs_output_t *output)
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 08:07:54 +00:00
{
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (!obs_output_valid(output, "obs_output_properties"))
return NULL;
(API Change) Use 'get' convention: API callbacks Renamed: To: ------------------------------------------------------- obs_source_info::defaults obs_source_info::get_defaults obs_source_info::properties obs_source_info::get_properties obs_output_info::defaults obs_output_info::get_defaults obs_output_info::properties obs_output_info::get_properties obs_output_info::total_bytes obs_output_info::get_total_bytes obs_output_info::dropped_frames obs_output_info::get_dropped_frames obs_encoder_info::defaults obs_encoder_info::get_defaults obs_encoder_info::properties obs_encoder_info::get_properties obs_encoder_info::extra_data obs_encoder_info::get_extra_data obs_encoder_info::sei_data obs_encoder_info::get_sei_data obs_encoder_info::audio_info obs_encoder_info::get_audio_info obs_encoder_info::video_info obs_encoder_info::get_video_fino obs_service_info::defaults obs_service_info::get_defaults obs_service_info::properties obs_service_info::get_properties
2014-08-05 04:27:52 +00:00
if (output && output->info.get_properties) {
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
obs_properties_t *props;
(API Change) Pass data to get_properties when possible
2014-09-29 15:36:13 +00:00
props = output->info.get_properties(output->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-20 03:38:53 +00:00
obs_properties_apply_settings(props, output->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 07:30:37 +00: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 08:07:54 +00:00
return NULL;
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
void obs_output_update(obs_output_t *output, obs_data_t *settings)
first commit
2013-10-01 02:37:13 +00:00
{
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (!obs_output_valid(output, "obs_output_update"))
return;
Add more checks for NULL pointers
2014-02-24 05:39:33 +00: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-20 03:38:53 +00:00
obs_data_apply(output->context.settings, settings);
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 22:45:30 +00: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 15:04:50 +00:00
if (output->info.update)
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-20 03:38:53 +00:00
output->info.update(output->context.data,
output->context.settings);
first commit
2013-10-01 02:37:13 +00:00
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 22:25:59 +00:00
obs_data_t *obs_output_get_settings(const obs_output_t *output)
Do test recording to a specified file It will now output to a a filename that you specify when you click the record button. This is just for testing.
2014-02-10 17:22:35 +00:00
{
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (!obs_output_valid(output, "obs_output_get_settings"))
Do test recording to a specified file It will now output to a a filename that you specify when you click the record button. This is just for testing.
2014-02-10 17:22:35 +00:00
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-20 03:38:53 +00:00
obs_data_addref(output->context.settings);
return output->context.settings;
Do test recording to a specified file It will now output to a a filename that you specify when you click the record button. This is just for testing.
2014-02-10 17:22:35 +00:00
}
libobs: Rename obs_output_canpause Renames obs_output_canpause to obs_output_can_pause
2015-10-21 14:32:01 +00:00
bool obs_output_can_pause(const obs_output_t *output)
first commit
2013-10-01 02:37:13 +00:00
{
libobs: Rename obs_output_canpause Renames obs_output_canpause to obs_output_can_pause
2015-10-21 14:32:01 +00:00
return obs_output_valid(output, "obs_output_can_pause")
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
? !!(output->info.flags & OBS_OUTPUT_CAN_PAUSE)
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
: false;
first commit
2013-10-01 02:37:13 +00:00
}
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
static inline void end_pause(struct pause_data *pause, uint64_t ts)
{
if (!pause->ts_end) {
pause->ts_end = ts;
pause->ts_offset += pause->ts_end - pause->ts_start;
}
}
static inline uint64_t get_closest_v_ts(struct pause_data *pause)
{
uint64_t interval = obs->video.video_frame_interval_ns;
libobs: Give a little extra time for pause to start/stop Audio latency can get really low, and if it's low enough, the timestamp can be passed by the audio subsystem before it's had a chance to pause with it. So instead, make the pause have a little bit of extra delay to ensure that doesn't occur.
2019-08-31 07:52:36 +00:00
uint64_t i2 = interval * 2;
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
uint64_t ts = os_gettime_ns();
return pause->last_video_ts +
libobs: Give a little extra time for pause to start/stop Audio latency can get really low, and if it's low enough, the timestamp can be passed by the audio subsystem before it's had a chance to pause with it. So instead, make the pause have a little bit of extra delay to ensure that doesn't occur.
2019-08-31 07:52:36 +00:00
((ts - pause->last_video_ts + i2) / interval) * interval;
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
}
libobs: Fail pause/unpause if still waiting for them When a pause/unpause occurs, a timestamp is set and the actual pause/unpause does not occur until the output/encoders reach the specified timestamps. Do not allow pausing/unpausing unless that point has been reached with all encoders of an encoded output or the output itself when using a raw output. This fixes a bug where pause data could get corrupted if pausing/unpausing too fast, because the audio/video encoders aren't necessarily synchronized and although one encoder may have unpaused, the other encoder(s) may not have yet. Checking all encoders first before allowing a pause/unpause ensures that doesn't occur.
2019-08-31 07:59:48 +00:00
static inline bool pause_can_start(struct pause_data *pause)
{
return !pause->ts_start && !pause->ts_end;
}
static inline bool pause_can_stop(struct pause_data *pause)
{
return !!pause->ts_start && !pause->ts_end;
}
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
static bool get_first_audio_encoder_index(const struct obs_output *output,
size_t *index)
{
if (!index)
return false;
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
if (output->audio_encoders[i]) {
*index = i;
return true;
}
}
return false;
}
static bool get_first_video_encoder_index(const struct obs_output *output,
size_t *index)
{
if (!index)
return false;
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
if (output->video_encoders[i]) {
*index = i;
return true;
}
}
return false;
}
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
static bool obs_encoded_output_pause(obs_output_t *output, bool pause)
first commit
2013-10-01 02:37:13 +00:00
{
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
obs_encoder_t *venc[MAX_OUTPUT_VIDEO_ENCODERS];
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
obs_encoder_t *aenc[MAX_OUTPUT_AUDIO_ENCODERS];
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
uint64_t closest_v_ts;
libobs: Fail pause/unpause if still waiting for them When a pause/unpause occurs, a timestamp is set and the actual pause/unpause does not occur until the output/encoders reach the specified timestamps. Do not allow pausing/unpausing unless that point has been reached with all encoders of an encoded output or the output itself when using a raw output. This fixes a bug where pause data could get corrupted if pausing/unpausing too fast, because the audio/video encoders aren't necessarily synchronized and although one encoder may have unpaused, the other encoder(s) may not have yet. Checking all encoders first before allowing a pause/unpause ensures that doesn't occur.
2019-08-31 07:59:48 +00:00
bool success = false;
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++)
venc[i] = output->video_encoders[i];
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++)
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
aenc[i] = output->audio_encoders[i];
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
if (venc[i]) {
pthread_mutex_lock(&venc[i]->pause.mutex);
}
}
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
if (aenc[i]) {
pthread_mutex_lock(&aenc[i]->pause.mutex);
}
}
/* ---------------------------- */
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
size_t first_venc_index;
if (!get_first_video_encoder_index(output, &first_venc_index))
goto fail;
closest_v_ts = get_closest_v_ts(&venc[first_venc_index]->pause);
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
if (pause) {
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
if (venc[i] && !pause_can_start(&venc[i]->pause)) {
goto fail;
}
libobs: Fail pause/unpause if still waiting for them When a pause/unpause occurs, a timestamp is set and the actual pause/unpause does not occur until the output/encoders reach the specified timestamps. Do not allow pausing/unpausing unless that point has been reached with all encoders of an encoded output or the output itself when using a raw output. This fixes a bug where pause data could get corrupted if pausing/unpausing too fast, because the audio/video encoders aren't necessarily synchronized and although one encoder may have unpaused, the other encoder(s) may not have yet. Checking all encoders first before allowing a pause/unpause ensures that doesn't occur.
2019-08-31 07:59:48 +00:00
}
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
libobs: Fail pause/unpause if still waiting for them When a pause/unpause occurs, a timestamp is set and the actual pause/unpause does not occur until the output/encoders reach the specified timestamps. Do not allow pausing/unpausing unless that point has been reached with all encoders of an encoded output or the output itself when using a raw output. This fixes a bug where pause data could get corrupted if pausing/unpausing too fast, because the audio/video encoders aren't necessarily synchronized and although one encoder may have unpaused, the other encoder(s) may not have yet. Checking all encoders first before allowing a pause/unpause ensures that doesn't occur.
2019-08-31 07:59:48 +00:00
if (aenc[i] && !pause_can_start(&aenc[i]->pause)) {
goto fail;
}
}
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
if (venc[i]) {
os_atomic_set_bool(&venc[i]->paused, true);
venc[i]->pause.ts_start = closest_v_ts;
}
}
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
if (aenc[i]) {
os_atomic_set_bool(&aenc[i]->paused, true);
aenc[i]->pause.ts_start = closest_v_ts;
}
}
} else {
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
if (venc[i] && !pause_can_stop(&venc[i]->pause)) {
goto fail;
}
libobs: Fail pause/unpause if still waiting for them When a pause/unpause occurs, a timestamp is set and the actual pause/unpause does not occur until the output/encoders reach the specified timestamps. Do not allow pausing/unpausing unless that point has been reached with all encoders of an encoded output or the output itself when using a raw output. This fixes a bug where pause data could get corrupted if pausing/unpausing too fast, because the audio/video encoders aren't necessarily synchronized and although one encoder may have unpaused, the other encoder(s) may not have yet. Checking all encoders first before allowing a pause/unpause ensures that doesn't occur.
2019-08-31 07:59:48 +00:00
}
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
libobs: Fail pause/unpause if still waiting for them When a pause/unpause occurs, a timestamp is set and the actual pause/unpause does not occur until the output/encoders reach the specified timestamps. Do not allow pausing/unpausing unless that point has been reached with all encoders of an encoded output or the output itself when using a raw output. This fixes a bug where pause data could get corrupted if pausing/unpausing too fast, because the audio/video encoders aren't necessarily synchronized and although one encoder may have unpaused, the other encoder(s) may not have yet. Checking all encoders first before allowing a pause/unpause ensures that doesn't occur.
2019-08-31 07:59:48 +00:00
if (aenc[i] && !pause_can_stop(&aenc[i]->pause)) {
goto fail;
}
}
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
if (venc[i]) {
os_atomic_set_bool(&venc[i]->paused, false);
end_pause(&venc[i]->pause, closest_v_ts);
}
}
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
if (aenc[i]) {
os_atomic_set_bool(&aenc[i]->paused, false);
end_pause(&aenc[i]->pause, closest_v_ts);
}
}
}
/* ---------------------------- */
libobs: Fail pause/unpause if still waiting for them When a pause/unpause occurs, a timestamp is set and the actual pause/unpause does not occur until the output/encoders reach the specified timestamps. Do not allow pausing/unpausing unless that point has been reached with all encoders of an encoded output or the output itself when using a raw output. This fixes a bug where pause data could get corrupted if pausing/unpausing too fast, because the audio/video encoders aren't necessarily synchronized and although one encoder may have unpaused, the other encoder(s) may not have yet. Checking all encoders first before allowing a pause/unpause ensures that doesn't occur.
2019-08-31 07:59:48 +00:00
success = true;
fail:
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
for (size_t i = MAX_OUTPUT_AUDIO_ENCODERS; i > 0; i--) {
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
if (aenc[i - 1]) {
pthread_mutex_unlock(&aenc[i - 1]->pause.mutex);
}
}
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
for (size_t i = MAX_OUTPUT_VIDEO_ENCODERS; i > 0; i--) {
if (venc[i - 1]) {
pthread_mutex_unlock(&venc[i - 1]->pause.mutex);
}
}
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
libobs: Fail pause/unpause if still waiting for them When a pause/unpause occurs, a timestamp is set and the actual pause/unpause does not occur until the output/encoders reach the specified timestamps. Do not allow pausing/unpausing unless that point has been reached with all encoders of an encoded output or the output itself when using a raw output. This fixes a bug where pause data could get corrupted if pausing/unpausing too fast, because the audio/video encoders aren't necessarily synchronized and although one encoder may have unpaused, the other encoder(s) may not have yet. Checking all encoders first before allowing a pause/unpause ensures that doesn't occur.
2019-08-31 07:59:48 +00:00
return success;
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
}
static bool obs_raw_output_pause(obs_output_t *output, bool pause)
{
bool success;
uint64_t closest_v_ts;
pthread_mutex_lock(&output->pause.mutex);
closest_v_ts = get_closest_v_ts(&output->pause);
if (pause) {
libobs: Fail pause/unpause if still waiting for them When a pause/unpause occurs, a timestamp is set and the actual pause/unpause does not occur until the output/encoders reach the specified timestamps. Do not allow pausing/unpausing unless that point has been reached with all encoders of an encoded output or the output itself when using a raw output. This fixes a bug where pause data could get corrupted if pausing/unpausing too fast, because the audio/video encoders aren't necessarily synchronized and although one encoder may have unpaused, the other encoder(s) may not have yet. Checking all encoders first before allowing a pause/unpause ensures that doesn't occur.
2019-08-31 07:59:48 +00:00
success = pause_can_start(&output->pause);
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
if (success)
output->pause.ts_start = closest_v_ts;
} else {
libobs: Fail pause/unpause if still waiting for them When a pause/unpause occurs, a timestamp is set and the actual pause/unpause does not occur until the output/encoders reach the specified timestamps. Do not allow pausing/unpausing unless that point has been reached with all encoders of an encoded output or the output itself when using a raw output. This fixes a bug where pause data could get corrupted if pausing/unpausing too fast, because the audio/video encoders aren't necessarily synchronized and although one encoder may have unpaused, the other encoder(s) may not have yet. Checking all encoders first before allowing a pause/unpause ensures that doesn't occur.
2019-08-31 07:59:48 +00:00
success = pause_can_stop(&output->pause);
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
if (success)
end_pause(&output->pause, closest_v_ts);
}
pthread_mutex_unlock(&output->pause.mutex);
return success;
}
bool obs_output_pause(obs_output_t *output, bool pause)
{
bool success;
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (!obs_output_valid(output, "obs_output_pause"))
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
return false;
if ((output->info.flags & OBS_OUTPUT_CAN_PAUSE) == 0)
return false;
if (!os_atomic_load_bool(&output->active))
return false;
if (os_atomic_load_bool(&output->paused) == pause)
return true;
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
success = flag_encoded(output) ? obs_encoded_output_pause(output, pause)
: obs_raw_output_pause(output, pause);
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
if (success) {
os_atomic_set_bool(&output->paused, pause);
do_output_signal(output, pause ? "pause" : "unpause");
blog(LOG_INFO, "output %s %spaused", output->context.name,
pause ? "" : "un");
}
return success;
}
bool obs_output_paused(const obs_output_t *output)
{
return obs_output_valid(output, "obs_output_paused")
? os_atomic_load_bool(&output->paused)
: false;
}
uint64_t obs_output_get_pause_offset(obs_output_t *output)
{
uint64_t offset;
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
if (!obs_output_valid(output, "obs_output_get_pause_offset"))
return 0;
pthread_mutex_lock(&output->pause.mutex);
offset = output->pause.ts_offset;
pthread_mutex_unlock(&output->pause.mutex);
return offset;
first commit
2013-10-01 02:37:13 +00:00
}
Add preliminary streaming code for testing - Add some temporary streaming code using FFmpeg. FFmpeg itself is not very ideal for streaming; lack of direct control of the sockets and no framedrop handling means that FFmpeg is definitely not something you want to use without wrapper code. I'd prefer writing my own network framework in this particular case just because you give away so much control of the network interface. Wasted an entire day trying to go through FFmpeg issues. There's just no way FFmpeg should be used for real streaming (at least without being patched or submitting some sort of patch, but I'm sort of feeling "meh" on that idea) I had to end up writing multiple threads just to handle both connecting and writing, because av_interleaved_write_frame blocks every call, stalling the main encoder thread, and thus also stalling draw signals. - Add some temporary user interface for streaming settings. This is just temporary for the time being. It's in the outputs section of the basic-mode settings - Make it so that dynamic arrays do not free all their data when the size just happens to be reduced to 0. This prevents constant reallocation when an array keeps going from 1 item to 0 items. Also, it was bad to become dependent upon that functionality. You must now always explicitly call "free" on it to ensure the data is free, and that's how it should be. Implicit functionality can lead to confusion and maintainability issues.
2014-03-10 20:10:35 +00:00
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 22:25:59 +00:00
signal_handler_t *obs_output_get_signal_handler(const obs_output_t *output)
Add preliminary streaming code for testing - Add some temporary streaming code using FFmpeg. FFmpeg itself is not very ideal for streaming; lack of direct control of the sockets and no framedrop handling means that FFmpeg is definitely not something you want to use without wrapper code. I'd prefer writing my own network framework in this particular case just because you give away so much control of the network interface. Wasted an entire day trying to go through FFmpeg issues. There's just no way FFmpeg should be used for real streaming (at least without being patched or submitting some sort of patch, but I'm sort of feeling "meh" on that idea) I had to end up writing multiple threads just to handle both connecting and writing, because av_interleaved_write_frame blocks every call, stalling the main encoder thread, and thus also stalling draw signals. - Add some temporary user interface for streaming settings. This is just temporary for the time being. It's in the outputs section of the basic-mode settings - Make it so that dynamic arrays do not free all their data when the size just happens to be reduced to 0. This prevents constant reallocation when an array keeps going from 1 item to 0 items. Also, it was bad to become dependent upon that functionality. You must now always explicitly call "free" on it to ensure the data is free, and that's how it should be. Implicit functionality can lead to confusion and maintainability issues.
2014-03-10 20:10:35 +00:00
{
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
return obs_output_valid(output, "obs_output_get_signal_handler")
? output->context.signals
: NULL;
Add preliminary streaming code for testing - Add some temporary streaming code using FFmpeg. FFmpeg itself is not very ideal for streaming; lack of direct control of the sockets and no framedrop handling means that FFmpeg is definitely not something you want to use without wrapper code. I'd prefer writing my own network framework in this particular case just because you give away so much control of the network interface. Wasted an entire day trying to go through FFmpeg issues. There's just no way FFmpeg should be used for real streaming (at least without being patched or submitting some sort of patch, but I'm sort of feeling "meh" on that idea) I had to end up writing multiple threads just to handle both connecting and writing, because av_interleaved_write_frame blocks every call, stalling the main encoder thread, and thus also stalling draw signals. - Add some temporary user interface for streaming settings. This is just temporary for the time being. It's in the outputs section of the basic-mode settings - Make it so that dynamic arrays do not free all their data when the size just happens to be reduced to 0. This prevents constant reallocation when an array keeps going from 1 item to 0 items. Also, it was bad to become dependent upon that functionality. You must now always explicitly call "free" on it to ensure the data is free, and that's how it should be. Implicit functionality can lead to confusion and maintainability issues.
2014-03-10 20:10:35 +00:00
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 22:25:59 +00:00
proc_handler_t *obs_output_get_proc_handler(const obs_output_t *output)
Add preliminary streaming code for testing - Add some temporary streaming code using FFmpeg. FFmpeg itself is not very ideal for streaming; lack of direct control of the sockets and no framedrop handling means that FFmpeg is definitely not something you want to use without wrapper code. I'd prefer writing my own network framework in this particular case just because you give away so much control of the network interface. Wasted an entire day trying to go through FFmpeg issues. There's just no way FFmpeg should be used for real streaming (at least without being patched or submitting some sort of patch, but I'm sort of feeling "meh" on that idea) I had to end up writing multiple threads just to handle both connecting and writing, because av_interleaved_write_frame blocks every call, stalling the main encoder thread, and thus also stalling draw signals. - Add some temporary user interface for streaming settings. This is just temporary for the time being. It's in the outputs section of the basic-mode settings - Make it so that dynamic arrays do not free all their data when the size just happens to be reduced to 0. This prevents constant reallocation when an array keeps going from 1 item to 0 items. Also, it was bad to become dependent upon that functionality. You must now always explicitly call "free" on it to ensure the data is free, and that's how it should be. Implicit functionality can lead to confusion and maintainability issues.
2014-03-10 20:10:35 +00:00
{
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
return obs_output_valid(output, "obs_output_get_proc_handler")
? output->context.procs
: NULL;
Add preliminary streaming code for testing - Add some temporary streaming code using FFmpeg. FFmpeg itself is not very ideal for streaming; lack of direct control of the sockets and no framedrop handling means that FFmpeg is definitely not something you want to use without wrapper code. I'd prefer writing my own network framework in this particular case just because you give away so much control of the network interface. Wasted an entire day trying to go through FFmpeg issues. There's just no way FFmpeg should be used for real streaming (at least without being patched or submitting some sort of patch, but I'm sort of feeling "meh" on that idea) I had to end up writing multiple threads just to handle both connecting and writing, because av_interleaved_write_frame blocks every call, stalling the main encoder thread, and thus also stalling draw signals. - Add some temporary user interface for streaming settings. This is just temporary for the time being. It's in the outputs section of the basic-mode settings - Make it so that dynamic arrays do not free all their data when the size just happens to be reduced to 0. This prevents constant reallocation when an array keeps going from 1 item to 0 items. Also, it was bad to become dependent upon that functionality. You must now always explicitly call "free" on it to ensure the data is free, and that's how it should be. Implicit functionality can lead to confusion and maintainability issues.
2014-03-10 20:10:35 +00:00
}
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
void obs_output_set_media(obs_output_t *output, video_t *video, audio_t *audio)
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
{
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (!obs_output_valid(output, "obs_output_set_media"))
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
return;
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
if (log_flag_encoded(output, __FUNCTION__, true))
return;
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
if (flag_video(output))
output->video = video;
if (flag_audio(output))
output->audio = audio;
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 22:25:59 +00:00
video_t *obs_output_video(const obs_output_t *output)
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
{
libobs: Fix obs_output_video and obs_output_audio for encoded output The API `obs_output_video` and `obs_output_audio` returned valid pointers until the commit fb57eff21 and 645e31fa1. The API `obs_output_video` is used by some plugins such as obs-websocket and obs-midi to calculate the duration of streaming and recording. To have a similar behavior, return the media (video and audio, respectively) from the encoder.
2023-08-30 13:44:46 +00:00
if (!obs_output_valid(output, "obs_output_video"))
return NULL;
if (!flag_encoded(output))
return output->video;
obs_encoder_t *vencoder = obs_output_get_video_encoder(output);
return obs_encoder_video(vencoder);
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 22:25:59 +00:00
audio_t *obs_output_audio(const obs_output_t *output)
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
{
libobs: Fix obs_output_video and obs_output_audio for encoded output The API `obs_output_video` and `obs_output_audio` returned valid pointers until the commit fb57eff21 and 645e31fa1. The API `obs_output_video` is used by some plugins such as obs-websocket and obs-midi to calculate the duration of streaming and recording. To have a similar behavior, return the media (video and audio, respectively) from the encoder.
2023-08-30 13:44:46 +00:00
if (!obs_output_valid(output, "obs_output_audio"))
return NULL;
if (!flag_encoded(output))
return output->audio;
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
if (output->audio_encoders[i])
return obs_encoder_audio(output->audio_encoders[i]);
}
return NULL;
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
}
libobs: Add multi-track support to non-encoded outputs
2018-10-05 03:04:40 +00:00
static inline size_t get_first_mixer(const obs_output_t *output)
{
for (size_t i = 0; i < MAX_AUDIO_MIXES; i++) {
if ((((size_t)1 << i) & output->mixer_mask) != 0) {
return i;
}
}
return 0;
}
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
void obs_output_set_mixer(obs_output_t *output, size_t mixer_idx)
{
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (!obs_output_valid(output, "obs_output_set_mixer"))
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
return;
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
if (log_flag_encoded(output, __FUNCTION__, true))
return;
if (active(output))
return;
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
output->mixer_mask = (size_t)1 << mixer_idx;
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
}
size_t obs_output_get_mixer(const obs_output_t *output)
{
libobs: Add multi-track support to non-encoded outputs
2018-10-05 03:04:40 +00:00
if (!obs_output_valid(output, "obs_output_get_mixer"))
return 0;
return get_first_mixer(output);
}
void obs_output_set_mixers(obs_output_t *output, size_t mixers)
{
if (!obs_output_valid(output, "obs_output_set_mixers"))
return;
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
if (log_flag_encoded(output, __FUNCTION__, true))
return;
if (active(output))
return;
libobs: Add multi-track support to non-encoded outputs
2018-10-05 03:04:40 +00:00
output->mixer_mask = mixers;
}
size_t obs_output_get_mixers(const obs_output_t *output)
{
return obs_output_valid(output, "obs_output_get_mixers")
? output->mixer_mask
: 0;
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
}
libobs: Make internal version of remove encoder
2023-01-16 23:33:15 +00:00
void obs_output_remove_encoder_internal(struct obs_output *output,
struct obs_encoder *encoder)
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
{
libobs: Make internal version of remove encoder
2023-01-16 23:33:15 +00:00
if (!obs_output_valid(output, "obs_output_remove_encoder_internal"))
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
return;
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (encoder->info.type == OBS_ENCODER_VIDEO) {
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
obs_encoder_t *video = output->video_encoders[i];
if (video == encoder)
output->video_encoders[i] = NULL;
}
} else if (encoder->info.type == OBS_ENCODER_AUDIO) {
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
obs_encoder_t *audio = output->audio_encoders[i];
if (audio == encoder)
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
output->audio_encoders[i] = NULL;
}
}
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
}
libobs: Make internal version of remove encoder
2023-01-16 23:33:15 +00:00
void obs_output_remove_encoder(struct obs_output *output,
struct obs_encoder *encoder)
{
if (!obs_output_valid(output, "obs_output_remove_encoder"))
return;
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
if (active(output))
libobs: Make internal version of remove encoder
2023-01-16 23:33:15 +00:00
return;
obs_output_remove_encoder_internal(output, encoder);
}
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
static struct caption_track_data *create_caption_track()
{
struct caption_track_data *rval =
bzalloc(sizeof(struct caption_track_data));
pthread_mutex_init_value(&rval->caption_mutex);
if (pthread_mutex_init(&rval->caption_mutex, NULL) != 0) {
bfree(rval);
rval = NULL;
}
return rval;
}
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
void obs_output_set_video_encoder2(obs_output_t *output, obs_encoder_t *encoder,
size_t idx)
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
{
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (!obs_output_valid(output, "obs_output_set_video_encoder2"))
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
return;
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
if (!log_flag_encoded(output, __FUNCTION__, false) ||
!log_flag_video(output, __FUNCTION__))
return;
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (encoder && encoder->info.type != OBS_ENCODER_VIDEO) {
blog(LOG_WARNING, "obs_output_set_video_encoder: "
"encoder passed is not a video encoder");
return;
}
libobs: Check if output active when setting encoders This fixes an issue where someone might mistakenly try to change an audio/video encoder before the output is complete.
2020-09-23 21:47:30 +00:00
if (active(output)) {
blog(LOG_WARNING,
"%s: tried to set video encoder on output \"%s\" "
"while the output is still active!",
__FUNCTION__, output->context.name);
return;
}
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if ((output->info.flags & OBS_OUTPUT_MULTI_TRACK_VIDEO) != 0) {
if (idx >= MAX_OUTPUT_VIDEO_ENCODERS) {
return;
}
} else {
if (idx > 0) {
return;
}
}
if (output->video_encoders[idx] == encoder)
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
return;
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
obs_encoder_remove_output(output->video_encoders[idx], output);
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
obs_encoder_add_output(encoder, output);
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
output->video_encoders[idx] = encoder;
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
destroy_caption_track(&output->caption_tracks[idx]);
if (encoder != NULL) {
output->caption_tracks[idx] = create_caption_track();
} else {
output->caption_tracks[idx] = NULL;
}
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
// Set preferred resolution on the default index to preserve old behavior
if (idx == 0) {
/* set the preferred resolution on the encoder */
if (output->scaled_width && output->scaled_height)
obs_encoder_set_scaled_size(output->video_encoders[idx],
output->scaled_width,
output->scaled_height);
}
}
void obs_output_set_video_encoder(obs_output_t *output, obs_encoder_t *encoder)
{
if (!obs_output_valid(output, "obs_output_set_video_encoder"))
return;
Add API functions for output/encoder scaling API functions added: ----------------------------------------------- obs_output_set_preferred_size obs_output_get_width obs_output_get_height obs_encoder_set_scaled_size obs_encoder_get_width obs_encoder_get_height These functions allow for easier means of setting a custom resolution on an output or encoder. If an output uses an encoder and you set the preferred width/height using the output, then the output will attempt to set the scaled width/height for the encoder it's currently using. Outputs and encoders now should use these functions to determine the width/height of the raw frame data instead of using the video-io functions.
2014-08-10 23:50:44 +00:00
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
obs_output_set_video_encoder2(output, encoder, 0);
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
}
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
void obs_output_set_audio_encoder(obs_output_t *output, obs_encoder_t *encoder,
size_t idx)
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
{
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (!obs_output_valid(output, "obs_output_set_audio_encoder"))
return;
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
if (!log_flag_encoded(output, __FUNCTION__, false) ||
!log_flag_audio(output, __FUNCTION__))
return;
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (encoder && encoder->info.type != OBS_ENCODER_AUDIO) {
blog(LOG_WARNING, "obs_output_set_audio_encoder: "
"encoder passed is not an audio encoder");
return;
}
libobs: Check if output active when setting encoders This fixes an issue where someone might mistakenly try to change an audio/video encoder before the output is complete.
2020-09-23 21:47:30 +00:00
if (active(output)) {
blog(LOG_WARNING,
"%s: tried to set audio encoder %d on output \"%s\" "
"while the output is still active!",
__FUNCTION__, (int)idx, output->context.name);
return;
}
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if ((output->info.flags & OBS_OUTPUT_MULTI_TRACK_AUDIO) != 0) {
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
if (idx >= MAX_OUTPUT_AUDIO_ENCODERS) {
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
return;
}
} else {
if (idx > 0) {
return;
}
}
if (output->audio_encoders[idx] == encoder)
return;
obs_encoder_remove_output(output->audio_encoders[idx], output);
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
obs_encoder_add_output(encoder, output);
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
output->audio_encoders[idx] = encoder;
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
}
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
obs_encoder_t *obs_output_get_video_encoder2(const obs_output_t *output,
size_t idx)
{
if (!obs_output_valid(output, "obs_output_get_video_encoder2"))
return NULL;
if (idx >= MAX_OUTPUT_VIDEO_ENCODERS)
return NULL;
return output->video_encoders[idx];
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 22:25:59 +00:00
obs_encoder_t *obs_output_get_video_encoder(const obs_output_t *output)
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
{
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (!obs_output_valid(output, "obs_output_get_video_encoder"))
return NULL;
size_t first_venc_idx;
if (get_first_video_encoder_index(output, &first_venc_idx))
return obs_output_get_video_encoder2(output, first_venc_idx);
else
return NULL;
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
}
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
obs_encoder_t *obs_output_get_audio_encoder(const obs_output_t *output,
size_t idx)
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
{
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (!obs_output_valid(output, "obs_output_get_audio_encoder"))
return NULL;
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
if (idx >= MAX_OUTPUT_AUDIO_ENCODERS)
return NULL;
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
return output->audio_encoders[idx];
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
void obs_output_set_service(obs_output_t *output, obs_service_t *service)
obs-studio UI: Implement stream settings UI - Updated the services API so that it links up with an output and the output gets data from that service rather than via settings. This allows the service context to have control over how an output is used, and makes it so that the URL/key/etc isn't necessarily some static setting. Also, if the service is attached to an output, it will stick around until the output is destroyed. - The settings interface has been updated so that it can allow the usage of service plugins. What this means is that now you can create a service plugin that can control aspects of the stream, and it allows each service to create their own user interface if they create a service plugin module. - Testing out saving of current service information. Saves/loads from JSON in to obs_data_t, seems to be working quite nicely, and the service object information is saved/preserved on exit, and loaded again on startup. - I agonized over the settings user interface for days, and eventually I just decided that the only way that users weren't going to be fumbling over options was to split up the settings in to simple/basic output, pre-configured, and then advanced for advanced use (such as multiple outputs or services, which I'll implement later). This was particularly painful to really design right, I wanted more features and wanted to include everything in one interface but ultimately just realized from experience that users are just not technically knowledgable about it and will end up fumbling with the settings rather than getting things done. Basically, what this means is that casual users only have to enter in about 3 things to configure their stream: Stream key, audio bitrate, and video bitrate. I am really happy with this interface for those types of users, but it definitely won't be sufficient for advanced usage or for custom outputs, so that stuff will have to be separated. - Improved the JSON usage for the 'common streaming services' context, I realized that JSON arrays are there to ensure sorting, while forgetting that general items are optimized for hashing. So basically I'm just using arrays now to sort items in it.
2014-04-24 08:49:07 +00:00
{
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (!obs_output_valid(output, "obs_output_set_service"))
return;
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
if (!log_flag_service(output, __FUNCTION__) || active(output) ||
!service || service->active)
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
return;
obs-studio UI: Implement stream settings UI - Updated the services API so that it links up with an output and the output gets data from that service rather than via settings. This allows the service context to have control over how an output is used, and makes it so that the URL/key/etc isn't necessarily some static setting. Also, if the service is attached to an output, it will stick around until the output is destroyed. - The settings interface has been updated so that it can allow the usage of service plugins. What this means is that now you can create a service plugin that can control aspects of the stream, and it allows each service to create their own user interface if they create a service plugin module. - Testing out saving of current service information. Saves/loads from JSON in to obs_data_t, seems to be working quite nicely, and the service object information is saved/preserved on exit, and loaded again on startup. - I agonized over the settings user interface for days, and eventually I just decided that the only way that users weren't going to be fumbling over options was to split up the settings in to simple/basic output, pre-configured, and then advanced for advanced use (such as multiple outputs or services, which I'll implement later). This was particularly painful to really design right, I wanted more features and wanted to include everything in one interface but ultimately just realized from experience that users are just not technically knowledgable about it and will end up fumbling with the settings rather than getting things done. Basically, what this means is that casual users only have to enter in about 3 things to configure their stream: Stream key, audio bitrate, and video bitrate. I am really happy with this interface for those types of users, but it definitely won't be sufficient for advanced usage or for custom outputs, so that stuff will have to be separated. - Improved the JSON usage for the 'common streaming services' context, I realized that JSON arrays are there to ensure sorting, while forgetting that general items are optimized for hashing. So basically I'm just using arrays now to sort items in it.
2014-04-24 08:49:07 +00:00
if (service->output)
service->output->service = NULL;
output->service = service;
service->output = output;
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 22:25:59 +00:00
obs_service_t *obs_output_get_service(const obs_output_t *output)
obs-studio UI: Implement stream settings UI - Updated the services API so that it links up with an output and the output gets data from that service rather than via settings. This allows the service context to have control over how an output is used, and makes it so that the URL/key/etc isn't necessarily some static setting. Also, if the service is attached to an output, it will stick around until the output is destroyed. - The settings interface has been updated so that it can allow the usage of service plugins. What this means is that now you can create a service plugin that can control aspects of the stream, and it allows each service to create their own user interface if they create a service plugin module. - Testing out saving of current service information. Saves/loads from JSON in to obs_data_t, seems to be working quite nicely, and the service object information is saved/preserved on exit, and loaded again on startup. - I agonized over the settings user interface for days, and eventually I just decided that the only way that users weren't going to be fumbling over options was to split up the settings in to simple/basic output, pre-configured, and then advanced for advanced use (such as multiple outputs or services, which I'll implement later). This was particularly painful to really design right, I wanted more features and wanted to include everything in one interface but ultimately just realized from experience that users are just not technically knowledgable about it and will end up fumbling with the settings rather than getting things done. Basically, what this means is that casual users only have to enter in about 3 things to configure their stream: Stream key, audio bitrate, and video bitrate. I am really happy with this interface for those types of users, but it definitely won't be sufficient for advanced usage or for custom outputs, so that stuff will have to be separated. - Improved the JSON usage for the 'common streaming services' context, I realized that JSON arrays are there to ensure sorting, while forgetting that general items are optimized for hashing. So basically I'm just using arrays now to sort items in it.
2014-04-24 08:49:07 +00:00
{
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
return obs_output_valid(output, "obs_output_get_service")
? output->service
: NULL;
obs-studio UI: Implement stream settings UI - Updated the services API so that it links up with an output and the output gets data from that service rather than via settings. This allows the service context to have control over how an output is used, and makes it so that the URL/key/etc isn't necessarily some static setting. Also, if the service is attached to an output, it will stick around until the output is destroyed. - The settings interface has been updated so that it can allow the usage of service plugins. What this means is that now you can create a service plugin that can control aspects of the stream, and it allows each service to create their own user interface if they create a service plugin module. - Testing out saving of current service information. Saves/loads from JSON in to obs_data_t, seems to be working quite nicely, and the service object information is saved/preserved on exit, and loaded again on startup. - I agonized over the settings user interface for days, and eventually I just decided that the only way that users weren't going to be fumbling over options was to split up the settings in to simple/basic output, pre-configured, and then advanced for advanced use (such as multiple outputs or services, which I'll implement later). This was particularly painful to really design right, I wanted more features and wanted to include everything in one interface but ultimately just realized from experience that users are just not technically knowledgable about it and will end up fumbling with the settings rather than getting things done. Basically, what this means is that casual users only have to enter in about 3 things to configure their stream: Stream key, audio bitrate, and video bitrate. I am really happy with this interface for those types of users, but it definitely won't be sufficient for advanced usage or for custom outputs, so that stuff will have to be separated. - Improved the JSON usage for the 'common streaming services' context, I realized that JSON arrays are there to ensure sorting, while forgetting that general items are optimized for hashing. So basically I'm just using arrays now to sort items in it.
2014-04-24 08:49:07 +00:00
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
void obs_output_set_reconnect_settings(obs_output_t *output, int retry_count,
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
int retry_sec)
{
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (!obs_output_valid(output, "obs_output_set_reconnect_settings"))
return;
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
output->reconnect_retry_max = retry_count;
output->reconnect_retry_sec = retry_sec;
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 22:25:59 +00:00
uint64_t obs_output_get_total_bytes(const obs_output_t *output)
Add statistics functions to outputs Total bytes, total frames, and frames dropped. Total frames is generated automatically, but total bytes and total dropped frames are returned via callbacks.
2014-07-06 21:55:56 +00:00
{
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (!obs_output_valid(output, "obs_output_get_total_bytes"))
return 0;
if (!output->info.get_total_bytes)
Add statistics functions to outputs Total bytes, total frames, and frames dropped. Total frames is generated automatically, but total bytes and total dropped frames are returned via callbacks.
2014-07-06 21:55:56 +00:00
return 0;
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
if (delay_active(output) && !delay_capturing(output))
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
return 0;
(API Change) Use 'get' convention: API callbacks Renamed: To: ------------------------------------------------------- obs_source_info::defaults obs_source_info::get_defaults obs_source_info::properties obs_source_info::get_properties obs_output_info::defaults obs_output_info::get_defaults obs_output_info::properties obs_output_info::get_properties obs_output_info::total_bytes obs_output_info::get_total_bytes obs_output_info::dropped_frames obs_output_info::get_dropped_frames obs_encoder_info::defaults obs_encoder_info::get_defaults obs_encoder_info::properties obs_encoder_info::get_properties obs_encoder_info::extra_data obs_encoder_info::get_extra_data obs_encoder_info::sei_data obs_encoder_info::get_sei_data obs_encoder_info::audio_info obs_encoder_info::get_audio_info obs_encoder_info::video_info obs_encoder_info::get_video_fino obs_service_info::defaults obs_service_info::get_defaults obs_service_info::properties obs_service_info::get_properties
2014-08-05 04:27:52 +00:00
return output->info.get_total_bytes(output->context.data);
Add statistics functions to outputs Total bytes, total frames, and frames dropped. Total frames is generated automatically, but total bytes and total dropped frames are returned via callbacks.
2014-07-06 21:55:56 +00:00
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 22:25:59 +00:00
int obs_output_get_frames_dropped(const obs_output_t *output)
Add statistics functions to outputs Total bytes, total frames, and frames dropped. Total frames is generated automatically, but total bytes and total dropped frames are returned via callbacks.
2014-07-06 21:55:56 +00:00
{
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (!obs_output_valid(output, "obs_output_get_frames_dropped"))
return 0;
if (!output->info.get_dropped_frames)
Add statistics functions to outputs Total bytes, total frames, and frames dropped. Total frames is generated automatically, but total bytes and total dropped frames are returned via callbacks.
2014-07-06 21:55:56 +00:00
return 0;
(API Change) Use 'get' convention: API callbacks Renamed: To: ------------------------------------------------------- obs_source_info::defaults obs_source_info::get_defaults obs_source_info::properties obs_source_info::get_properties obs_output_info::defaults obs_output_info::get_defaults obs_output_info::properties obs_output_info::get_properties obs_output_info::total_bytes obs_output_info::get_total_bytes obs_output_info::dropped_frames obs_output_info::get_dropped_frames obs_encoder_info::defaults obs_encoder_info::get_defaults obs_encoder_info::properties obs_encoder_info::get_properties obs_encoder_info::extra_data obs_encoder_info::get_extra_data obs_encoder_info::sei_data obs_encoder_info::get_sei_data obs_encoder_info::audio_info obs_encoder_info::get_audio_info obs_encoder_info::video_info obs_encoder_info::get_video_fino obs_service_info::defaults obs_service_info::get_defaults obs_service_info::properties obs_service_info::get_properties
2014-08-05 04:27:52 +00:00
return output->info.get_dropped_frames(output->context.data);
Add statistics functions to outputs Total bytes, total frames, and frames dropped. Total frames is generated automatically, but total bytes and total dropped frames are returned via callbacks.
2014-07-06 21:55:56 +00:00
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 22:25:59 +00:00
int obs_output_get_total_frames(const obs_output_t *output)
Add statistics functions to outputs Total bytes, total frames, and frames dropped. Total frames is generated automatically, but total bytes and total dropped frames are returned via callbacks.
2014-07-06 21:55:56 +00:00
{
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
return obs_output_valid(output, "obs_output_get_total_frames")
? output->total_frames
: 0;
Add statistics functions to outputs Total bytes, total frames, and frames dropped. Total frames is generated automatically, but total bytes and total dropped frames are returned via callbacks.
2014-07-06 21:55:56 +00:00
}
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
void obs_output_set_preferred_size2(obs_output_t *output, uint32_t width,
uint32_t height, size_t idx)
Add API functions for output/encoder scaling API functions added: ----------------------------------------------- obs_output_set_preferred_size obs_output_get_width obs_output_get_height obs_encoder_set_scaled_size obs_encoder_get_width obs_encoder_get_height These functions allow for easier means of setting a custom resolution on an output or encoder. If an output uses an encoder and you set the preferred width/height using the output, then the output will attempt to set the scaled width/height for the encoder it's currently using. Outputs and encoders now should use these functions to determine the width/height of the raw frame data instead of using the video-io functions.
2014-08-10 23:50:44 +00:00
{
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (!obs_output_valid(output, "obs_output_set_preferred_size2"))
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
return;
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
if (!log_flag_video(output, __FUNCTION__))
Add API functions for output/encoder scaling API functions added: ----------------------------------------------- obs_output_set_preferred_size obs_output_get_width obs_output_get_height obs_encoder_set_scaled_size obs_encoder_get_width obs_encoder_get_height These functions allow for easier means of setting a custom resolution on an output or encoder. If an output uses an encoder and you set the preferred width/height using the output, then the output will attempt to set the scaled width/height for the encoder it's currently using. Outputs and encoders now should use these functions to determine the width/height of the raw frame data instead of using the video-io functions.
2014-08-10 23:50:44 +00:00
return;
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (idx >= MAX_OUTPUT_VIDEO_ENCODERS)
return;
Add API functions for output/encoder scaling API functions added: ----------------------------------------------- obs_output_set_preferred_size obs_output_get_width obs_output_get_height obs_encoder_set_scaled_size obs_encoder_get_width obs_encoder_get_height These functions allow for easier means of setting a custom resolution on an output or encoder. If an output uses an encoder and you set the preferred width/height using the output, then the output will attempt to set the scaled width/height for the encoder it's currently using. Outputs and encoders now should use these functions to determine the width/height of the raw frame data instead of using the video-io functions.
2014-08-10 23:50:44 +00:00
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
if (active(output)) {
Add API functions for output/encoder scaling API functions added: ----------------------------------------------- obs_output_set_preferred_size obs_output_get_width obs_output_get_height obs_encoder_set_scaled_size obs_encoder_get_width obs_encoder_get_height These functions allow for easier means of setting a custom resolution on an output or encoder. If an output uses an encoder and you set the preferred width/height using the output, then the output will attempt to set the scaled width/height for the encoder it's currently using. Outputs and encoders now should use these functions to determine the width/height of the raw frame data instead of using the video-io functions.
2014-08-10 23:50:44 +00:00
blog(LOG_WARNING,
"output '%s': Cannot set the preferred "
"resolution while the output is active",
obs_output_get_name(output));
return;
}
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
// Used for raw video output
if (idx == 0) {
output->scaled_width = width;
output->scaled_height = height;
}
Add API functions for output/encoder scaling API functions added: ----------------------------------------------- obs_output_set_preferred_size obs_output_get_width obs_output_get_height obs_encoder_set_scaled_size obs_encoder_get_width obs_encoder_get_height These functions allow for easier means of setting a custom resolution on an output or encoder. If an output uses an encoder and you set the preferred width/height using the output, then the output will attempt to set the scaled width/height for the encoder it's currently using. Outputs and encoders now should use these functions to determine the width/height of the raw frame data instead of using the video-io functions.
2014-08-10 23:50:44 +00:00
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
if (flag_encoded(output)) {
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (output->video_encoders[idx])
obs_encoder_set_scaled_size(output->video_encoders[idx],
Add API functions for output/encoder scaling API functions added: ----------------------------------------------- obs_output_set_preferred_size obs_output_get_width obs_output_get_height obs_encoder_set_scaled_size obs_encoder_get_width obs_encoder_get_height These functions allow for easier means of setting a custom resolution on an output or encoder. If an output uses an encoder and you set the preferred width/height using the output, then the output will attempt to set the scaled width/height for the encoder it's currently using. Outputs and encoders now should use these functions to determine the width/height of the raw frame data instead of using the video-io functions.
2014-08-10 23:50:44 +00:00
width, height);
}
}
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
void obs_output_set_preferred_size(obs_output_t *output, uint32_t width,
uint32_t height)
Add API functions for output/encoder scaling API functions added: ----------------------------------------------- obs_output_set_preferred_size obs_output_get_width obs_output_get_height obs_encoder_set_scaled_size obs_encoder_get_width obs_encoder_get_height These functions allow for easier means of setting a custom resolution on an output or encoder. If an output uses an encoder and you set the preferred width/height using the output, then the output will attempt to set the scaled width/height for the encoder it's currently using. Outputs and encoders now should use these functions to determine the width/height of the raw frame data instead of using the video-io functions.
2014-08-10 23:50:44 +00:00
{
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (!obs_output_valid(output, "obs_output_set_preferred_size"))
return;
if (!log_flag_video(output, __FUNCTION__))
return;
obs_output_set_preferred_size2(output, width, height, 0);
}
uint32_t obs_output_get_width2(const obs_output_t *output, size_t idx)
{
if (!obs_output_valid(output, "obs_output_get_width2"))
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
return 0;
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
if (!log_flag_video(output, __FUNCTION__))
Add API functions for output/encoder scaling API functions added: ----------------------------------------------- obs_output_set_preferred_size obs_output_get_width obs_output_get_height obs_encoder_set_scaled_size obs_encoder_get_width obs_encoder_get_height These functions allow for easier means of setting a custom resolution on an output or encoder. If an output uses an encoder and you set the preferred width/height using the output, then the output will attempt to set the scaled width/height for the encoder it's currently using. Outputs and encoders now should use these functions to determine the width/height of the raw frame data instead of using the video-io functions.
2014-08-10 23:50:44 +00:00
return 0;
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (idx >= MAX_OUTPUT_VIDEO_ENCODERS)
return 0;
Add API functions for output/encoder scaling API functions added: ----------------------------------------------- obs_output_set_preferred_size obs_output_get_width obs_output_get_height obs_encoder_set_scaled_size obs_encoder_get_width obs_encoder_get_height These functions allow for easier means of setting a custom resolution on an output or encoder. If an output uses an encoder and you set the preferred width/height using the output, then the output will attempt to set the scaled width/height for the encoder it's currently using. Outputs and encoders now should use these functions to determine the width/height of the raw frame data instead of using the video-io functions.
2014-08-10 23:50:44 +00:00
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (flag_encoded(output)) {
if (output->video_encoders[idx])
return obs_encoder_get_width(
output->video_encoders[idx]);
else
return 0;
} else
Add API functions for output/encoder scaling API functions added: ----------------------------------------------- obs_output_set_preferred_size obs_output_get_width obs_output_get_height obs_encoder_set_scaled_size obs_encoder_get_width obs_encoder_get_height These functions allow for easier means of setting a custom resolution on an output or encoder. If an output uses an encoder and you set the preferred width/height using the output, then the output will attempt to set the scaled width/height for the encoder it's currently using. Outputs and encoders now should use these functions to determine the width/height of the raw frame data instead of using the video-io functions.
2014-08-10 23:50:44 +00:00
return output->scaled_width != 0
? output->scaled_width
: video_output_get_width(output->video);
}
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
uint32_t obs_output_get_width(const obs_output_t *output)
Add API functions for output/encoder scaling API functions added: ----------------------------------------------- obs_output_set_preferred_size obs_output_get_width obs_output_get_height obs_encoder_set_scaled_size obs_encoder_get_width obs_encoder_get_height These functions allow for easier means of setting a custom resolution on an output or encoder. If an output uses an encoder and you set the preferred width/height using the output, then the output will attempt to set the scaled width/height for the encoder it's currently using. Outputs and encoders now should use these functions to determine the width/height of the raw frame data instead of using the video-io functions.
2014-08-10 23:50:44 +00:00
{
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (!obs_output_valid(output, "obs_output_get_width"))
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
return 0;
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
if (!log_flag_video(output, __FUNCTION__))
Add API functions for output/encoder scaling API functions added: ----------------------------------------------- obs_output_set_preferred_size obs_output_get_width obs_output_get_height obs_encoder_set_scaled_size obs_encoder_get_width obs_encoder_get_height These functions allow for easier means of setting a custom resolution on an output or encoder. If an output uses an encoder and you set the preferred width/height using the output, then the output will attempt to set the scaled width/height for the encoder it's currently using. Outputs and encoders now should use these functions to determine the width/height of the raw frame data instead of using the video-io functions.
2014-08-10 23:50:44 +00:00
return 0;
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
return obs_output_get_width2(output, 0);
}
uint32_t obs_output_get_height2(const obs_output_t *output, size_t idx)
{
if (!obs_output_valid(output, "obs_output_get_height2"))
return 0;
if (!log_flag_video(output, __FUNCTION__))
return 0;
if (idx >= MAX_OUTPUT_VIDEO_ENCODERS)
return 0;
if (flag_encoded(output)) {
if (output->video_encoders[idx])
libobs: Fix obs_output_get_height2 returning width
2023-06-25 21:19:16 +00:00
return obs_encoder_get_height(
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
output->video_encoders[idx]);
else
return 0;
} else
Add API functions for output/encoder scaling API functions added: ----------------------------------------------- obs_output_set_preferred_size obs_output_get_width obs_output_get_height obs_encoder_set_scaled_size obs_encoder_get_width obs_encoder_get_height These functions allow for easier means of setting a custom resolution on an output or encoder. If an output uses an encoder and you set the preferred width/height using the output, then the output will attempt to set the scaled width/height for the encoder it's currently using. Outputs and encoders now should use these functions to determine the width/height of the raw frame data instead of using the video-io functions.
2014-08-10 23:50:44 +00:00
return output->scaled_height != 0
? output->scaled_height
: video_output_get_height(output->video);
}
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
uint32_t obs_output_get_height(const obs_output_t *output)
{
if (!obs_output_valid(output, "obs_output_get_height"))
return 0;
if (!log_flag_video(output, __FUNCTION__))
return 0;
return obs_output_get_height2(output, 0);
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
void obs_output_set_video_conversion(obs_output_t *output,
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
const struct video_scale_info *conversion)
{
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (!obs_output_valid(output, "obs_output_set_video_conversion"))
return;
if (!obs_ptr_valid(conversion, "obs_output_set_video_conversion"))
return;
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
if (log_flag_encoded(output, __FUNCTION__, true) ||
!log_flag_video(output, __FUNCTION__))
return;
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
output->video_conversion = *conversion;
output->video_conversion_set = true;
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
void obs_output_set_audio_conversion(
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
obs_output_t *output, const struct audio_convert_info *conversion)
{
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (!obs_output_valid(output, "obs_output_set_audio_conversion"))
return;
if (!obs_ptr_valid(conversion, "obs_output_set_audio_conversion"))
return;
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
if (log_flag_encoded(output, __FUNCTION__, true) ||
!log_flag_audio(output, __FUNCTION__))
return;
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
output->audio_conversion = *conversion;
output->audio_conversion_set = true;
}
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
static inline bool video_valid(const struct obs_output *output)
{
if (flag_encoded(output)) {
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
if (output->video_encoders[i]) {
return true;
}
}
return false;
} else {
return output->video != NULL;
}
}
libobs, plugins: Deprecate obs_output_t functions with flag parameters This deprecates the following functions, replacing them with new versions: - `obs_output_can_begin_data_capture()` - now `*capture2()` - `obs_output_initialize_encoders()` - now `*encoders2()` - `obs_output_begin_data_capture()` - now `*capture2()` The flags parameter was initially designed to support audio-only or video-only operation of an output which had the `OBS_OUTPUT_AV` flag, however, full support for that was never implemented, and there are likely fundamental issues with an implementation, mainly that most outputs are programmed assuming that there will always be at least one audio and one video track. This requires new flags specifying support for optional audio/video, among other things. An implementation to allow audio/video to be optional is best done using the flag technique above, with audio/video enablement specified by whether media (raw, `video_t/audio_t`) or encoder (`obs_encoder_t`) objects are specified. Since every implementation I could find always specifies `flags` as 0, I was able to safely conclude that immediately removing the parameter's functionality is safe to do.
2023-05-09 06:05:27 +00:00
static inline bool audio_valid(const struct obs_output *output)
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
{
libobs, plugins: Deprecate obs_output_t functions with flag parameters This deprecates the following functions, replacing them with new versions: - `obs_output_can_begin_data_capture()` - now `*capture2()` - `obs_output_initialize_encoders()` - now `*encoders2()` - `obs_output_begin_data_capture()` - now `*capture2()` The flags parameter was initially designed to support audio-only or video-only operation of an output which had the `OBS_OUTPUT_AV` flag, however, full support for that was never implemented, and there are likely fundamental issues with an implementation, mainly that most outputs are programmed assuming that there will always be at least one audio and one video track. This requires new flags specifying support for optional audio/video, among other things. An implementation to allow audio/video to be optional is best done using the flag technique above, with audio/video enablement specified by whether media (raw, `video_t/audio_t`) or encoder (`obs_encoder_t`) objects are specified. Since every implementation I could find always specifies `flags` as 0, I was able to safely conclude that immediately removing the parameter's functionality is safe to do.
2023-05-09 06:05:27 +00:00
if (flag_encoded(output)) {
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
if (output->audio_encoders[i]) {
return true;
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
}
}
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
return false;
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
}
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
return output->audio != NULL;
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
}
libobs, plugins: Deprecate obs_output_t functions with flag parameters This deprecates the following functions, replacing them with new versions: - `obs_output_can_begin_data_capture()` - now `*capture2()` - `obs_output_initialize_encoders()` - now `*encoders2()` - `obs_output_begin_data_capture()` - now `*capture2()` The flags parameter was initially designed to support audio-only or video-only operation of an output which had the `OBS_OUTPUT_AV` flag, however, full support for that was never implemented, and there are likely fundamental issues with an implementation, mainly that most outputs are programmed assuming that there will always be at least one audio and one video track. This requires new flags specifying support for optional audio/video, among other things. An implementation to allow audio/video to be optional is best done using the flag technique above, with audio/video enablement specified by whether media (raw, `video_t/audio_t`) or encoder (`obs_encoder_t`) objects are specified. Since every implementation I could find always specifies `flags` as 0, I was able to safely conclude that immediately removing the parameter's functionality is safe to do.
2023-05-09 06:05:27 +00:00
static bool can_begin_data_capture(const struct obs_output *output)
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
{
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (flag_video(output) && !video_valid(output))
return false;
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
libobs, plugins: Deprecate obs_output_t functions with flag parameters This deprecates the following functions, replacing them with new versions: - `obs_output_can_begin_data_capture()` - now `*capture2()` - `obs_output_initialize_encoders()` - now `*encoders2()` - `obs_output_begin_data_capture()` - now `*capture2()` The flags parameter was initially designed to support audio-only or video-only operation of an output which had the `OBS_OUTPUT_AV` flag, however, full support for that was never implemented, and there are likely fundamental issues with an implementation, mainly that most outputs are programmed assuming that there will always be at least one audio and one video track. This requires new flags specifying support for optional audio/video, among other things. An implementation to allow audio/video to be optional is best done using the flag technique above, with audio/video enablement specified by whether media (raw, `video_t/audio_t`) or encoder (`obs_encoder_t`) objects are specified. Since every implementation I could find always specifies `flags` as 0, I was able to safely conclude that immediately removing the parameter's functionality is safe to do.
2023-05-09 06:05:27 +00:00
if (flag_audio(output) && !audio_valid(output))
return false;
if (flag_service(output) && !output->service)
obs-studio UI: Implement stream settings UI - Updated the services API so that it links up with an output and the output gets data from that service rather than via settings. This allows the service context to have control over how an output is used, and makes it so that the URL/key/etc isn't necessarily some static setting. Also, if the service is attached to an output, it will stick around until the output is destroyed. - The settings interface has been updated so that it can allow the usage of service plugins. What this means is that now you can create a service plugin that can control aspects of the stream, and it allows each service to create their own user interface if they create a service plugin module. - Testing out saving of current service information. Saves/loads from JSON in to obs_data_t, seems to be working quite nicely, and the service object information is saved/preserved on exit, and loaded again on startup. - I agonized over the settings user interface for days, and eventually I just decided that the only way that users weren't going to be fumbling over options was to split up the settings in to simple/basic output, pre-configured, and then advanced for advanced use (such as multiple outputs or services, which I'll implement later). This was particularly painful to really design right, I wanted more features and wanted to include everything in one interface but ultimately just realized from experience that users are just not technically knowledgable about it and will end up fumbling with the settings rather than getting things done. Basically, what this means is that casual users only have to enter in about 3 things to configure their stream: Stream key, audio bitrate, and video bitrate. I am really happy with this interface for those types of users, but it definitely won't be sufficient for advanced usage or for custom outputs, so that stuff will have to be separated. - Improved the JSON usage for the 'common streaming services' context, I realized that JSON arrays are there to ensure sorting, while forgetting that general items are optimized for hashing. So basically I'm just using arrays now to sort items in it.
2014-04-24 08:49:07 +00:00
return false;
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
return true;
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 22:25:59 +00:00
static inline bool has_scaling(const struct obs_output *output)
Add API functions for output/encoder scaling API functions added: ----------------------------------------------- obs_output_set_preferred_size obs_output_get_width obs_output_get_height obs_encoder_set_scaled_size obs_encoder_get_width obs_encoder_get_height These functions allow for easier means of setting a custom resolution on an output or encoder. If an output uses an encoder and you set the preferred width/height using the output, then the output will attempt to set the scaled width/height for the encoder it's currently using. Outputs and encoders now should use these functions to determine the width/height of the raw frame data instead of using the video-io functions.
2014-08-10 23:50:44 +00:00
{
uint32_t video_width = video_output_get_width(output->video);
uint32_t video_height = video_output_get_height(output->video);
return output->scaled_width && output->scaled_height &&
(video_width != output->scaled_width ||
video_height != output->scaled_height);
}
libobs: Add obs_output_get_video_conversion Need post-convert size to avoid CPU rescale.
2022-09-07 05:03:02 +00:00
const struct video_scale_info *
obs_output_get_video_conversion(struct obs_output *output)
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
{
libobs: Fix holding possibly released pointer in obs_output_t When `obs_output_t` is an encoded output, `obs_output_set_media` will ignore the video and audio so that `obs_output_t` will keep holding the `video_t` and `audio_t` pointer when the output was created. By this commit, `video` and `audio` member variables in `obs_output_t` will never set if it is an encoded output. In the auto-configuration wizard, `video_t` is released and created to have a different video size while `obs_output_t` is not released. This resulted in accessing the released `video_t` pointer.
2023-08-11 04:05:57 +00:00
if (log_flag_encoded(output, __FUNCTION__, true) ||
!log_flag_video(output, __FUNCTION__))
return NULL;
Add API functions for output/encoder scaling API functions added: ----------------------------------------------- obs_output_set_preferred_size obs_output_get_width obs_output_get_height obs_encoder_set_scaled_size obs_encoder_get_width obs_encoder_get_height These functions allow for easier means of setting a custom resolution on an output or encoder. If an output uses an encoder and you set the preferred width/height using the output, then the output will attempt to set the scaled width/height for the encoder it's currently using. Outputs and encoders now should use these functions to determine the width/height of the raw frame data instead of using the video-io functions.
2014-08-10 23:50:44 +00:00
if (output->video_conversion_set) {
if (!output->video_conversion.width)
output->video_conversion.width =
obs_output_get_width(output);
if (!output->video_conversion.height)
output->video_conversion.height =
obs_output_get_height(output);
return &output->video_conversion;
} else if (has_scaling(output)) {
const struct video_output_info *info =
video_output_get_info(output->video);
output->video_conversion.format = info->format;
output->video_conversion.colorspace = VIDEO_CS_DEFAULT;
output->video_conversion.range = VIDEO_RANGE_DEFAULT;
output->video_conversion.width = output->scaled_width;
output->video_conversion.height = output->scaled_height;
return &output->video_conversion;
}
return NULL;
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
}
static inline struct audio_convert_info *
get_audio_conversion(struct obs_output *output)
{
return output->audio_conversion_set ? &output->audio_conversion : NULL;
}
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
static size_t get_encoder_index(const struct obs_output *output,
struct encoder_packet *pkt)
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
{
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (pkt->type == OBS_ENCODER_VIDEO) {
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
struct obs_encoder *encoder = output->video_encoders[i];
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (encoder && pkt->encoder == encoder)
return i;
}
} else if (pkt->type == OBS_ENCODER_AUDIO) {
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
struct obs_encoder *encoder = output->audio_encoders[i];
if (encoder && pkt->encoder == encoder)
return i;
}
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
}
assert(false);
return 0;
}
libobs: Fix multi. video encoder sync issues When using multiple video encoders together with a single audio encoder, the audio wouldn't be in sync. The reason why this occurred is because the dts_usec variable of the encoder packet (which is based on system time) would always be reset to a value based upon the dts (which is not guaranteed to be based on system time) in the apply_interleaved_packet_offset function. This would then in turn cause it to miscalculate the starting audio/video offsets, which are required to calculate sync. So instead of calling that function unnecessarily, separate the check for whether audio/video has been received in to a new function, and only start applying the interleaved offsets after audio and video have actually started up and the starting offsets have been calculated.
2015-02-11 05:47:34 +00:00
static inline void check_received(struct obs_output *output,
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
struct encoder_packet *out)
Add packet interleaving and improve encoder API - Add interleaving of video/audio packets for outputs that are encoded and expect both video and audio data, sorting the packets and sending them to the output when both video and audio is received. - Combine create and initialize callbacks for the encoder API callback interface.
2014-04-05 06:21:19 +00:00
{
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
if (out->type == OBS_ENCODER_VIDEO) {
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (!output->received_video[out->track_idx])
output->received_video[out->track_idx] = true;
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
} else {
if (!output->received_audio)
Add packet interleaving and improve encoder API - Add interleaving of video/audio packets for outputs that are encoded and expect both video and audio data, sorting the packets and sending them to the output when both video and audio is received. - Combine create and initialize callbacks for the encoder API callback interface.
2014-04-05 06:21:19 +00:00
output->received_audio = true;
}
libobs: Fix multi. video encoder sync issues When using multiple video encoders together with a single audio encoder, the audio wouldn't be in sync. The reason why this occurred is because the dts_usec variable of the encoder packet (which is based on system time) would always be reset to a value based upon the dts (which is not guaranteed to be based on system time) in the apply_interleaved_packet_offset function. This would then in turn cause it to miscalculate the starting audio/video offsets, which are required to calculate sync. So instead of calling that function unnecessarily, separate the check for whether audio/video has been received in to a new function, and only start applying the interleaved offsets after audio and video have actually started up and the starting offsets have been calculated.
2015-02-11 05:47:34 +00:00
}
static inline void apply_interleaved_packet_offset(struct obs_output *output,
struct encoder_packet *out)
{
int64_t offset;
/* audio and video need to start at timestamp 0, and the encoders
* may not currently be at 0 when we get data. so, we store the
* current dts as offset and subtract that value from the dts/pts
* of the output packet. */
offset = (out->type == OBS_ENCODER_VIDEO)
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
? output->video_offsets[out->track_idx]
libobs: Fix multi. video encoder sync issues When using multiple video encoders together with a single audio encoder, the audio wouldn't be in sync. The reason why this occurred is because the dts_usec variable of the encoder packet (which is based on system time) would always be reset to a value based upon the dts (which is not guaranteed to be based on system time) in the apply_interleaved_packet_offset function. This would then in turn cause it to miscalculate the starting audio/video offsets, which are required to calculate sync. So instead of calling that function unnecessarily, separate the check for whether audio/video has been received in to a new function, and only start applying the interleaved offsets after audio and video have actually started up and the starting offsets have been calculated.
2015-02-11 05:47:34 +00:00
: output->audio_offsets[out->track_idx];
Add packet interleaving and improve encoder API - Add interleaving of video/audio packets for outputs that are encoded and expect both video and audio data, sorting the packets and sending them to the output when both video and audio is received. - Combine create and initialize callbacks for the encoder API callback interface.
2014-04-05 06:21:19 +00:00
Fix issue when using multiple video encoders - Fix an issue that could occur when using more than one video encoder. Audio/video would not sync up correctly because they were expected to be paired with a particular encoder. This simply adds a little helper variable to encoder packets that specifies the system time in microseconds. We then use that system time to sync - Fix an issue with x264 with fractional FPS rates (29.97 and 59.94 particularly) where it would create ridiculously large stream outputs. The problem was that you shouldn't set the timebase_* variables in the x264 params manually, let x264 handle the default values for it and leave them at 0. - Make x264 use CFR output, because there's no reason to ever use VFR in this case.
2014-04-10 18:59:42 +00:00
out->dts -= offset;
out->pts -= offset;
/* convert the newly adjusted dts to relative dts time to ensure proper
* interleaving. if we're using an audio encoder that's already been
* started on another output, then the first audio packet may not be
* quite perfectly synced up in terms of system time (and there's
* nothing we can really do about that), but it will always at least be
* within a 23ish millisecond threshold (at least for AAC) */
out->dts_usec = packet_dts_usec(out);
Add packet interleaving and improve encoder API - Add interleaving of video/audio packets for outputs that are encoded and expect both video and audio data, sorting the packets and sending them to the output when both video and audio is received. - Combine create and initialize callbacks for the encoder API callback interface.
2014-04-05 06:21:19 +00:00
}
Improve output packet interleaving The 'wait' constant was a terrible means of trying to ensure that the packets were interleaved. Instead, calculate the current highest timestamps of each encoder that's present in the interleaved buffer, and use that as a means of detecting whether the current packet should be sent off. This will guarantee sorting without relying on some arbirary constant that 'assumes' that it'll be interleaved. It also reduces buffering any more than what is needed to interleave.
2014-04-27 06:29:40 +00:00
static inline bool has_higher_opposing_ts(struct obs_output *output,
struct encoder_packet *packet)
{
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
bool has_higher = true;
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
if (!output->video_encoders[i] ||
(packet->type == OBS_ENCODER_VIDEO &&
i == packet->track_idx))
continue;
has_higher = has_higher &&
output->highest_video_ts[i] > packet->dts_usec;
}
return packet->type == OBS_ENCODER_AUDIO
? has_higher
: (has_higher &&
output->highest_audio_ts > packet->dts_usec);
Improve output packet interleaving The 'wait' constant was a terrible means of trying to ensure that the packets were interleaved. Instead, calculate the current highest timestamps of each encoder that's present in the interleaved buffer, and use that as a means of detecting whether the current packet should be sent off. This will guarantee sorting without relying on some arbirary constant that 'assumes' that it'll be interleaved. It also reduces buffering any more than what is needed to interleave.
2014-04-27 06:29:40 +00:00
}
libobs: Add caption support for AV1 Extract the itut_t35 caption data buffer from existing caption data and repackage in a metadata OBU instead of an AVC/HEVC SEI.
2024-03-11 21:06:33 +00:00
static size_t extract_itut_t35_buffer_from_sei(sei_t *sei, uint8_t **data_out)
{
if (!sei || !sei->head) {
return 0;
}
/* We should only need to get one payload, because the SEI that was
* generated should only have one message, so no need to iterate. If
* we did iterate, we would need to generate multiple OBUs. */
sei_message_t *msg = sei_message_head(sei);
int payload_size = (int)sei_message_size(msg);
uint8_t *payload_data = sei_message_data(msg);
libobs: Use bmalloc/bfree for caption data
2024-04-22 16:57:02 +00:00
*data_out = bmalloc(payload_size);
libobs: Add caption support for AV1 Extract the itut_t35 caption data buffer from existing caption data and repackage in a metadata OBU instead of an AVC/HEVC SEI.
2024-03-11 21:06:33 +00:00
memcpy(*data_out, payload_data, payload_size);
return payload_size;
}
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
libobs: Add caption support for AV1 Extract the itut_t35 caption data buffer from existing caption data and repackage in a metadata OBU instead of an AVC/HEVC SEI.
2024-03-11 21:06:33 +00:00
static const uint8_t nal_start[4] = {0, 0, 0, 1};
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
static bool add_caption(struct obs_output *output, struct encoder_packet *out)
{
libobs: Eliminate an unnecessary allocation with captions
2016-12-24 11:45:19 +00:00
struct encoder_packet backup = *out;
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
sei_t sei;
libobs: Add caption support for AV1 Extract the itut_t35 caption data buffer from existing caption data and repackage in a metadata OBU instead of an AVC/HEVC SEI.
2024-03-11 21:06:33 +00:00
uint8_t *data = NULL;
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
size_t size;
libobs: Eliminate an unnecessary allocation with captions
2016-12-24 11:45:19 +00:00
long ref = 1;
libobs: Avoid adding captions on non H.264 streams The existing caption insertion implementation is to add H.264 specific SEI NALs, because of this we will skip caption insertion unless the video stream is H.264. This prevents corruption of AV1/HEVC/etc.
2024-03-11 19:21:01 +00:00
bool avc = false;
libobs: Add caption support for HEVC Add embedded caption support for HEVC by slightly modifying the H.264 SEI to be an HEVC SEI (2 byte SEI NAL header).
2024-03-13 19:55:00 +00:00
bool hevc = false;
libobs: Add caption support for AV1 Extract the itut_t35 caption data buffer from existing caption data and repackage in a metadata OBU instead of an AVC/HEVC SEI.
2024-03-11 21:06:33 +00:00
bool av1 = false;
libobs: Avoid adding captions on non H.264 streams The existing caption insertion implementation is to add H.264 specific SEI NALs, because of this we will skip caption insertion unless the video stream is H.264. This prevents corruption of AV1/HEVC/etc.
2024-03-11 19:21:01 +00:00
/* Instead of exiting early for unsupported codecs, we will continue
* processing to allow the freeing of caption data even if the captions
* will not be included in the bitstream due to being unimplemented in
* the given codec. */
if (strcmp(out->encoder->info.codec, "h264") == 0) {
avc = true;
libobs: Add caption support for AV1 Extract the itut_t35 caption data buffer from existing caption data and repackage in a metadata OBU instead of an AVC/HEVC SEI.
2024-03-11 21:06:33 +00:00
} else if (strcmp(out->encoder->info.codec, "av1") == 0) {
av1 = true;
libobs: Add caption support for HEVC Add embedded caption support for HEVC by slightly modifying the H.264 SEI to be an HEVC SEI (2 byte SEI NAL header).
2024-03-13 19:55:00 +00:00
#ifdef ENABLE_HEVC
} else if (strcmp(out->encoder->info.codec, "hevc") == 0) {
hevc = true;
#endif
libobs: Avoid adding captions on non H.264 streams The existing caption insertion implementation is to add H.264 specific SEI NALs, because of this we will skip caption insertion unless the video stream is H.264. This prevents corruption of AV1/HEVC/etc.
2024-03-11 19:21:01 +00:00
}
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
DARRAY(uint8_t) out_data;
if (out->priority > 1)
return false;
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
struct caption_track_data *ctrack =
output->caption_tracks[out->track_idx];
if (!ctrack) {
blog(LOG_DEBUG,
"Caption track for index: %lu has not been initialized",
out->track_idx);
return false;
}
libobs: Add caption support for HEVC Add embedded caption support for HEVC by slightly modifying the H.264 SEI to be an HEVC SEI (2 byte SEI NAL header).
2024-03-13 19:55:00 +00:00
#ifdef ENABLE_HEVC
uint8_t hevc_nal_header[2];
if (hevc) {
size_t nal_header_index_start = 4;
// Skip past the annex-b start code
if (memcmp(out->data, nal_start + 1, 3) == 0) {
nal_header_index_start = 3;
} else if (memcmp(out->data, nal_start, 4) == 0) {
nal_header_index_start = 4;
} else {
/* We shouldn't ever see this unless we start getting
* packets without annex-b start codes. */
blog(LOG_DEBUG,
"Annex-B start code not found. We may not "
"generate a valid HEVC NAL unit header "
"for our caption");
return false;
}
/* We will use the same 2 byte NAL unit header for the CC SEI,
* but swap the NAL types out. */
hevc_nal_header[0] = out->data[nal_header_index_start];
hevc_nal_header[1] = out->data[nal_header_index_start + 1];
}
#endif
libobs: Update libcaption library (This commit also modifies deps/libcaption) Closes obsproject/obs-studio#1354
2018-06-28 18:22:44 +00:00
sei_init(&sei, 0.0);
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
libobs: Fix caption encoder packet reallocation Captions do something unusual with encoder packets: they reallocate them due to appending extra h.264 data. Due to the way allocations are handled with core encoder packets (they now store a reference in their data), instead of modifying the encoder data directly, create a new encoder packet instead and release the old packet.
2016-12-24 10:13:50 +00:00
da_init(out_data);
libobs: Add casts to da_push_back_array arguments
2021-07-21 13:34:42 +00:00
da_push_back_array(out_data, (uint8_t *)&ref, sizeof(ref));
libobs: Eliminate an unnecessary allocation with captions
2016-12-24 11:45:19 +00:00
da_push_back_array(out_data, out->data, out->size);
libobs: Fix caption encoder packet reallocation Captions do something unusual with encoder packets: they reallocate them due to appending extra h.264 data. Due to the way allocations are handled with core encoder packets (they now store a reference in their data), instead of modifying the encoder data directly, create a new encoder packet instead and release the old packet.
2016-12-24 10:13:50 +00:00
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
if (ctrack->caption_data.size > 0) {
decklink: Add ability to ingest/embed cea 708 captions (This commit also modifies libobs, UI)
2019-08-26 22:58:20 +00:00
cea708_t cea708;
cea708_init(&cea708, 0); // set up a new popon frame
void *caption_buf = bzalloc(3 * sizeof(uint8_t));
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
while (ctrack->caption_data.size > 0) {
deque_pop_front(&ctrack->caption_data, caption_buf,
libobs: Replace circlebuf with deque
2023-11-30 15:11:18 +00:00
3 * sizeof(uint8_t));
decklink: Add ability to ingest/embed cea 708 captions (This commit also modifies libobs, UI)
2019-08-26 22:58:20 +00:00
if ((((uint8_t *)caption_buf)[0] & 0x3) != 0) {
// only send cea 608
continue;
}
uint16_t captionData = ((uint8_t *)caption_buf)[1];
captionData = captionData << 8;
captionData += ((uint8_t *)caption_buf)[2];
// padding
if (captionData == 0x8080) {
continue;
}
if (captionData == 0) {
continue;
}
if (!eia608_parity_varify(captionData)) {
continue;
}
cea708_add_cc_data(&cea708, 1,
((uint8_t *)caption_buf)[0] & 0x3,
captionData);
}
bfree(caption_buf);
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
decklink: Add ability to ingest/embed cea 708 captions (This commit also modifies libobs, UI)
2019-08-26 22:58:20 +00:00
sei_message_t *msg =
sei_message_new(sei_type_user_data_registered_itu_t_t35,
0, CEA608_MAX_SIZE);
msg->size = cea708_render(&cea708, sei_message_data(msg),
sei_message_size(msg));
sei_message_append(&sei, msg);
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
} else if (ctrack->caption_head) {
decklink: Add ability to ingest/embed cea 708 captions (This commit also modifies libobs, UI)
2019-08-26 22:58:20 +00:00
caption_frame_t cf;
caption_frame_init(&cf);
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
caption_frame_from_text(&cf, &ctrack->caption_head->text[0]);
decklink: Add ability to ingest/embed cea 708 captions (This commit also modifies libobs, UI)
2019-08-26 22:58:20 +00:00
sei_from_caption_frame(&sei, &cf);
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
struct caption_text *next = ctrack->caption_head->next;
bfree(ctrack->caption_head);
ctrack->caption_head = next;
decklink: Add ability to ingest/embed cea 708 captions (This commit also modifies libobs, UI)
2019-08-26 22:58:20 +00:00
}
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
libobs: Add caption support for AV1 Extract the itut_t35 caption data buffer from existing caption data and repackage in a metadata OBU instead of an AVC/HEVC SEI.
2024-03-11 21:06:33 +00:00
if (avc || hevc || av1) {
if (avc || hevc) {
libobs: Use bmalloc/bfree for caption data
2024-04-22 16:57:02 +00:00
data = bmalloc(sei_render_size(&sei));
libobs: Add caption support for AV1 Extract the itut_t35 caption data buffer from existing caption data and repackage in a metadata OBU instead of an AVC/HEVC SEI.
2024-03-11 21:06:33 +00:00
size = sei_render(&sei, data);
}
/* In each of these specs there is an identical structure that
* carries caption information. It is named slightly differently
* in each one. The metadata_itut_t35 in AV1 or the
* user_data_registered_itu_t_t35 in HEVC/AVC. We have an AVC
* SEI wrapped version of that here. We will strip it out and
* repackage it slightly to fit the different codec carrying
* mechanisms. A slightly modified SEI for HEVC and a metadata
* OBU for AV1. */
libobs: Add caption support for HEVC Add embedded caption support for HEVC by slightly modifying the H.264 SEI to be an HEVC SEI (2 byte SEI NAL header).
2024-03-13 19:55:00 +00:00
if (avc) {
/* TODO: SEI should come after AUD/SPS/PPS,
* but before any VCL */
da_push_back_array(out_data, nal_start, 4);
da_push_back_array(out_data, data, size);
#ifdef ENABLE_HEVC
} else if (hevc) {
libobs: Add caption support for AV1 Extract the itut_t35 caption data buffer from existing caption data and repackage in a metadata OBU instead of an AVC/HEVC SEI.
2024-03-11 21:06:33 +00:00
/* Only first NAL (VPS/PPS/SPS) should use the 4 byte
* start code. SEIs use 3 byte version */
libobs: Add caption support for HEVC Add embedded caption support for HEVC by slightly modifying the H.264 SEI to be an HEVC SEI (2 byte SEI NAL header).
2024-03-13 19:55:00 +00:00
da_push_back_array(out_data, nal_start + 1, 3);
/* nal_unit_header( ) {
* forbidden_zero_bit f(1)
* nal_unit_type u(6)
* nuh_layer_id u(6)
* nuh_temporal_id_plus1 u(3)
* }
*/
const uint8_t prefix_sei_nal_type = 39;
/* The first bit is always 0, so we just need to
* save the last bit off the original header and
* add the SEI NAL type. */
uint8_t first_byte = (prefix_sei_nal_type << 1) |
(0x01 & hevc_nal_header[0]);
hevc_nal_header[0] = first_byte;
/* The HEVC NAL unit header is 2 byte instead of
* one, otherwise everything else is the
* same. */
da_push_back_array(out_data, hevc_nal_header, 2);
da_push_back_array(out_data, &data[1], size - 1);
#endif
libobs: Add caption support for AV1 Extract the itut_t35 caption data buffer from existing caption data and repackage in a metadata OBU instead of an AVC/HEVC SEI.
2024-03-11 21:06:33 +00:00
} else if (av1) {
uint8_t *obu_buffer = NULL;
size_t obu_buffer_size = 0;
size = extract_itut_t35_buffer_from_sei(&sei, &data);
metadata_obu_itu_t35(data, size, &obu_buffer,
&obu_buffer_size);
if (obu_buffer) {
da_push_back_array(out_data, obu_buffer,
obu_buffer_size);
bfree(obu_buffer);
}
libobs: Add caption support for HEVC Add embedded caption support for HEVC by slightly modifying the H.264 SEI to be an HEVC SEI (2 byte SEI NAL header).
2024-03-13 19:55:00 +00:00
}
libobs: Add caption support for AV1 Extract the itut_t35 caption data buffer from existing caption data and repackage in a metadata OBU instead of an AVC/HEVC SEI.
2024-03-11 21:06:33 +00:00
if (data) {
libobs: Use bmalloc/bfree for caption data
2024-04-22 16:57:02 +00:00
bfree(data);
libobs: Add caption support for AV1 Extract the itut_t35 caption data buffer from existing caption data and repackage in a metadata OBU instead of an AVC/HEVC SEI.
2024-03-11 21:06:33 +00:00
}
obs_encoder_packet_release(out);
libobs: Fix caption encoder packet reallocation Captions do something unusual with encoder packets: they reallocate them due to appending extra h.264 data. Due to the way allocations are handled with core encoder packets (they now store a reference in their data), instead of modifying the encoder data directly, create a new encoder packet instead and release the old packet.
2016-12-24 10:13:50 +00:00
libobs: Add caption support for AV1 Extract the itut_t35 caption data buffer from existing caption data and repackage in a metadata OBU instead of an AVC/HEVC SEI.
2024-03-11 21:06:33 +00:00
*out = backup;
out->data = (uint8_t *)out_data.array + sizeof(ref);
out->size = out_data.num - sizeof(ref);
libobs: Avoid adding captions on non H.264 streams The existing caption insertion implementation is to add H.264 specific SEI NALs, because of this we will skip caption insertion unless the video stream is H.264. This prevents corruption of AV1/HEVC/etc.
2024-03-11 19:21:01 +00:00
}
libobs: Add caption support for AV1 Extract the itut_t35 caption data buffer from existing caption data and repackage in a metadata OBU instead of an AVC/HEVC SEI.
2024-03-11 21:06:33 +00:00
sei_free(&sei);
return avc || hevc || av1;
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
}
Add packet interleaving and improve encoder API - Add interleaving of video/audio packets for outputs that are encoded and expect both video and audio data, sorting the packets and sending them to the output when both video and audio is received. - Combine create and initialize callbacks for the encoder API callback interface.
2014-04-05 06:21:19 +00:00
static inline void send_interleaved(struct obs_output *output)
{
Fix issue when using multiple video encoders - Fix an issue that could occur when using more than one video encoder. Audio/video would not sync up correctly because they were expected to be paired with a particular encoder. This simply adds a little helper variable to encoder packets that specifies the system time in microseconds. We then use that system time to sync - Fix an issue with x264 with fractional FPS rates (29.97 and 59.94 particularly) where it would create ridiculously large stream outputs. The problem was that you shouldn't set the timebase_* variables in the x264 params manually, let x264 handle the default values for it and leave them at 0. - Make x264 use CFR output, because there's no reason to ever use VFR in this case.
2014-04-10 18:59:42 +00:00
struct encoder_packet out = output->interleaved_packets.array[0];
Add packet interleaving and improve encoder API - Add interleaving of video/audio packets for outputs that are encoded and expect both video and audio data, sorting the packets and sending them to the output when both video and audio is received. - Combine create and initialize callbacks for the encoder API callback interface.
2014-04-05 06:21:19 +00:00
Improve output packet interleaving The 'wait' constant was a terrible means of trying to ensure that the packets were interleaved. Instead, calculate the current highest timestamps of each encoder that's present in the interleaved buffer, and use that as a means of detecting whether the current packet should be sent off. This will guarantee sorting without relying on some arbirary constant that 'assumes' that it'll be interleaved. It also reduces buffering any more than what is needed to interleave.
2014-04-27 06:29:40 +00:00
/* do not send an interleaved packet if there's no packet of the
Fix various typos across multiple modules
2017-03-19 11:35:51 +00:00
* opposing type of a higher timestamp in the interleave buffer.
Improve output packet interleaving The 'wait' constant was a terrible means of trying to ensure that the packets were interleaved. Instead, calculate the current highest timestamps of each encoder that's present in the interleaved buffer, and use that as a means of detecting whether the current packet should be sent off. This will guarantee sorting without relying on some arbirary constant that 'assumes' that it'll be interleaved. It also reduces buffering any more than what is needed to interleave.
2014-04-27 06:29:40 +00:00
* this ensures that the timestamps are monotonic */
if (!has_higher_opposing_ts(output, &out))
return;
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
da_erase(output->interleaved_packets, 0);
if (out.type == OBS_ENCODER_VIDEO) {
Add counting of total video frames to outputs Before it would assign the encoder/media callbacks directly to the output's callbacks, so instead of doing that, it now goes through intermediary functions for the sake of counting the frames.
2014-07-06 21:16:31 +00:00
output->total_frames++;
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
pthread_mutex_lock(
&output->caption_tracks[out.track_idx]->caption_mutex);
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
double frame_timestamp =
(out.pts * out.timebase_num) / (double)out.timebase_den;
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
struct caption_track_data *ctrack =
output->caption_tracks[out.track_idx];
if (ctrack->caption_head &&
ctrack->caption_timestamp <= frame_timestamp) {
libobs: Add minimum display duration to caption data Adds display_duration declaring the minimum duration a caption text is not going to be overwritten by a new one. To keep the functions backwards-compatible obs_output_output_caption_text2 was added while obs_output_output_caption_text1 continues having a 2 second default.
2019-02-20 04:33:33 +00:00
blog(LOG_DEBUG, "Sending caption: %f \"%s\"",
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
frame_timestamp, &ctrack->caption_head->text[0]);
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
libobs: Add minimum display duration to caption data Adds display_duration declaring the minimum duration a caption text is not going to be overwritten by a new one. To keep the functions backwards-compatible obs_output_output_caption_text2 was added while obs_output_output_caption_text1 continues having a 2 second default.
2019-02-20 04:33:33 +00:00
double display_duration =
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
ctrack->caption_head->display_duration;
libobs: Add minimum display duration to caption data Adds display_duration declaring the minimum duration a caption text is not going to be overwritten by a new one. To keep the functions backwards-compatible obs_output_output_caption_text2 was added while obs_output_output_caption_text1 continues having a 2 second default.
2019-02-20 04:33:33 +00:00
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
if (add_caption(output, &out)) {
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
ctrack->caption_timestamp =
libobs: Add minimum display duration to caption data Adds display_duration declaring the minimum duration a caption text is not going to be overwritten by a new one. To keep the functions backwards-compatible obs_output_output_caption_text2 was added while obs_output_output_caption_text1 continues having a 2 second default.
2019-02-20 04:33:33 +00:00
frame_timestamp + display_duration;
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
}
}
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
if (ctrack->caption_data.size > 0) {
if (ctrack->last_caption_timestamp < frame_timestamp) {
ctrack->last_caption_timestamp =
frame_timestamp;
decklink: Add ability to ingest/embed cea 708 captions (This commit also modifies libobs, UI)
2019-08-26 22:58:20 +00:00
add_caption(output, &out);
}
}
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
pthread_mutex_unlock(&ctrack->caption_mutex);
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
}
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
output->info.encoded_packet(output->context.data, &out);
libobs: Use reference counting for encoder packets Prevents reallocation of encoded packet data. Deprecates: obs_duplicate_encoder_packet obs_free_encoder_packet Replaces those functions with: obs_encoder_packet_ref obs_encoder_packet_release
2016-12-07 20:45:25 +00:00
obs_encoder_packet_release(&out);
Add packet interleaving and improve encoder API - Add interleaving of video/audio packets for outputs that are encoded and expect both video and audio data, sorting the packets and sending them to the output when both video and audio is received. - Combine create and initialize callbacks for the encoder API callback interface.
2014-04-05 06:21:19 +00:00
}
Improve output packet interleaving The 'wait' constant was a terrible means of trying to ensure that the packets were interleaved. Instead, calculate the current highest timestamps of each encoder that's present in the interleaved buffer, and use that as a means of detecting whether the current packet should be sent off. This will guarantee sorting without relying on some arbirary constant that 'assumes' that it'll be interleaved. It also reduces buffering any more than what is needed to interleave.
2014-04-27 06:29:40 +00:00
static inline void set_higher_ts(struct obs_output *output,
struct encoder_packet *packet)
{
if (packet->type == OBS_ENCODER_VIDEO) {
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (output->highest_video_ts[packet->track_idx] <
packet->dts_usec)
output->highest_video_ts[packet->track_idx] =
packet->dts_usec;
Improve output packet interleaving The 'wait' constant was a terrible means of trying to ensure that the packets were interleaved. Instead, calculate the current highest timestamps of each encoder that's present in the interleaved buffer, and use that as a means of detecting whether the current packet should be sent off. This will guarantee sorting without relying on some arbirary constant that 'assumes' that it'll be interleaved. It also reduces buffering any more than what is needed to interleave.
2014-04-27 06:29:40 +00:00
} else {
if (output->highest_audio_ts < packet->dts_usec)
output->highest_audio_ts = packet->dts_usec;
}
}
libobs: Add find_first_packet_type_idx Gets the index of the first interleaved packet of a given/type and audio index
2016-01-30 17:31:57 +00:00
static inline struct encoder_packet *
find_first_packet_type(struct obs_output *output, enum obs_encoder_type type,
size_t audio_idx);
static int find_first_packet_type_idx(struct obs_output *output,
libobs: Fix potential output audio/video sync bug Problem: When an output is started with encoders that have already been started by another output, and it starts in between the window in between where the first audio packets start coming in and where the first video packet comes in, the output would get audio packets with timestamps potentially much later than the first video frame when the first video frame finally comes in. The audio/video encoders will almost always have a differing delay. Solution: Detect that starting window, and if within that starting window, wait for a new keyframe from video instead of trying to sync up video. Additional Notes: In these cases where an output starts with already-active encoders, this patch also reduces the potential sync offset between the first video frame and the first audio frame. Before, it would sync the first video frame with the first audio frames right after that, but now it syncs with the closest audio frame in the interleaved array, which halves the potential sync difference between the first video frame and the first audio frame of already-active encoders. (So now the potential sync difference is roughly 11.6 milliseconds at 44.1khz audio, where it was 23.2 before)
2016-01-25 10:41:02 +00:00
enum obs_encoder_type type,
size_t audio_idx);
/* gets the point where audio and video are closest together */
static size_t get_interleaved_start_idx(struct obs_output *output)
{
int64_t closest_diff = 0x7FFFFFFFFFFFFFFFLL;
struct encoder_packet *first_video =
find_first_packet_type(output, OBS_ENCODER_VIDEO, 0);
size_t video_idx = DARRAY_INVALID;
size_t idx = 0;
for (size_t i = 0; i < output->interleaved_packets.num; i++) {
struct encoder_packet *packet =
&output->interleaved_packets.array[i];
int64_t diff;
if (packet->type != OBS_ENCODER_AUDIO) {
if (packet == first_video)
video_idx = i;
continue;
}
diff = llabs(packet->dts_usec - first_video->dts_usec);
if (diff < closest_diff) {
closest_diff = diff;
idx = i;
}
}
return video_idx < idx ? video_idx : idx;
}
libobs: Reduce synchronization limit for multiple audio tracks Since 65eb3c0815929866dde7d398bec7738d21e9b211 we tried to get as close a sync between audio and video tracks as we could before starting to send frames to the output. But in be717dbb2c19aa0e91a164fa52e3d4467b64be9d when multi-track audio was considered for synchronization it continued to try and line ALL audio packets up with one video packet. While audio and video packets are similar size this will work out. But once video packets duration is smaller than 1/2 audio packet duration this may fail forever. In practice with AAC's 20-23ms frame duration we can often get tracks producing frames 5-10ms out of phase. For 60fps video this mostly fine as 16ms frame duration will cover the gap, but for framerates as low as 100 its possible to fail to synchronize. In practice this is ~50% for 6 audio tracks and 120fps video on my system, or 100% at 240fps.
2023-01-30 02:50:28 +00:00
static int64_t get_encoder_duration(struct obs_encoder *encoder)
{
return (encoder->timebase_num * 1000000LL / encoder->timebase_den) *
encoder->framesize;
}
libobs: Consider multi-track audio when pruning packets In a multi-track scenario it was not taking in to consideration the possibility of secondary audio tracks, which could have caused desync on some of the audio tracks.
2016-01-30 17:33:20 +00:00
static int prune_premature_packets(struct obs_output *output)
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
{
libobs: Consider multi-track audio when pruning packets In a multi-track scenario it was not taking in to consideration the possibility of secondary audio tracks, which could have caused desync on some of the audio tracks.
2016-01-30 17:33:20 +00:00
struct encoder_packet *video;
int video_idx;
int max_idx;
libobs: Reduce synchronization limit for multiple audio tracks Since 65eb3c0815929866dde7d398bec7738d21e9b211 we tried to get as close a sync between audio and video tracks as we could before starting to send frames to the output. But in be717dbb2c19aa0e91a164fa52e3d4467b64be9d when multi-track audio was considered for synchronization it continued to try and line ALL audio packets up with one video packet. While audio and video packets are similar size this will work out. But once video packets duration is smaller than 1/2 audio packet duration this may fail forever. In practice with AAC's 20-23ms frame duration we can often get tracks producing frames 5-10ms out of phase. For 60fps video this mostly fine as 16ms frame duration will cover the gap, but for framerates as low as 100 its possible to fail to synchronize. In practice this is ~50% for 6 audio tracks and 120fps video on my system, or 100% at 240fps.
2023-01-30 02:50:28 +00:00
int64_t duration_usec, max_audio_duration_usec = 0;
libobs: Consider multi-track audio when pruning packets In a multi-track scenario it was not taking in to consideration the possibility of secondary audio tracks, which could have caused desync on some of the audio tracks.
2016-01-30 17:33:20 +00:00
int64_t max_diff = 0;
libobs: Fix 'may be uninitialized' warning
2016-06-22 21:08:56 +00:00
int64_t diff = 0;
libobs: Reduce synchronization limit for multiple audio tracks Since 65eb3c0815929866dde7d398bec7738d21e9b211 we tried to get as close a sync between audio and video tracks as we could before starting to send frames to the output. But in be717dbb2c19aa0e91a164fa52e3d4467b64be9d when multi-track audio was considered for synchronization it continued to try and line ALL audio packets up with one video packet. While audio and video packets are similar size this will work out. But once video packets duration is smaller than 1/2 audio packet duration this may fail forever. In practice with AAC's 20-23ms frame duration we can often get tracks producing frames 5-10ms out of phase. For 60fps video this mostly fine as 16ms frame duration will cover the gap, but for framerates as low as 100 its possible to fail to synchronize. In practice this is ~50% for 6 audio tracks and 120fps video on my system, or 100% at 240fps.
2023-01-30 02:50:28 +00:00
int audio_encoders = 0;
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
libobs: Consider multi-track audio when pruning packets In a multi-track scenario it was not taking in to consideration the possibility of secondary audio tracks, which could have caused desync on some of the audio tracks.
2016-01-30 17:33:20 +00:00
video_idx = find_first_packet_type_idx(output, OBS_ENCODER_VIDEO, 0);
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (video_idx == -1)
libobs: Consider multi-track audio when pruning packets In a multi-track scenario it was not taking in to consideration the possibility of secondary audio tracks, which could have caused desync on some of the audio tracks.
2016-01-30 17:33:20 +00:00
return -1;
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
libobs: Consider multi-track audio when pruning packets In a multi-track scenario it was not taking in to consideration the possibility of secondary audio tracks, which could have caused desync on some of the audio tracks.
2016-01-30 17:33:20 +00:00
max_idx = video_idx;
video = &output->interleaved_packets.array[video_idx];
duration_usec = video->timebase_num * 1000000LL / video->timebase_den;
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
libobs: Consider multi-track audio when pruning packets In a multi-track scenario it was not taking in to consideration the possibility of secondary audio tracks, which could have caused desync on some of the audio tracks.
2016-01-30 17:33:20 +00:00
struct encoder_packet *audio;
int audio_idx;
libobs: Reduce synchronization limit for multiple audio tracks Since 65eb3c0815929866dde7d398bec7738d21e9b211 we tried to get as close a sync between audio and video tracks as we could before starting to send frames to the output. But in be717dbb2c19aa0e91a164fa52e3d4467b64be9d when multi-track audio was considered for synchronization it continued to try and line ALL audio packets up with one video packet. While audio and video packets are similar size this will work out. But once video packets duration is smaller than 1/2 audio packet duration this may fail forever. In practice with AAC's 20-23ms frame duration we can often get tracks producing frames 5-10ms out of phase. For 60fps video this mostly fine as 16ms frame duration will cover the gap, but for framerates as low as 100 its possible to fail to synchronize. In practice this is ~50% for 6 audio tracks and 120fps video on my system, or 100% at 240fps.
2023-01-30 02:50:28 +00:00
int64_t audio_duration_usec = 0;
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
if (!output->audio_encoders[i])
continue;
libobs: Reduce synchronization limit for multiple audio tracks Since 65eb3c0815929866dde7d398bec7738d21e9b211 we tried to get as close a sync between audio and video tracks as we could before starting to send frames to the output. But in be717dbb2c19aa0e91a164fa52e3d4467b64be9d when multi-track audio was considered for synchronization it continued to try and line ALL audio packets up with one video packet. While audio and video packets are similar size this will work out. But once video packets duration is smaller than 1/2 audio packet duration this may fail forever. In practice with AAC's 20-23ms frame duration we can often get tracks producing frames 5-10ms out of phase. For 60fps video this mostly fine as 16ms frame duration will cover the gap, but for framerates as low as 100 its possible to fail to synchronize. In practice this is ~50% for 6 audio tracks and 120fps video on my system, or 100% at 240fps.
2023-01-30 02:50:28 +00:00
audio_encoders++;
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
libobs: Consider multi-track audio when pruning packets In a multi-track scenario it was not taking in to consideration the possibility of secondary audio tracks, which could have caused desync on some of the audio tracks.
2016-01-30 17:33:20 +00:00
audio_idx = find_first_packet_type_idx(output,
OBS_ENCODER_AUDIO, i);
if (audio_idx == -1) {
output->received_audio = false;
return -1;
}
audio = &output->interleaved_packets.array[audio_idx];
if (audio_idx > max_idx)
max_idx = audio_idx;
diff = audio->dts_usec - video->dts_usec;
if (diff > max_diff)
max_diff = diff;
libobs: Reduce synchronization limit for multiple audio tracks Since 65eb3c0815929866dde7d398bec7738d21e9b211 we tried to get as close a sync between audio and video tracks as we could before starting to send frames to the output. But in be717dbb2c19aa0e91a164fa52e3d4467b64be9d when multi-track audio was considered for synchronization it continued to try and line ALL audio packets up with one video packet. While audio and video packets are similar size this will work out. But once video packets duration is smaller than 1/2 audio packet duration this may fail forever. In practice with AAC's 20-23ms frame duration we can often get tracks producing frames 5-10ms out of phase. For 60fps video this mostly fine as 16ms frame duration will cover the gap, but for framerates as low as 100 its possible to fail to synchronize. In practice this is ~50% for 6 audio tracks and 120fps video on my system, or 100% at 240fps.
2023-01-30 02:50:28 +00:00
audio_duration_usec =
get_encoder_duration(output->audio_encoders[i]);
if (audio_duration_usec > max_audio_duration_usec)
max_audio_duration_usec = audio_duration_usec;
}
/* Once multiple audio encoders are running they are almost always out
* of phase by ~Xms. If users change their video to > 100fps then it
* becomes probable that this phase difference will be larger than the
* video duration preventing us from ever finding a synchronization
* point due to their larger frame duration. Instead give up on a tight
* video sync. */
if (audio_encoders > 1 && duration_usec < max_audio_duration_usec) {
duration_usec = max_audio_duration_usec;
libobs: Consider multi-track audio when pruning packets In a multi-track scenario it was not taking in to consideration the possibility of secondary audio tracks, which could have caused desync on some of the audio tracks.
2016-01-30 17:33:20 +00:00
}
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
libobs: Consider multi-track audio when pruning packets In a multi-track scenario it was not taking in to consideration the possibility of secondary audio tracks, which could have caused desync on some of the audio tracks.
2016-01-30 17:33:20 +00:00
return diff > duration_usec ? max_idx + 1 : 0;
libobs: Fix potential output audio/video sync bug Problem: When an output is started with encoders that have already been started by another output, and it starts in between the window in between where the first audio packets start coming in and where the first video packet comes in, the output would get audio packets with timestamps potentially much later than the first video frame when the first video frame finally comes in. The audio/video encoders will almost always have a differing delay. Solution: Detect that starting window, and if within that starting window, wait for a new keyframe from video instead of trying to sync up video. Additional Notes: In these cases where an output starts with already-active encoders, this patch also reduces the potential sync offset between the first video frame and the first audio frame. Before, it would sync the first video frame with the first audio frames right after that, but now it syncs with the closest audio frame in the interleaved array, which halves the potential sync difference between the first video frame and the first audio frame of already-active encoders. (So now the potential sync difference is roughly 11.6 milliseconds at 44.1khz audio, where it was 23.2 before)
2016-01-25 10:41:02 +00:00
}
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
libobs: Fix potential output audio/video sync bug Problem: When an output is started with encoders that have already been started by another output, and it starts in between the window in between where the first audio packets start coming in and where the first video packet comes in, the output would get audio packets with timestamps potentially much later than the first video frame when the first video frame finally comes in. The audio/video encoders will almost always have a differing delay. Solution: Detect that starting window, and if within that starting window, wait for a new keyframe from video instead of trying to sync up video. Additional Notes: In these cases where an output starts with already-active encoders, this patch also reduces the potential sync offset between the first video frame and the first audio frame. Before, it would sync the first video frame with the first audio frames right after that, but now it syncs with the closest audio frame in the interleaved array, which halves the potential sync difference between the first video frame and the first audio frame of already-active encoders. (So now the potential sync difference is roughly 11.6 milliseconds at 44.1khz audio, where it was 23.2 before)
2016-01-25 10:41:02 +00:00
static void discard_to_idx(struct obs_output *output, size_t idx)
{
for (size_t i = 0; i < idx; i++) {
struct encoder_packet *packet =
&output->interleaved_packets.array[i];
libobs: Use reference counting for encoder packets Prevents reallocation of encoded packet data. Deprecates: obs_duplicate_encoder_packet obs_free_encoder_packet Replaces those functions with: obs_encoder_packet_ref obs_encoder_packet_release
2016-12-07 20:45:25 +00:00
obs_encoder_packet_release(packet);
libobs: Fix potential output audio/video sync bug Problem: When an output is started with encoders that have already been started by another output, and it starts in between the window in between where the first audio packets start coming in and where the first video packet comes in, the output would get audio packets with timestamps potentially much later than the first video frame when the first video frame finally comes in. The audio/video encoders will almost always have a differing delay. Solution: Detect that starting window, and if within that starting window, wait for a new keyframe from video instead of trying to sync up video. Additional Notes: In these cases where an output starts with already-active encoders, this patch also reduces the potential sync offset between the first video frame and the first audio frame. Before, it would sync the first video frame with the first audio frames right after that, but now it syncs with the closest audio frame in the interleaved array, which halves the potential sync difference between the first video frame and the first audio frame of already-active encoders. (So now the potential sync difference is roughly 11.6 milliseconds at 44.1khz audio, where it was 23.2 before)
2016-01-25 10:41:02 +00:00
}
da_erase_range(output->interleaved_packets, 0, idx);
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
}
libobs: Fix potential output audio/video sync bug Problem: When an output is started with encoders that have already been started by another output, and it starts in between the window in between where the first audio packets start coming in and where the first video packet comes in, the output would get audio packets with timestamps potentially much later than the first video frame when the first video frame finally comes in. The audio/video encoders will almost always have a differing delay. Solution: Detect that starting window, and if within that starting window, wait for a new keyframe from video instead of trying to sync up video. Additional Notes: In these cases where an output starts with already-active encoders, this patch also reduces the potential sync offset between the first video frame and the first audio frame. Before, it would sync the first video frame with the first audio frames right after that, but now it syncs with the closest audio frame in the interleaved array, which halves the potential sync difference between the first video frame and the first audio frame of already-active encoders. (So now the potential sync difference is roughly 11.6 milliseconds at 44.1khz audio, where it was 23.2 before)
2016-01-25 10:41:02 +00:00
#define DEBUG_STARTING_PACKETS 0
libobs: Consider multi-track audio when pruning packets In a multi-track scenario it was not taking in to consideration the possibility of secondary audio tracks, which could have caused desync on some of the audio tracks.
2016-01-30 17:33:20 +00:00
static bool prune_interleaved_packets(struct obs_output *output)
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
{
size_t start_idx = 0;
libobs: Consider multi-track audio when pruning packets In a multi-track scenario it was not taking in to consideration the possibility of secondary audio tracks, which could have caused desync on some of the audio tracks.
2016-01-30 17:33:20 +00:00
int prune_start = prune_premature_packets(output);
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
libobs: Fix potential output audio/video sync bug Problem: When an output is started with encoders that have already been started by another output, and it starts in between the window in between where the first audio packets start coming in and where the first video packet comes in, the output would get audio packets with timestamps potentially much later than the first video frame when the first video frame finally comes in. The audio/video encoders will almost always have a differing delay. Solution: Detect that starting window, and if within that starting window, wait for a new keyframe from video instead of trying to sync up video. Additional Notes: In these cases where an output starts with already-active encoders, this patch also reduces the potential sync offset between the first video frame and the first audio frame. Before, it would sync the first video frame with the first audio frames right after that, but now it syncs with the closest audio frame in the interleaved array, which halves the potential sync difference between the first video frame and the first audio frame of already-active encoders. (So now the potential sync difference is roughly 11.6 milliseconds at 44.1khz audio, where it was 23.2 before)
2016-01-25 10:41:02 +00:00
#if DEBUG_STARTING_PACKETS == 1
libobs: Improve output packet pruning debug message Specifies whether packets were pruned or not
2016-04-20 15:36:14 +00:00
blog(LOG_DEBUG, "--------- Pruning! %d ---------", prune_start);
libobs: Fix potential output audio/video sync bug Problem: When an output is started with encoders that have already been started by another output, and it starts in between the window in between where the first audio packets start coming in and where the first video packet comes in, the output would get audio packets with timestamps potentially much later than the first video frame when the first video frame finally comes in. The audio/video encoders will almost always have a differing delay. Solution: Detect that starting window, and if within that starting window, wait for a new keyframe from video instead of trying to sync up video. Additional Notes: In these cases where an output starts with already-active encoders, this patch also reduces the potential sync offset between the first video frame and the first audio frame. Before, it would sync the first video frame with the first audio frames right after that, but now it syncs with the closest audio frame in the interleaved array, which halves the potential sync difference between the first video frame and the first audio frame of already-active encoders. (So now the potential sync difference is roughly 11.6 milliseconds at 44.1khz audio, where it was 23.2 before)
2016-01-25 10:41:02 +00:00
for (size_t i = 0; i < output->interleaved_packets.num; i++) {
struct encoder_packet *packet =
&output->interleaved_packets.array[i];
libobs: Improve output packet pruning debug message Specifies whether packets were pruned or not
2016-04-20 15:36:14 +00:00
blog(LOG_DEBUG, "packet: %s %d, ts: %lld, pruned = %s",
libobs: Fix potential output audio/video sync bug Problem: When an output is started with encoders that have already been started by another output, and it starts in between the window in between where the first audio packets start coming in and where the first video packet comes in, the output would get audio packets with timestamps potentially much later than the first video frame when the first video frame finally comes in. The audio/video encoders will almost always have a differing delay. Solution: Detect that starting window, and if within that starting window, wait for a new keyframe from video instead of trying to sync up video. Additional Notes: In these cases where an output starts with already-active encoders, this patch also reduces the potential sync offset between the first video frame and the first audio frame. Before, it would sync the first video frame with the first audio frames right after that, but now it syncs with the closest audio frame in the interleaved array, which halves the potential sync difference between the first video frame and the first audio frame of already-active encoders. (So now the potential sync difference is roughly 11.6 milliseconds at 44.1khz audio, where it was 23.2 before)
2016-01-25 10:41:02 +00:00
packet->type == OBS_ENCODER_AUDIO ? "audio" : "video",
libobs: Consider multi-track audio when pruning packets In a multi-track scenario it was not taking in to consideration the possibility of secondary audio tracks, which could have caused desync on some of the audio tracks.
2016-01-30 17:33:20 +00:00
(int)packet->track_idx, packet->dts_usec,
libobs: Improve output packet pruning debug message Specifies whether packets were pruned or not
2016-04-20 15:36:14 +00:00
(int)i < prune_start ? "true" : "false");
libobs: Fix potential output audio/video sync bug Problem: When an output is started with encoders that have already been started by another output, and it starts in between the window in between where the first audio packets start coming in and where the first video packet comes in, the output would get audio packets with timestamps potentially much later than the first video frame when the first video frame finally comes in. The audio/video encoders will almost always have a differing delay. Solution: Detect that starting window, and if within that starting window, wait for a new keyframe from video instead of trying to sync up video. Additional Notes: In these cases where an output starts with already-active encoders, this patch also reduces the potential sync offset between the first video frame and the first audio frame. Before, it would sync the first video frame with the first audio frames right after that, but now it syncs with the closest audio frame in the interleaved array, which halves the potential sync difference between the first video frame and the first audio frame of already-active encoders. (So now the potential sync difference is roughly 11.6 milliseconds at 44.1khz audio, where it was 23.2 before)
2016-01-25 10:41:02 +00:00
}
#endif
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
libobs: Fix potential output audio/video sync bug Problem: When an output is started with encoders that have already been started by another output, and it starts in between the window in between where the first audio packets start coming in and where the first video packet comes in, the output would get audio packets with timestamps potentially much later than the first video frame when the first video frame finally comes in. The audio/video encoders will almost always have a differing delay. Solution: Detect that starting window, and if within that starting window, wait for a new keyframe from video instead of trying to sync up video. Additional Notes: In these cases where an output starts with already-active encoders, this patch also reduces the potential sync offset between the first video frame and the first audio frame. Before, it would sync the first video frame with the first audio frames right after that, but now it syncs with the closest audio frame in the interleaved array, which halves the potential sync difference between the first video frame and the first audio frame of already-active encoders. (So now the potential sync difference is roughly 11.6 milliseconds at 44.1khz audio, where it was 23.2 before)
2016-01-25 10:41:02 +00:00
/* prunes the first video packet if it's too far away from audio */
libobs: Consider multi-track audio when pruning packets In a multi-track scenario it was not taking in to consideration the possibility of secondary audio tracks, which could have caused desync on some of the audio tracks.
2016-01-30 17:33:20 +00:00
if (prune_start == -1)
return false;
else if (prune_start != 0)
start_idx = (size_t)prune_start;
libobs: Fix potential output audio/video sync bug Problem: When an output is started with encoders that have already been started by another output, and it starts in between the window in between where the first audio packets start coming in and where the first video packet comes in, the output would get audio packets with timestamps potentially much later than the first video frame when the first video frame finally comes in. The audio/video encoders will almost always have a differing delay. Solution: Detect that starting window, and if within that starting window, wait for a new keyframe from video instead of trying to sync up video. Additional Notes: In these cases where an output starts with already-active encoders, this patch also reduces the potential sync offset between the first video frame and the first audio frame. Before, it would sync the first video frame with the first audio frames right after that, but now it syncs with the closest audio frame in the interleaved array, which halves the potential sync difference between the first video frame and the first audio frame of already-active encoders. (So now the potential sync difference is roughly 11.6 milliseconds at 44.1khz audio, where it was 23.2 before)
2016-01-25 10:41:02 +00:00
else
start_idx = get_interleaved_start_idx(output);
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
libobs: Fix potential output audio/video sync bug Problem: When an output is started with encoders that have already been started by another output, and it starts in between the window in between where the first audio packets start coming in and where the first video packet comes in, the output would get audio packets with timestamps potentially much later than the first video frame when the first video frame finally comes in. The audio/video encoders will almost always have a differing delay. Solution: Detect that starting window, and if within that starting window, wait for a new keyframe from video instead of trying to sync up video. Additional Notes: In these cases where an output starts with already-active encoders, this patch also reduces the potential sync offset between the first video frame and the first audio frame. Before, it would sync the first video frame with the first audio frames right after that, but now it syncs with the closest audio frame in the interleaved array, which halves the potential sync difference between the first video frame and the first audio frame of already-active encoders. (So now the potential sync difference is roughly 11.6 milliseconds at 44.1khz audio, where it was 23.2 before)
2016-01-25 10:41:02 +00:00
if (start_idx)
discard_to_idx(output, start_idx);
libobs: Consider multi-track audio when pruning packets In a multi-track scenario it was not taking in to consideration the possibility of secondary audio tracks, which could have caused desync on some of the audio tracks.
2016-01-30 17:33:20 +00:00
return true;
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
}
libobs: Add find_first_packet_type_idx Gets the index of the first interleaved packet of a given/type and audio index
2016-01-30 17:31:57 +00:00
static int find_first_packet_type_idx(struct obs_output *output,
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
enum obs_encoder_type type, size_t idx)
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
{
for (size_t i = 0; i < output->interleaved_packets.num; i++) {
struct encoder_packet *packet =
&output->interleaved_packets.array[i];
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (packet->type == type && packet->track_idx == idx)
libobs: Add find_first_packet_type_idx Gets the index of the first interleaved packet of a given/type and audio index
2016-01-30 17:31:57 +00:00
return (int)i;
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
}
libobs: Add find_first_packet_type_idx Gets the index of the first interleaved packet of a given/type and audio index
2016-01-30 17:31:57 +00:00
return -1;
}
libobs: Fix another sync issue with encoder sharing If audio buffering is very high, the audio packets built up in the interleaved buffer would be significantly before the first video packet, causing the offset between the starting video/audio packet pairs to be significantly off, leading to desync. This issue was not spotted until recently because it only happens when streaming/recording with same encoders while audio buffering is very high.
2016-04-18 21:02:57 +00:00
static int find_last_packet_type_idx(struct obs_output *output,
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
enum obs_encoder_type type, size_t idx)
libobs: Fix another sync issue with encoder sharing If audio buffering is very high, the audio packets built up in the interleaved buffer would be significantly before the first video packet, causing the offset between the starting video/audio packet pairs to be significantly off, leading to desync. This issue was not spotted until recently because it only happens when streaming/recording with same encoders while audio buffering is very high.
2016-04-18 21:02:57 +00:00
{
for (size_t i = output->interleaved_packets.num; i > 0; i--) {
struct encoder_packet *packet =
&output->interleaved_packets.array[i - 1];
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (packet->type == type && packet->track_idx == idx)
libobs: Fix another sync issue with encoder sharing If audio buffering is very high, the audio packets built up in the interleaved buffer would be significantly before the first video packet, causing the offset between the starting video/audio packet pairs to be significantly off, leading to desync. This issue was not spotted until recently because it only happens when streaming/recording with same encoders while audio buffering is very high.
2016-04-18 21:02:57 +00:00
return (int)(i - 1);
}
return -1;
}
libobs: Add find_first_packet_type_idx Gets the index of the first interleaved packet of a given/type and audio index
2016-01-30 17:31:57 +00:00
static inline struct encoder_packet *
find_first_packet_type(struct obs_output *output, enum obs_encoder_type type,
size_t audio_idx)
{
int idx = find_first_packet_type_idx(output, type, audio_idx);
return (idx != -1) ? &output->interleaved_packets.array[idx] : NULL;
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
}
libobs: Fix another sync issue with encoder sharing If audio buffering is very high, the audio packets built up in the interleaved buffer would be significantly before the first video packet, causing the offset between the starting video/audio packet pairs to be significantly off, leading to desync. This issue was not spotted until recently because it only happens when streaming/recording with same encoders while audio buffering is very high.
2016-04-18 21:02:57 +00:00
static inline struct encoder_packet *
find_last_packet_type(struct obs_output *output, enum obs_encoder_type type,
size_t audio_idx)
{
int idx = find_last_packet_type_idx(output, type, audio_idx);
return (idx != -1) ? &output->interleaved_packets.array[idx] : NULL;
}
libobs: Always prune excessive starting audio packets On outputs that use already-active video/audio encoder, the audio pruning to sync up audio packets with video packets doesn't always get called (for example if the video pruning function was called). Always prune excess starting audio packets.
2016-04-20 15:36:54 +00:00
static bool get_audio_and_video_packets(struct obs_output *output,
struct encoder_packet **video,
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
struct encoder_packet **audio)
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
{
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
bool found_video = false;
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
if (output->video_encoders[i]) {
video[i] = find_first_packet_type(output,
OBS_ENCODER_VIDEO, i);
if (!video[i]) {
output->received_video[i] = false;
return false;
} else {
found_video = true;
}
}
}
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
if (output->audio_encoders[i]) {
audio[i] = find_first_packet_type(output,
OBS_ENCODER_AUDIO, i);
if (!audio[i]) {
output->received_audio = false;
return false;
}
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
}
}
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
return found_video;
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
}
libobs: Always prune excessive starting audio packets On outputs that use already-active video/audio encoder, the audio pruning to sync up audio packets with video packets doesn't always get called (for example if the video pruning function was called). Always prune excess starting audio packets.
2016-04-20 15:36:54 +00:00
static bool initialize_interleaved_packets(struct obs_output *output)
{
libobs: Fix null pointer access for video packets Initialize arrays to 0, as otherwise these can get initialized with garbage data or potentially Visual Studio's default debug marker, which is a problem if they're being checked against `NULL` later.
2023-06-14 17:52:05 +00:00
struct encoder_packet *video[MAX_OUTPUT_VIDEO_ENCODERS] = {0};
struct encoder_packet *audio[MAX_OUTPUT_AUDIO_ENCODERS] = {0};
struct encoder_packet *last_audio[MAX_OUTPUT_AUDIO_ENCODERS] = {0};
libobs: Always prune excessive starting audio packets On outputs that use already-active video/audio encoder, the audio pruning to sync up audio packets with video packets doesn't always get called (for example if the video pruning function was called). Always prune excess starting audio packets.
2016-04-20 15:36:54 +00:00
size_t start_idx;
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
size_t first_audio_idx;
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
size_t first_video_idx;
libobs: Always prune excessive starting audio packets On outputs that use already-active video/audio encoder, the audio pruning to sync up audio packets with video packets doesn't always get called (for example if the video pruning function was called). Always prune excess starting audio packets.
2016-04-20 15:36:54 +00:00
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
if (!get_first_audio_encoder_index(output, &first_audio_idx))
libobs: Always prune excessive starting audio packets On outputs that use already-active video/audio encoder, the audio pruning to sync up audio packets with video packets doesn't always get called (for example if the video pruning function was called). Always prune excess starting audio packets.
2016-04-20 15:36:54 +00:00
return false;
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (!get_first_video_encoder_index(output, &first_video_idx))
return false;
libobs: Always prune excessive starting audio packets On outputs that use already-active video/audio encoder, the audio pruning to sync up audio packets with video packets doesn't always get called (for example if the video pruning function was called). Always prune excess starting audio packets.
2016-04-20 15:36:54 +00:00
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (!get_audio_and_video_packets(output, video, audio))
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
return false;
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
if (output->audio_encoders[i]) {
last_audio[i] = find_last_packet_type(
output, OBS_ENCODER_AUDIO, i);
}
}
libobs: Always prune excessive starting audio packets On outputs that use already-active video/audio encoder, the audio pruning to sync up audio packets with video packets doesn't always get called (for example if the video pruning function was called). Always prune excess starting audio packets.
2016-04-20 15:36:54 +00:00
libobs: Fix another sync issue with encoder sharing If audio buffering is very high, the audio packets built up in the interleaved buffer would be significantly before the first video packet, causing the offset between the starting video/audio packet pairs to be significantly off, leading to desync. This issue was not spotted until recently because it only happens when streaming/recording with same encoders while audio buffering is very high.
2016-04-18 21:02:57 +00:00
/* ensure that there is audio past the first video packet */
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
if (output->audio_encoders[i]) {
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (last_audio[i]->dts_usec <
video[first_video_idx]->dts_usec) {
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
output->received_audio = false;
return false;
}
libobs: Fix another sync issue with encoder sharing If audio buffering is very high, the audio packets built up in the interleaved buffer would be significantly before the first video packet, causing the offset between the starting video/audio packet pairs to be significantly off, leading to desync. This issue was not spotted until recently because it only happens when streaming/recording with same encoders while audio buffering is very high.
2016-04-18 21:02:57 +00:00
}
}
libobs: Always prune excessive starting audio packets On outputs that use already-active video/audio encoder, the audio pruning to sync up audio packets with video packets doesn't always get called (for example if the video pruning function was called). Always prune excess starting audio packets.
2016-04-20 15:36:54 +00:00
/* clear out excess starting audio if it hasn't been already */
start_idx = get_interleaved_start_idx(output);
if (start_idx) {
discard_to_idx(output, start_idx);
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (!get_audio_and_video_packets(output, video, audio))
libobs: Always prune excessive starting audio packets On outputs that use already-active video/audio encoder, the audio pruning to sync up audio packets with video packets doesn't always get called (for example if the video pruning function was called). Always prune excess starting audio packets.
2016-04-20 15:36:54 +00:00
return false;
}
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
/* get new offsets */
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
if (output->video_encoders[i]) {
output->video_offsets[i] = video[i]->pts;
}
}
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
libobs: Ensure audio offsets are positive
2024-05-18 19:21:49 +00:00
if (output->audio_encoders[i] && audio[i]->dts > 0) {
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
output->audio_offsets[i] = audio[i]->dts;
}
}
libobs: Fix potential output audio/video sync bug Problem: When an output is started with encoders that have already been started by another output, and it starts in between the window in between where the first audio packets start coming in and where the first video packet comes in, the output would get audio packets with timestamps potentially much later than the first video frame when the first video frame finally comes in. The audio/video encoders will almost always have a differing delay. Solution: Detect that starting window, and if within that starting window, wait for a new keyframe from video instead of trying to sync up video. Additional Notes: In these cases where an output starts with already-active encoders, this patch also reduces the potential sync offset between the first video frame and the first audio frame. Before, it would sync the first video frame with the first audio frames right after that, but now it syncs with the closest audio frame in the interleaved array, which halves the potential sync difference between the first video frame and the first audio frame of already-active encoders. (So now the potential sync difference is roughly 11.6 milliseconds at 44.1khz audio, where it was 23.2 before)
2016-01-25 10:41:02 +00:00
#if DEBUG_STARTING_PACKETS == 1
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
int64_t v = video[first_video_idx]->dts_usec;
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
int64_t a = audio[first_audio_idx]->dts_usec;
libobs: Fix potential output audio/video sync bug Problem: When an output is started with encoders that have already been started by another output, and it starts in between the window in between where the first audio packets start coming in and where the first video packet comes in, the output would get audio packets with timestamps potentially much later than the first video frame when the first video frame finally comes in. The audio/video encoders will almost always have a differing delay. Solution: Detect that starting window, and if within that starting window, wait for a new keyframe from video instead of trying to sync up video. Additional Notes: In these cases where an output starts with already-active encoders, this patch also reduces the potential sync offset between the first video frame and the first audio frame. Before, it would sync the first video frame with the first audio frames right after that, but now it syncs with the closest audio frame in the interleaved array, which halves the potential sync difference between the first video frame and the first audio frame of already-active encoders. (So now the potential sync difference is roughly 11.6 milliseconds at 44.1khz audio, where it was 23.2 before)
2016-01-25 10:41:02 +00:00
int64_t diff = v - a;
blog(LOG_DEBUG,
"output '%s' offset for video: %lld, audio: %lld, "
"diff: %lldms",
output->context.name, v, a, diff / 1000LL);
#endif
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
/* subtract offsets from highest TS offset variables */
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
output->highest_audio_ts -= audio[first_audio_idx]->dts_usec;
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
/* apply new offsets to all existing packet DTS/PTS values */
for (size_t i = 0; i < output->interleaved_packets.num; i++) {
struct encoder_packet *packet =
&output->interleaved_packets.array[i];
apply_interleaved_packet_offset(output, packet);
}
Fix asset crash interleaving with active encoders Apparently the audio isn't guaranteed to start up past the first video frame, so it would trigger that assert (which I'm glad I put in). I didn't originally have this happen when I was testing because my audio buffering was not at the default value and didn't trigger it to occur. A blunder on my part, and once again a fine example of how you should never make assumptions about possible code path.
2014-11-03 22:13:14 +00:00
return true;
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
}
static inline void insert_interleaved_packet(struct obs_output *output,
struct encoder_packet *out)
{
size_t idx;
for (idx = 0; idx < output->interleaved_packets.num; idx++) {
struct encoder_packet *cur_packet;
cur_packet = output->interleaved_packets.array + idx;
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
// sort video packets with same DTS by track index,
// to prevent the pruning logic from removing additional
// video tracks
if (out->dts_usec == cur_packet->dts_usec &&
out->type == OBS_ENCODER_VIDEO &&
cur_packet->type == OBS_ENCODER_VIDEO &&
out->track_idx > cur_packet->track_idx)
continue;
libobs: When interleaving packets, make video come first During packet interleaving (for outputs), ensure that if two packets coincide with the same timestamp, that the video packet always comes first instead of the audio packet. This fix is required to make FLV demux properly with certain demuxers; some FLV demuxers expect the video packet before the audio packet when two packets coincide with the same timestamps.
2017-09-28 13:17:17 +00:00
if (out->dts_usec == cur_packet->dts_usec &&
out->type == OBS_ENCODER_VIDEO) {
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
break;
libobs: When interleaving packets, make video come first During packet interleaving (for outputs), ensure that if two packets coincide with the same timestamp, that the video packet always comes first instead of the audio packet. This fix is required to make FLV demux properly with certain demuxers; some FLV demuxers expect the video packet before the audio packet when two packets coincide with the same timestamps.
2017-09-28 13:17:17 +00:00
} else if (out->dts_usec < cur_packet->dts_usec) {
break;
}
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
}
da_insert(output->interleaved_packets, idx, out);
}
static void resort_interleaved_packets(struct obs_output *output)
{
DARRAY(struct encoder_packet) old_array;
old_array.da = output->interleaved_packets.da;
memset(&output->interleaved_packets, 0,
sizeof(output->interleaved_packets));
libobs: Fix `highest_video_ts` tracking Calling `set_higher_ts` before offsets are known pollutes `highest_video_ts` with timestamps that are out of range of actual timestamps. They're generally somewhere high above 0 until an offset for all streams is found, where they are then reset to 0 or slightly below 0 in the presence of b-frames. `highest_video_ts` also needs to start below 0 for the same reason. Even with timestamps being reset to close to 0, b-frames will cause initial DTS to drop below 0, thus we need a value that should "always" be below any "real" timestamps observed. `highest_video_ts` tracking now only starts once all input streams are ready, and is computed based on all buffered packets at that point.
2024-02-09 13:32:54 +00:00
for (size_t i = 0; i < old_array.num; i++) {
set_higher_ts(output, &old_array.array[i]);
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
insert_interleaved_packet(output, &old_array.array[i]);
libobs: Fix `highest_video_ts` tracking Calling `set_higher_ts` before offsets are known pollutes `highest_video_ts` with timestamps that are out of range of actual timestamps. They're generally somewhere high above 0 until an offset for all streams is found, where they are then reset to 0 or slightly below 0 in the presence of b-frames. `highest_video_ts` also needs to start below 0 for the same reason. Even with timestamps being reset to close to 0, b-frames will cause initial DTS to drop below 0, thus we need a value that should "always" be below any "real" timestamps observed. `highest_video_ts` tracking now only starts once all input streams are ready, and is computed based on all buffered packets at that point.
2024-02-09 13:32:54 +00:00
}
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
da_free(old_array);
}
libobs: Fix potential output audio/video sync bug Problem: When an output is started with encoders that have already been started by another output, and it starts in between the window in between where the first audio packets start coming in and where the first video packet comes in, the output would get audio packets with timestamps potentially much later than the first video frame when the first video frame finally comes in. The audio/video encoders will almost always have a differing delay. Solution: Detect that starting window, and if within that starting window, wait for a new keyframe from video instead of trying to sync up video. Additional Notes: In these cases where an output starts with already-active encoders, this patch also reduces the potential sync offset between the first video frame and the first audio frame. Before, it would sync the first video frame with the first audio frames right after that, but now it syncs with the closest audio frame in the interleaved array, which halves the potential sync difference between the first video frame and the first audio frame of already-active encoders. (So now the potential sync difference is roughly 11.6 milliseconds at 44.1khz audio, where it was 23.2 before)
2016-01-25 10:41:02 +00:00
static void discard_unused_audio_packets(struct obs_output *output,
int64_t dts_usec)
{
size_t idx = 0;
for (; idx < output->interleaved_packets.num; idx++) {
struct encoder_packet *p =
&output->interleaved_packets.array[idx];
if (p->dts_usec >= dts_usec)
break;
}
if (idx)
discard_to_idx(output, idx);
}
libobs: Track keyframe alignment for keyframe aligned encoder groups
2023-09-07 13:56:45 +00:00
static bool purge_encoder_group_keyframe_data(obs_output_t *output, size_t idx)
{
struct keyframe_group_data *data =
&output->keyframe_group_tracking.array[idx];
uint32_t modified_count = 0;
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
if (data->seen_on_track[i] != KEYFRAME_TRACK_STATUS_NOT_SEEN)
modified_count += 1;
}
if (modified_count == data->required_tracks) {
da_erase(output->keyframe_group_tracking, idx);
return true;
}
return false;
}
/* Check whether keyframes are emitted from all grouped encoders, and log
* if keyframes haven't been emitted from all grouped encoders. */
static void
check_encoder_group_keyframe_alignment(obs_output_t *output,
struct encoder_packet *packet)
{
size_t idx = 0;
struct keyframe_group_data insert_data = {0};
if (!packet->keyframe || packet->type != OBS_ENCODER_VIDEO ||
!packet->encoder->encoder_group)
return;
for (; idx < output->keyframe_group_tracking.num;) {
struct keyframe_group_data *data =
&output->keyframe_group_tracking.array[idx];
if (data->pts > packet->pts)
break;
if (data->group_id !=
(uintptr_t)packet->encoder->encoder_group) {
idx += 1;
continue;
}
if (data->pts < packet->pts) {
if (data->seen_on_track[packet->track_idx] ==
KEYFRAME_TRACK_STATUS_NOT_SEEN) {
blog(LOG_WARNING,
"obs-output '%s': Missing keyframe with pts %" PRIi64
" for encoder '%s' (track: %zu)",
obs_output_get_name(output), data->pts,
obs_encoder_get_name(packet->encoder),
packet->track_idx);
}
data->seen_on_track[packet->track_idx] =
KEYFRAME_TRACK_STATUS_SKIPPED;
if (!purge_encoder_group_keyframe_data(output, idx))
idx += 1;
continue;
}
data->seen_on_track[packet->track_idx] =
KEYFRAME_TRACK_STATUS_SEEN;
purge_encoder_group_keyframe_data(output, idx);
return;
}
insert_data.group_id = (uintptr_t)packet->encoder->encoder_group;
insert_data.pts = packet->pts;
insert_data.seen_on_track[packet->track_idx] =
KEYFRAME_TRACK_STATUS_SEEN;
pthread_mutex_lock(&packet->encoder->encoder_group->mutex);
insert_data.required_tracks =
packet->encoder->encoder_group->encoders_started;
pthread_mutex_unlock(&packet->encoder->encoder_group->mutex);
da_insert(output->keyframe_group_tracking, idx, &insert_data);
}
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 07:30:37 +00:00
static void interleave_packets(void *data, struct encoder_packet *packet)
{
Fix issue when using multiple video encoders - Fix an issue that could occur when using more than one video encoder. Audio/video would not sync up correctly because they were expected to be paired with a particular encoder. This simply adds a little helper variable to encoder packets that specifies the system time in microseconds. We then use that system time to sync - Fix an issue with x264 with fractional FPS rates (29.97 and 59.94 particularly) where it would create ridiculously large stream outputs. The problem was that you shouldn't set the timebase_* variables in the x264 params manually, let x264 handle the default values for it and leave them at 0. - Make x264 use CFR output, because there's no reason to ever use VFR in this case.
2014-04-10 18:59:42 +00:00
struct obs_output *output = data;
struct encoder_packet out;
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
bool was_started;
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
bool received_video;
Add packet interleaving and improve encoder API - Add interleaving of video/audio packets for outputs that are encoded and expect both video and audio data, sorting the packets and sending them to the output when both video and audio is received. - Combine create and initialize callbacks for the encoder API callback interface.
2014-04-05 06:21:19 +00:00
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
if (!active(output))
return;
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
packet->track_idx = get_encoder_index(output, packet);
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
Add packet interleaving and improve encoder API - Add interleaving of video/audio packets for outputs that are encoded and expect both video and audio data, sorting the packets and sending them to the output when both video and audio is received. - Combine create and initialize callbacks for the encoder API callback interface.
2014-04-05 06:21:19 +00:00
pthread_mutex_lock(&output->interleaved_mutex);
libobs: Fix potential output audio/video sync bug Problem: When an output is started with encoders that have already been started by another output, and it starts in between the window in between where the first audio packets start coming in and where the first video packet comes in, the output would get audio packets with timestamps potentially much later than the first video frame when the first video frame finally comes in. The audio/video encoders will almost always have a differing delay. Solution: Detect that starting window, and if within that starting window, wait for a new keyframe from video instead of trying to sync up video. Additional Notes: In these cases where an output starts with already-active encoders, this patch also reduces the potential sync offset between the first video frame and the first audio frame. Before, it would sync the first video frame with the first audio frames right after that, but now it syncs with the closest audio frame in the interleaved array, which halves the potential sync difference between the first video frame and the first audio frame of already-active encoders. (So now the potential sync difference is roughly 11.6 milliseconds at 44.1khz audio, where it was 23.2 before)
2016-01-25 10:41:02 +00:00
/* if first video frame is not a keyframe, discard until received */
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (packet->type == OBS_ENCODER_VIDEO &&
!output->received_video[packet->track_idx] && !packet->keyframe) {
libobs: Fix potential output audio/video sync bug Problem: When an output is started with encoders that have already been started by another output, and it starts in between the window in between where the first audio packets start coming in and where the first video packet comes in, the output would get audio packets with timestamps potentially much later than the first video frame when the first video frame finally comes in. The audio/video encoders will almost always have a differing delay. Solution: Detect that starting window, and if within that starting window, wait for a new keyframe from video instead of trying to sync up video. Additional Notes: In these cases where an output starts with already-active encoders, this patch also reduces the potential sync offset between the first video frame and the first audio frame. Before, it would sync the first video frame with the first audio frames right after that, but now it syncs with the closest audio frame in the interleaved array, which halves the potential sync difference between the first video frame and the first audio frame of already-active encoders. (So now the potential sync difference is roughly 11.6 milliseconds at 44.1khz audio, where it was 23.2 before)
2016-01-25 10:41:02 +00:00
discard_unused_audio_packets(output, packet->dts_usec);
pthread_mutex_unlock(&output->interleaved_mutex);
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
if (output->active_delay_ns)
libobs: Use reference counting for encoder packets Prevents reallocation of encoded packet data. Deprecates: obs_duplicate_encoder_packet obs_free_encoder_packet Replaces those functions with: obs_encoder_packet_ref obs_encoder_packet_release
2016-12-07 20:45:25 +00:00
obs_encoder_packet_release(packet);
libobs: Fix potential output audio/video sync bug Problem: When an output is started with encoders that have already been started by another output, and it starts in between the window in between where the first audio packets start coming in and where the first video packet comes in, the output would get audio packets with timestamps potentially much later than the first video frame when the first video frame finally comes in. The audio/video encoders will almost always have a differing delay. Solution: Detect that starting window, and if within that starting window, wait for a new keyframe from video instead of trying to sync up video. Additional Notes: In these cases where an output starts with already-active encoders, this patch also reduces the potential sync offset between the first video frame and the first audio frame. Before, it would sync the first video frame with the first audio frames right after that, but now it syncs with the closest audio frame in the interleaved array, which halves the potential sync difference between the first video frame and the first audio frame of already-active encoders. (So now the potential sync difference is roughly 11.6 milliseconds at 44.1khz audio, where it was 23.2 before)
2016-01-25 10:41:02 +00:00
return;
}
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
received_video = true;
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
if (output->video_encoders[i])
received_video = received_video &&
output->received_video[i];
}
libobs: Track keyframe alignment for keyframe aligned encoder groups
2023-09-07 13:56:45 +00:00
check_encoder_group_keyframe_alignment(output, packet);
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
was_started = output->received_audio && received_video;
Add packet interleaving and improve encoder API - Add interleaving of video/audio packets for outputs that are encoded and expect both video and audio data, sorting the packets and sending them to the output when both video and audio is received. - Combine create and initialize callbacks for the encoder API callback interface.
2014-04-05 06:21:19 +00:00
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
if (output->active_delay_ns)
out = *packet;
else
libobs: Use reference counting for encoder packets Prevents reallocation of encoded packet data. Deprecates: obs_duplicate_encoder_packet obs_free_encoder_packet Replaces those functions with: obs_encoder_packet_ref obs_encoder_packet_release
2016-12-07 20:45:25 +00:00
obs_encoder_packet_create_instance(&out, packet);
libobs: Fix multi. video encoder sync issues When using multiple video encoders together with a single audio encoder, the audio wouldn't be in sync. The reason why this occurred is because the dts_usec variable of the encoder packet (which is based on system time) would always be reset to a value based upon the dts (which is not guaranteed to be based on system time) in the apply_interleaved_packet_offset function. This would then in turn cause it to miscalculate the starting audio/video offsets, which are required to calculate sync. So instead of calling that function unnecessarily, separate the check for whether audio/video has been received in to a new function, and only start applying the interleaved offsets after audio and video have actually started up and the starting offsets have been calculated.
2015-02-11 05:47:34 +00:00
if (was_started)
apply_interleaved_packet_offset(output, &out);
else
check_received(output, packet);
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
insert_interleaved_packet(output, &out);
Add packet interleaving and improve encoder API - Add interleaving of video/audio packets for outputs that are encoded and expect both video and audio data, sorting the packets and sending them to the output when both video and audio is received. - Combine create and initialize callbacks for the encoder API callback interface.
2014-04-05 06:21:19 +00:00
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
received_video = true;
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
if (output->video_encoders[i])
received_video = received_video &&
output->received_video[i];
}
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
/* when both video and audio have been received, we're ready
* to start sending out packets (one at a time) */
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (output->received_audio && received_video) {
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
if (!was_started) {
libobs: Consider multi-track audio when pruning packets In a multi-track scenario it was not taking in to consideration the possibility of secondary audio tracks, which could have caused desync on some of the audio tracks.
2016-01-30 17:33:20 +00:00
if (prune_interleaved_packets(output)) {
if (initialize_interleaved_packets(output)) {
resort_interleaved_packets(output);
send_interleaved(output);
}
Fix asset crash interleaving with active encoders Apparently the audio isn't guaranteed to start up past the first video frame, so it would trigger that assert (which I'm glad I put in). I didn't originally have this happen when I was testing because my audio buffering was not at the default value and didn't trigger it to occur. A blunder on my part, and once again a fine example of how you should never make assumptions about possible code path.
2014-11-03 22:13:14 +00:00
}
} else {
libobs: Fix `highest_video_ts` tracking Calling `set_higher_ts` before offsets are known pollutes `highest_video_ts` with timestamps that are out of range of actual timestamps. They're generally somewhere high above 0 until an offset for all streams is found, where they are then reset to 0 or slightly below 0 in the presence of b-frames. `highest_video_ts` also needs to start below 0 for the same reason. Even with timestamps being reset to close to 0, b-frames will cause initial DTS to drop below 0, thus we need a value that should "always" be below any "real" timestamps observed. `highest_video_ts` tracking now only starts once all input streams are ready, and is computed based on all buffered packets at that point.
2024-02-09 13:32:54 +00:00
set_higher_ts(output, &out);
Fix asset crash interleaving with active encoders Apparently the audio isn't guaranteed to start up past the first video frame, so it would trigger that assert (which I'm glad I put in). I didn't originally have this happen when I was testing because my audio buffering was not at the default value and didn't trigger it to occur. A blunder on my part, and once again a fine example of how you should never make assumptions about possible code path.
2014-11-03 22:13:14 +00:00
send_interleaved(output);
Fix a major sync bug This bug would happen if audio packets started being received before video packets. It would erroneously cause audio packets to be completely thrown away, and in certain cases would cause audio and video to start way out of sync. My original intention was "don't accept audio until video has started", but instead mistakenly had the effect of "don't start audio until a video packet has been received". This was originally was intended as a way to handle outputs hooking in to active encoders and compensating their existing timestamp information. However, this made me realize that there was a major flaw in the design for handling this, so I basically rewrote the entire thing. Now, it does the following steps when inserting packets: - Insert packets in to the interleaved packet array - When both audio/video packets are received, prune packets up until the point in which both audio/video start at the same time - Resort the interleaved packet array I have tested this code extensively and it appears to be working well, regardless of whether or not the encoders were already active with another output.
2014-10-22 22:16:37 +00:00
}
Add packet interleaving and improve encoder API - Add interleaving of video/audio packets for outputs that are encoded and expect both video and audio data, sorting the packets and sending them to the output when both video and audio is received. - Combine create and initialize callbacks for the encoder API callback interface.
2014-04-05 06:21:19 +00:00
}
pthread_mutex_unlock(&output->interleaved_mutex);
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 07:30:37 +00:00
}
Add counting of total video frames to outputs Before it would assign the encoder/media callbacks directly to the output's callbacks, so instead of doing that, it now goes through intermediary functions for the sake of counting the frames.
2014-07-06 21:16:31 +00:00
static void default_encoded_callback(void *param, struct encoder_packet *packet)
{
struct obs_output *output = param;
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
if (data_active(output)) {
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
packet->track_idx = get_encoder_index(output, packet);
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
libobs: Fix potential crash on output stop In certain circumstances where the output was stopping, and where data took a long enough time to send (such as when using an encoding preset that causes high CPU usage), the output would sometimes still send data even after it was stopped, typically causing the output to crash.
2014-12-31 09:30:54 +00:00
output->info.encoded_packet(output->context.data, packet);
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
if (packet->type == OBS_ENCODER_VIDEO)
output->total_frames++;
}
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
if (output->active_delay_ns)
libobs: Use reference counting for encoder packets Prevents reallocation of encoded packet data. Deprecates: obs_duplicate_encoder_packet obs_free_encoder_packet Replaces those functions with: obs_encoder_packet_ref obs_encoder_packet_release
2016-12-07 20:45:25 +00:00
obs_encoder_packet_release(packet);
Add counting of total video frames to outputs Before it would assign the encoder/media callbacks directly to the output's callbacks, so instead of doing that, it now goes through intermediary functions for the sake of counting the frames.
2014-07-06 21:16:31 +00:00
}
static void default_raw_video_callback(void *param, struct video_data *frame)
{
struct obs_output *output = param;
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
if (video_pause_check(&output->pause, frame->timestamp))
return;
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
if (data_active(output))
libobs: Fix potential crash on output stop In certain circumstances where the output was stopping, and where data took a long enough time to send (such as when using an encoding preset that causes high CPU usage), the output would sometimes still send data even after it was stopped, typically causing the output to crash.
2014-12-31 09:30:54 +00:00
output->info.raw_video(output->context.data, frame);
Add counting of total video frames to outputs Before it would assign the encoder/media callbacks directly to the output's callbacks, so instead of doing that, it now goes through intermediary functions for the sake of counting the frames.
2014-07-06 21:16:31 +00:00
output->total_frames++;
libobs: Correct raw output starting audio data If the audio subsystem was buffered to any extent, the audio of a raw output would start off at a negative offset, requiring each raw output to implement a "prepare_audio" function (as seen in the FFmpeg output) in order to ensure proper synchronization with video. This did not apply to encoded outputs because it was already being performed by the obs-encoder code.
2019-07-07 03:07:37 +00:00
}
static bool prepare_audio(struct obs_output *output,
const struct audio_data *old, struct audio_data *new)
{
libobs: Fix audio-only output did not receive raw_audio
2022-10-29 23:46:44 +00:00
if ((output->info.flags & OBS_OUTPUT_VIDEO) == 0) {
*new = *old;
return true;
}
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
if (!output->video_start_ts) {
pthread_mutex_lock(&output->pause.mutex);
output->video_start_ts = output->pause.last_video_ts;
pthread_mutex_unlock(&output->pause.mutex);
}
if (!output->video_start_ts)
return false;
/* ------------------ */
libobs: Correct raw output starting audio data If the audio subsystem was buffered to any extent, the audio of a raw output would start off at a negative offset, requiring each raw output to implement a "prepare_audio" function (as seen in the FFmpeg output) in order to ensure proper synchronization with video. This did not apply to encoded outputs because it was already being performed by the obs-encoder code.
2019-07-07 03:07:37 +00:00
*new = *old;
if (old->timestamp < output->video_start_ts) {
libobs: Implement and use better scaling function for 64-bit integers As os_gettime_ns() gets large the current scaling methods, mostly by casting to uint64_t, may lead to numerical overflows. Sweep the code and use util_mul_div64() where applicable. Signed-off-by: Hans Petter Selasky <hps@selasky.org>
2020-03-21 09:55:12 +00:00
uint64_t duration = util_mul_div64(old->frames, 1000000000ULL,
output->sample_rate);
libobs: Correct raw output starting audio data If the audio subsystem was buffered to any extent, the audio of a raw output would start off at a negative offset, requiring each raw output to implement a "prepare_audio" function (as seen in the FFmpeg output) in order to ensure proper synchronization with video. This did not apply to encoded outputs because it was already being performed by the obs-encoder code.
2019-07-07 03:07:37 +00:00
uint64_t end_ts = (old->timestamp + duration);
uint64_t cutoff;
if (end_ts <= output->video_start_ts)
return false;
cutoff = output->video_start_ts - old->timestamp;
new->timestamp += cutoff;
libobs: Implement and use better scaling function for 64-bit integers As os_gettime_ns() gets large the current scaling methods, mostly by casting to uint64_t, may lead to numerical overflows. Sweep the code and use util_mul_div64() where applicable. Signed-off-by: Hans Petter Selasky <hps@selasky.org>
2020-03-21 09:55:12 +00:00
cutoff = util_mul_div64(cutoff, output->sample_rate,
1000000000ULL);
libobs: Correct raw output starting audio data If the audio subsystem was buffered to any extent, the audio of a raw output would start off at a negative offset, requiring each raw output to implement a "prepare_audio" function (as seen in the FFmpeg output) in order to ensure proper synchronization with video. This did not apply to encoded outputs because it was already being performed by the obs-encoder code.
2019-07-07 03:07:37 +00:00
for (size_t i = 0; i < output->planes; i++)
new->data[i] += output->audio_size *(uint32_t)cutoff;
new->frames -= (uint32_t)cutoff;
}
return true;
Add counting of total video frames to outputs Before it would assign the encoder/media callbacks directly to the output's callbacks, so instead of doing that, it now goes through intermediary functions for the sake of counting the frames.
2014-07-06 21:16:31 +00:00
}
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
static void default_raw_audio_callback(void *param, size_t mix_idx,
libobs: Correct raw output starting audio data If the audio subsystem was buffered to any extent, the audio of a raw output would start off at a negative offset, requiring each raw output to implement a "prepare_audio" function (as seen in the FFmpeg output) in order to ensure proper synchronization with video. This did not apply to encoded outputs because it was already being performed by the obs-encoder code.
2019-07-07 03:07:37 +00:00
struct audio_data *in)
libobs: Fix potential crash on output stop In certain circumstances where the output was stopping, and where data took a long enough time to send (such as when using an encoding preset that causes high CPU usage), the output would sometimes still send data even after it was stopped, typically causing the output to crash.
2014-12-31 09:30:54 +00:00
{
struct obs_output *output = param;
libobs: Correct raw output starting audio data If the audio subsystem was buffered to any extent, the audio of a raw output would start off at a negative offset, requiring each raw output to implement a "prepare_audio" function (as seen in the FFmpeg output) in order to ensure proper synchronization with video. This did not apply to encoded outputs because it was already being performed by the obs-encoder code.
2019-07-07 03:07:37 +00:00
struct audio_data out;
size_t frame_size_bytes;
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
if (!data_active(output))
return;
libobs: Correct raw output starting audio data If the audio subsystem was buffered to any extent, the audio of a raw output would start off at a negative offset, requiring each raw output to implement a "prepare_audio" function (as seen in the FFmpeg output) in order to ensure proper synchronization with video. This did not apply to encoded outputs because it was already being performed by the obs-encoder code.
2019-07-07 03:07:37 +00:00
/* -------------- */
if (!prepare_audio(output, in, &out))
return;
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
if (audio_pause_check(&output->pause, &out, output->sample_rate))
return;
libobs: Correct raw output starting audio data If the audio subsystem was buffered to any extent, the audio of a raw output would start off at a negative offset, requiring each raw output to implement a "prepare_audio" function (as seen in the FFmpeg output) in order to ensure proper synchronization with video. This did not apply to encoded outputs because it was already being performed by the obs-encoder code.
2019-07-07 03:07:37 +00:00
if (!output->audio_start_ts) {
output->audio_start_ts = out.timestamp;
}
frame_size_bytes = AUDIO_OUTPUT_FRAMES * output->audio_size;
for (size_t i = 0; i < output->planes; i++)
libobs: Replace circlebuf with deque
2023-11-30 15:11:18 +00:00
deque_push_back(&output->audio_buffer[mix_idx][i], out.data[i],
out.frames * output->audio_size);
libobs: Correct raw output starting audio data If the audio subsystem was buffered to any extent, the audio of a raw output would start off at a negative offset, requiring each raw output to implement a "prepare_audio" function (as seen in the FFmpeg output) in order to ensure proper synchronization with video. This did not apply to encoded outputs because it was already being performed by the obs-encoder code.
2019-07-07 03:07:37 +00:00
/* -------------- */
while (output->audio_buffer[mix_idx][0].size > frame_size_bytes) {
for (size_t i = 0; i < output->planes; i++) {
libobs: Replace circlebuf with deque
2023-11-30 15:11:18 +00:00
deque_pop_front(&output->audio_buffer[mix_idx][i],
output->audio_data[i],
frame_size_bytes);
libobs: Correct raw output starting audio data If the audio subsystem was buffered to any extent, the audio of a raw output would start off at a negative offset, requiring each raw output to implement a "prepare_audio" function (as seen in the FFmpeg output) in order to ensure proper synchronization with video. This did not apply to encoded outputs because it was already being performed by the obs-encoder code.
2019-07-07 03:07:37 +00:00
out.data[i] = (uint8_t *)output->audio_data[i];
}
out.frames = AUDIO_OUTPUT_FRAMES;
out.timestamp = output->audio_start_ts +
audio_frames_to_ns(output->sample_rate,
output->total_audio_frames);
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
pthread_mutex_lock(&output->pause.mutex);
out.timestamp += output->pause.ts_offset;
pthread_mutex_unlock(&output->pause.mutex);
libobs: Correct raw output starting audio data If the audio subsystem was buffered to any extent, the audio of a raw output would start off at a negative offset, requiring each raw output to implement a "prepare_audio" function (as seen in the FFmpeg output) in order to ensure proper synchronization with video. This did not apply to encoded outputs because it was already being performed by the obs-encoder code.
2019-07-07 03:07:37 +00:00
output->total_audio_frames += AUDIO_OUTPUT_FRAMES;
if (output->info.raw_audio2)
output->info.raw_audio2(output->context.data, mix_idx,
&out);
else
output->info.raw_audio(output->context.data, &out);
}
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
}
static inline void start_audio_encoders(struct obs_output *output,
encoded_callback_t encoded_callback)
{
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
if (output->audio_encoders[i]) {
obs_encoder_start(output->audio_encoders[i],
encoded_callback, output);
}
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
}
libobs: Fix potential crash on output stop In certain circumstances where the output was stopping, and where data took a long enough time to send (such as when using an encoding preset that causes high CPU usage), the output would sometimes still send data even after it was stopped, typically causing the output to crash.
2014-12-31 09:30:54 +00:00
}
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
static inline void start_video_encoders(struct obs_output *output,
encoded_callback_t encoded_callback)
{
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
if (output->video_encoders[i]) {
obs_encoder_start(output->video_encoders[i],
encoded_callback, output);
}
}
}
libobs: Add multi-track support to non-encoded outputs
2018-10-05 03:04:40 +00:00
static inline void start_raw_audio(obs_output_t *output)
{
if (output->info.raw_audio2) {
for (int idx = 0; idx < MAX_AUDIO_MIXES; idx++) {
if ((output->mixer_mask & ((size_t)1 << idx)) != 0) {
audio_output_connect(
output->audio, idx,
get_audio_conversion(output),
default_raw_audio_callback, output);
}
}
} else {
audio_output_connect(output->audio, get_first_mixer(output),
get_audio_conversion(output),
default_raw_audio_callback, output);
}
}
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
static void reset_packet_data(obs_output_t *output)
{
output->received_audio = false;
output->highest_audio_ts = 0;
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
output->received_video[i] = false;
output->video_offsets[i] = 0;
libobs: Fix `highest_video_ts` tracking Calling `set_higher_ts` before offsets are known pollutes `highest_video_ts` with timestamps that are out of range of actual timestamps. They're generally somewhere high above 0 until an offset for all streams is found, where they are then reset to 0 or slightly below 0 in the presence of b-frames. `highest_video_ts` also needs to start below 0 for the same reason. Even with timestamps being reset to close to 0, b-frames will cause initial DTS to drop below 0, thus we need a value that should "always" be below any "real" timestamps observed. `highest_video_ts` tracking now only starts once all input streams are ready, and is computed based on all buffered packets at that point.
2024-02-09 13:32:54 +00:00
output->highest_video_ts[i] = INT64_MIN;
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
}
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++)
libobs: Fix audio offset not reset for all tracks Track 1 offset is reset but not the offset for other tracks. This caused sync issues in between tracks (with track 1 and others). (bug found by EposVox)
2018-11-16 01:23:38 +00:00
output->audio_offsets[i] = 0;
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
free_packets(output);
}
static inline bool preserve_active(struct obs_output *output)
{
return (output->delay_flags & OBS_OUTPUT_DELAY_PRESERVE) != 0;
}
libobs, plugins: Deprecate obs_output_t functions with flag parameters This deprecates the following functions, replacing them with new versions: - `obs_output_can_begin_data_capture()` - now `*capture2()` - `obs_output_initialize_encoders()` - now `*encoders2()` - `obs_output_begin_data_capture()` - now `*capture2()` The flags parameter was initially designed to support audio-only or video-only operation of an output which had the `OBS_OUTPUT_AV` flag, however, full support for that was never implemented, and there are likely fundamental issues with an implementation, mainly that most outputs are programmed assuming that there will always be at least one audio and one video track. This requires new flags specifying support for optional audio/video, among other things. An implementation to allow audio/video to be optional is best done using the flag technique above, with audio/video enablement specified by whether media (raw, `video_t/audio_t`) or encoder (`obs_encoder_t`) objects are specified. Since every implementation I could find always specifies `flags` as 0, I was able to safely conclude that immediately removing the parameter's functionality is safe to do.
2023-05-09 06:05:27 +00:00
static void hook_data_capture(struct obs_output *output)
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
{
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
encoded_callback_t encoded_callback;
libobs, plugins: Deprecate obs_output_t functions with flag parameters This deprecates the following functions, replacing them with new versions: - `obs_output_can_begin_data_capture()` - now `*capture2()` - `obs_output_initialize_encoders()` - now `*encoders2()` - `obs_output_begin_data_capture()` - now `*capture2()` The flags parameter was initially designed to support audio-only or video-only operation of an output which had the `OBS_OUTPUT_AV` flag, however, full support for that was never implemented, and there are likely fundamental issues with an implementation, mainly that most outputs are programmed assuming that there will always be at least one audio and one video track. This requires new flags specifying support for optional audio/video, among other things. An implementation to allow audio/video to be optional is best done using the flag technique above, with audio/video enablement specified by whether media (raw, `video_t/audio_t`) or encoder (`obs_encoder_t`) objects are specified. Since every implementation I could find always specifies `flags` as 0, I was able to safely conclude that immediately removing the parameter's functionality is safe to do.
2023-05-09 06:05:27 +00:00
bool has_video = flag_video(output);
bool has_audio = flag_audio(output);
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 07:30:37 +00:00
libobs, plugins: Deprecate obs_output_t functions with flag parameters This deprecates the following functions, replacing them with new versions: - `obs_output_can_begin_data_capture()` - now `*capture2()` - `obs_output_initialize_encoders()` - now `*encoders2()` - `obs_output_begin_data_capture()` - now `*capture2()` The flags parameter was initially designed to support audio-only or video-only operation of an output which had the `OBS_OUTPUT_AV` flag, however, full support for that was never implemented, and there are likely fundamental issues with an implementation, mainly that most outputs are programmed assuming that there will always be at least one audio and one video track. This requires new flags specifying support for optional audio/video, among other things. An implementation to allow audio/video to be optional is best done using the flag technique above, with audio/video enablement specified by whether media (raw, `video_t/audio_t`) or encoder (`obs_encoder_t`) objects are specified. Since every implementation I could find always specifies `flags` as 0, I was able to safely conclude that immediately removing the parameter's functionality is safe to do.
2023-05-09 06:05:27 +00:00
if (flag_encoded(output)) {
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
pthread_mutex_lock(&output->interleaved_mutex);
reset_packet_data(output);
pthread_mutex_unlock(&output->interleaved_mutex);
Add packet interleaving and improve encoder API - Add interleaving of video/audio packets for outputs that are encoded and expect both video and audio data, sorting the packets and sending them to the output when both video and audio is received. - Combine create and initialize callbacks for the encoder API callback interface.
2014-04-05 06:21:19 +00: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 07:30:37 +00:00
encoded_callback = (has_video && has_audio)
Add counting of total video frames to outputs Before it would assign the encoder/media callbacks directly to the output's callbacks, so instead of doing that, it now goes through intermediary functions for the sake of counting the frames.
2014-07-06 21:16:31 +00:00
? interleave_packets
: default_encoded_callback;
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 07:30:37 +00:00
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
if (output->delay_sec) {
output->active_delay_ns =
(uint64_t)output->delay_sec * 1000000000ULL;
output->delay_cur_flags = output->delay_flags;
output->delay_callback = encoded_callback;
encoded_callback = process_delay;
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
os_atomic_set_bool(&output->delay_active, true);
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
blog(LOG_INFO,
"Output '%s': %" PRIu32 " second delay "
"active, preserve on disconnect is %s",
output->context.name, output->delay_sec,
preserve_active(output) ? "on" : "off");
}
libobs: Start audio tracks before starting video tracks When using multi-track audio, encoders cannot be paired like they can when only using a single audio track with video, so it has to choose the best point in the interleaved buffer as the "starting point", and if the encoders start up at different times, it has to prune that data and wait to start the output on the next video keyframe. When the audio encoders started up, there was the case where the encoders would take some time to load, and it would cause the pruning code to wait for the next keyframe to ensure startup syncing. Starting the audio encoders before starting the video encoder should reduce the possibility of that happening in a multi-track scenario.
2016-01-30 17:35:23 +00:00
if (has_audio)
start_audio_encoders(output, encoded_callback);
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
if (has_video)
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
start_video_encoders(output, encoded_callback);
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
} else {
if (has_video)
libobs: Deactivate unnecessary GPU ops when not encoding Reduces GPU usage when encoding is not active. Does not perform color conversion, frame staging, or frame downloading unless encoding is explicitly active.
2018-02-01 02:54:36 +00:00
start_raw_video(output->video,
libobs: Add obs_output_get_video_conversion Need post-convert size to avoid CPU rescale.
2022-09-07 05:03:02 +00:00
obs_output_get_video_conversion(output),
libobs: Allow configuring frame rate divisor for encoders This allows encoders/outputs to output at a frame rate that is lower than the configured base frame rate
2023-05-25 15:41:30 +00:00
1, default_raw_video_callback, output);
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
if (has_audio)
libobs: Add multi-track support to non-encoded outputs
2018-10-05 03:04:40 +00:00
start_raw_audio(output);
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
}
}
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
static inline void signal_start(struct obs_output *output)
{
do_output_signal(output, "start");
}
static inline void signal_reconnect(struct obs_output *output)
{
libobs: Use calldata with stack for simple signals Makes signals use stack memory rather than allocate memory each time. Most likely a completely insignificant and pointless optimization.
2016-01-19 04:01:58 +00:00
struct calldata params;
uint8_t stack[128];
calldata_init_fixed(&params, stack, sizeof(stack));
libobs: Add timeout_sec param to reconnect signal This optionally allows the front-end to know what the current timeout value in seconds is set to for the reconnection without having to call an extra API function to find that out.
2015-05-10 23:05:26 +00:00
calldata_set_int(&params, "timeout_sec",
libobs: Improve exponential backoff functionality - Changes the default base exponent value to 1.5 from 2.0 - Applies a random skew of +-0.05 to the exponent to lessen the "water hammer" effect caused by predictable backoff techniques - Fixes the logging associated with exponential backoff to log the true reconnect delay value
2022-06-25 23:19:48 +00:00
output->reconnect_retry_cur_msec / 1000);
libobs: Add timeout_sec param to reconnect signal This optionally allows the front-end to know what the current timeout value in seconds is set to for the reconnection without having to call an extra API function to find that out.
2015-05-10 23:05:26 +00:00
calldata_set_ptr(&params, "output", output);
signal_handler_signal(output->context.signals, "reconnect", &params);
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
}
static inline void signal_reconnect_success(struct obs_output *output)
{
do_output_signal(output, "reconnect_success");
}
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
static inline void signal_stop(struct obs_output *output)
Add preliminary FLV/RTMP output (incomplete) - obs-outputs module: Add preliminary code to send out data, and add an FLV muxer. This time we don't really need to build the packets ourselves, we can just use the FLV muxer and send it directly to RTMP_Write and it should automatically parse the entire stream for us without us having to do much manual code at all. We'll see how it goes. - libobs: Add AVC NAL packet parsing code - libobs/media-io: Add quick helper functions for audio/video to get the width/height/fps/samplerate/etc rather than having to query the info structures each time. - libobs (obs-output.c): Change 'connect' signal to 'start' and 'stop' signals. 'start' now specifies an error code rather than whether it simply failed, that way the client can actually know *why* a failure occurred. Added those error codes to obs-defs.h. - libobs: Add a few functions to duplicate/free encoder packets
2014-04-01 18:55:18 +00:00
{
libobs: Use calldata with stack for simple signals Makes signals use stack memory rather than allocate memory each time. Most likely a completely insignificant and pointless optimization.
2016-01-19 04:01:58 +00:00
struct calldata params;
libobs: Add support for output error messages
2017-05-15 10:04:11 +00:00
calldata_init(&params);
libobs: Allow last encoder error for last output error (This commit also modifies UI) This makes it more trivial for encoder plugins to communicate to users why specifically an encoder error might have occurred mid-stream.
2021-10-23 12:31:16 +00:00
calldata_set_string(&params, "last_error",
obs_output_get_last_error(output));
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
calldata_set_int(&params, "code", output->stop_code);
(API Change) libobs/callback: Unsquish names Renamed: To: ------------------------------------------------- calldata_getdata calldata_get_data calldata_getint calldata_get_int calldata_getfloat calldata_get_float calldata_getbool calldata_get_bool calldata_getptr calldata_get_ptr calldata_getstring calldata_get_string calldata_setdata calldata_set_data calldata_setint calldata_set_int calldata_setfloat calldata_set_float calldata_setbool calldata_set_bool calldata_setptr calldata_set_ptr calldata_setstring calldata_set_string
2014-08-06 00:49:28 +00:00
calldata_set_ptr(&params, "output", output);
libobs: Add support for output error messages
2017-05-15 10:04:11 +00: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-20 03:38:53 +00:00
signal_handler_signal(output->context.signals, "stop", &params);
libobs: Add support for output error messages
2017-05-15 10:04:11 +00:00
calldata_free(&params);
Add preliminary FLV/RTMP output (incomplete) - obs-outputs module: Add preliminary code to send out data, and add an FLV muxer. This time we don't really need to build the packets ourselves, we can just use the FLV muxer and send it directly to RTMP_Write and it should automatically parse the entire stream for us without us having to do much manual code at all. We'll see how it goes. - libobs: Add AVC NAL packet parsing code - libobs/media-io: Add quick helper functions for audio/video to get the width/height/fps/samplerate/etc rather than having to query the info structures each time. - libobs (obs-output.c): Change 'connect' signal to 'start' and 'stop' signals. 'start' now specifies an error code rather than whether it simply failed, that way the client can actually know *why* a failure occurred. Added those error codes to obs-defs.h. - libobs: Add a few functions to duplicate/free encoder packets
2014-04-01 18:55:18 +00:00
}
libobs,plugins: Remove new obs_output_*2 functions Effectively reverting parts of d314d47, this commit removes the new functions that got added to remove the flags parameter. Instead, it just marks the parameter as unused and documents this. Having what is effectively an API break just to remove a parameter is a bit overkill. The other parts of d314d47 which cleaned up the usage of the flags parameter are untouched here.
2023-06-04 12:00:37 +00:00
bool obs_output_can_begin_data_capture(const obs_output_t *output,
uint32_t flags)
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
{
libobs,plugins: Remove new obs_output_*2 functions Effectively reverting parts of d314d47, this commit removes the new functions that got added to remove the flags parameter. Instead, it just marks the parameter as unused and documents this. Having what is effectively an API break just to remove a parameter is a bit overkill. The other parts of d314d47 which cleaned up the usage of the flags parameter are untouched here.
2023-06-04 12:00:37 +00:00
UNUSED_PARAMETER(flags);
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (!obs_output_valid(output, "obs_output_can_begin_data_capture"))
return false;
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
if (delay_active(output))
return true;
if (active(output))
return false;
Add preliminary FLV/RTMP output (incomplete) - obs-outputs module: Add preliminary code to send out data, and add an FLV muxer. This time we don't really need to build the packets ourselves, we can just use the FLV muxer and send it directly to RTMP_Write and it should automatically parse the entire stream for us without us having to do much manual code at all. We'll see how it goes. - libobs: Add AVC NAL packet parsing code - libobs/media-io: Add quick helper functions for audio/video to get the width/height/fps/samplerate/etc rather than having to query the info structures each time. - libobs (obs-output.c): Change 'connect' signal to 'start' and 'stop' signals. 'start' now specifies an error code rather than whether it simply failed, that way the client can actually know *why* a failure occurred. Added those error codes to obs-defs.h. - libobs: Add a few functions to duplicate/free encoder packets
2014-04-01 18:55:18 +00:00
libobs: Move output/encoder shutdown to independent thread obs_output_end_data_capture could cause a hard lock due to mutex lock ordering, depending on what thread it was called in.
2016-06-22 00:25:26 +00:00
if (data_capture_ending(output))
pthread_join(output->end_data_capture_thread, NULL);
libobs, plugins: Deprecate obs_output_t functions with flag parameters This deprecates the following functions, replacing them with new versions: - `obs_output_can_begin_data_capture()` - now `*capture2()` - `obs_output_initialize_encoders()` - now `*encoders2()` - `obs_output_begin_data_capture()` - now `*capture2()` The flags parameter was initially designed to support audio-only or video-only operation of an output which had the `OBS_OUTPUT_AV` flag, however, full support for that was never implemented, and there are likely fundamental issues with an implementation, mainly that most outputs are programmed assuming that there will always be at least one audio and one video track. This requires new flags specifying support for optional audio/video, among other things. An implementation to allow audio/video to be optional is best done using the flag technique above, with audio/video enablement specified by whether media (raw, `video_t/audio_t`) or encoder (`obs_encoder_t`) objects are specified. Since every implementation I could find always specifies `flags` as 0, I was able to safely conclude that immediately removing the parameter's functionality is safe to do.
2023-05-09 06:05:27 +00:00
return can_begin_data_capture(output);
}
Add preliminary FLV/RTMP output (incomplete) - obs-outputs module: Add preliminary code to send out data, and add an FLV muxer. This time we don't really need to build the packets ourselves, we can just use the FLV muxer and send it directly to RTMP_Write and it should automatically parse the entire stream for us without us having to do much manual code at all. We'll see how it goes. - libobs: Add AVC NAL packet parsing code - libobs/media-io: Add quick helper functions for audio/video to get the width/height/fps/samplerate/etc rather than having to query the info structures each time. - libobs (obs-output.c): Change 'connect' signal to 'start' and 'stop' signals. 'start' now specifies an error code rather than whether it simply failed, that way the client can actually know *why* a failure occurred. Added those error codes to obs-defs.h. - libobs: Add a few functions to duplicate/free encoder packets
2014-04-01 18:55:18 +00:00
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
static inline bool initialize_audio_encoders(obs_output_t *output)
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
{
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
obs_encoder_t *audio = output->audio_encoders[i];
if (audio && !obs_encoder_initialize(audio)) {
libobs: Add support functions for encoder error handling Similar to how outputs can pass errors, add the same functionality for encoders so that if an output encoder has an error, it is made available to the output and eventually the UI / user.
2019-10-09 16:27:09 +00:00
obs_output_set_last_error(
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
output, obs_encoder_get_last_error(audio));
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
return false;
}
}
return true;
}
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
static inline bool initialize_video_encoders(obs_output_t *output)
{
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
obs_encoder_t *video = output->video_encoders[i];
if (video && !obs_encoder_initialize(video)) {
obs_output_set_last_error(
output, obs_encoder_get_last_error(video));
return false;
}
}
return true;
}
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
static inline void pair_encoders(obs_output_t *output)
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
{
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
size_t first_venc_idx;
if (!get_first_video_encoder_index(output, &first_venc_idx))
return;
struct obs_encoder *video = output->video_encoders[first_venc_idx];
libobs: Fix potential race condition Fixes potential race conditions when two threads are trying to initialize/start/stop the same encoders at the same time.
2016-01-25 09:42:06 +00:00
libobs: Pair video encoder with all audio encoders
2023-12-03 17:41:39 +00:00
pthread_mutex_lock(&video->init_mutex);
if (video->active) {
pthread_mutex_unlock(&video->init_mutex);
return;
}
libobs: Fix potential race condition Fixes potential race conditions when two threads are trying to initialize/start/stop the same encoders at the same time.
2016-01-25 09:42:06 +00:00
libobs: Pair video encoder with all audio encoders
2023-12-03 17:41:39 +00:00
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
struct obs_encoder *audio = output->audio_encoders[i];
if (!audio)
continue;
libobs: Fix potential race condition Fixes potential race conditions when two threads are trying to initialize/start/stop the same encoders at the same time.
2016-01-25 09:42:06 +00:00
libobs: Pair video encoder with all audio encoders
2023-12-03 17:41:39 +00:00
pthread_mutex_lock(&audio->init_mutex);
if (!audio->active && !audio->paired_encoders.num) {
da_push_back(video->paired_encoders, &audio);
da_push_back(audio->paired_encoders, &video);
}
libobs: Fix potential race condition Fixes potential race conditions when two threads are trying to initialize/start/stop the same encoders at the same time.
2016-01-25 09:42:06 +00:00
pthread_mutex_unlock(&audio->init_mutex);
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
}
libobs: Pair video encoder with all audio encoders
2023-12-03 17:41:39 +00:00
pthread_mutex_unlock(&video->init_mutex);
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
}
libobs,plugins: Remove new obs_output_*2 functions Effectively reverting parts of d314d47, this commit removes the new functions that got added to remove the flags parameter. Instead, it just marks the parameter as unused and documents this. Having what is effectively an API break just to remove a parameter is a bit overkill. The other parts of d314d47 which cleaned up the usage of the flags parameter are untouched here.
2023-06-04 12:00:37 +00:00
bool obs_output_initialize_encoders(obs_output_t *output, uint32_t flags)
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-08 05:00:10 +00:00
{
libobs,plugins: Remove new obs_output_*2 functions Effectively reverting parts of d314d47, this commit removes the new functions that got added to remove the flags parameter. Instead, it just marks the parameter as unused and documents this. Having what is effectively an API break just to remove a parameter is a bit overkill. The other parts of d314d47 which cleaned up the usage of the flags parameter are untouched here.
2023-06-04 12:00:37 +00:00
UNUSED_PARAMETER(flags);
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (!obs_output_valid(output, "obs_output_initialize_encoders"))
return false;
libobs, plugins: Deprecate obs_output_t functions with flag parameters This deprecates the following functions, replacing them with new versions: - `obs_output_can_begin_data_capture()` - now `*capture2()` - `obs_output_initialize_encoders()` - now `*encoders2()` - `obs_output_begin_data_capture()` - now `*capture2()` The flags parameter was initially designed to support audio-only or video-only operation of an output which had the `OBS_OUTPUT_AV` flag, however, full support for that was never implemented, and there are likely fundamental issues with an implementation, mainly that most outputs are programmed assuming that there will always be at least one audio and one video track. This requires new flags specifying support for optional audio/video, among other things. An implementation to allow audio/video to be optional is best done using the flag technique above, with audio/video enablement specified by whether media (raw, `video_t/audio_t`) or encoder (`obs_encoder_t`) objects are specified. Since every implementation I could find always specifies `flags` as 0, I was able to safely conclude that immediately removing the parameter's functionality is safe to do.
2023-05-09 06:05:27 +00:00
if (!log_flag_encoded(output, __FUNCTION__, false))
return false;
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
if (active(output))
return delay_active(output);
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-08 05:00:10 +00:00
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
if (flag_video(output) && !initialize_video_encoders(output))
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-08 05:00:10 +00:00
return false;
libobs, plugins: Deprecate obs_output_t functions with flag parameters This deprecates the following functions, replacing them with new versions: - `obs_output_can_begin_data_capture()` - now `*capture2()` - `obs_output_initialize_encoders()` - now `*encoders2()` - `obs_output_begin_data_capture()` - now `*capture2()` The flags parameter was initially designed to support audio-only or video-only operation of an output which had the `OBS_OUTPUT_AV` flag, however, full support for that was never implemented, and there are likely fundamental issues with an implementation, mainly that most outputs are programmed assuming that there will always be at least one audio and one video track. This requires new flags specifying support for optional audio/video, among other things. An implementation to allow audio/video to be optional is best done using the flag technique above, with audio/video enablement specified by whether media (raw, `video_t/audio_t`) or encoder (`obs_encoder_t`) objects are specified. Since every implementation I could find always specifies `flags` as 0, I was able to safely conclude that immediately removing the parameter's functionality is safe to do.
2023-05-09 06:05:27 +00:00
if (flag_audio(output) && !initialize_audio_encoders(output))
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-08 05:00:10 +00:00
return false;
return true;
}
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
static bool begin_delayed_capture(obs_output_t *output)
{
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
if (delay_capturing(output))
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
return false;
pthread_mutex_lock(&output->interleaved_mutex);
reset_packet_data(output);
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
os_atomic_set_bool(&output->delay_capturing, true);
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
pthread_mutex_unlock(&output->interleaved_mutex);
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
if (reconnecting(output)) {
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
signal_reconnect_success(output);
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
os_atomic_set_bool(&output->reconnecting, false);
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
} else {
signal_start(output);
}
return true;
}
libobs: Correct raw output starting audio data If the audio subsystem was buffered to any extent, the audio of a raw output would start off at a negative offset, requiring each raw output to implement a "prepare_audio" function (as seen in the FFmpeg output) in order to ensure proper synchronization with video. This did not apply to encoded outputs because it was already being performed by the obs-encoder code.
2019-07-07 03:07:37 +00:00
static void reset_raw_output(obs_output_t *output)
{
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
clear_raw_audio_buffers(output);
libobs: Correct raw output starting audio data If the audio subsystem was buffered to any extent, the audio of a raw output would start off at a negative offset, requiring each raw output to implement a "prepare_audio" function (as seen in the FFmpeg output) in order to ensure proper synchronization with video. This did not apply to encoded outputs because it was already being performed by the obs-encoder code.
2019-07-07 03:07:37 +00:00
libobs: add pointer check in reset_raw_output
2019-08-23 16:40:52 +00:00
if (output->audio) {
const struct audio_output_info *aoi =
audio_output_get_info(output->audio);
struct audio_convert_info conv = output->audio_conversion;
struct audio_convert_info info = {
aoi->samples_per_sec,
aoi->format,
aoi->speakers,
};
if (output->audio_conversion_set) {
if (conv.samples_per_sec)
info.samples_per_sec = conv.samples_per_sec;
if (conv.format != AUDIO_FORMAT_UNKNOWN)
info.format = conv.format;
if (conv.speakers != SPEAKERS_UNKNOWN)
info.speakers = conv.speakers;
}
output->sample_rate = info.samples_per_sec;
output->planes = get_audio_planes(info.format, info.speakers);
output->total_audio_frames = 0;
output->audio_size =
get_audio_size(info.format, info.speakers, 1);
libobs: Correct raw output starting audio data If the audio subsystem was buffered to any extent, the audio of a raw output would start off at a negative offset, requiring each raw output to implement a "prepare_audio" function (as seen in the FFmpeg output) in order to ensure proper synchronization with video. This did not apply to encoded outputs because it was already being performed by the obs-encoder code.
2019-07-07 03:07:37 +00:00
}
output->audio_start_ts = 0;
output->video_start_ts = 0;
libobs: Implement pausing of outputs This implements pausing of outputs. To accomplish this, raw audio/video data is halted to the encoders or raw output. Pausing is as precisely timed as possible according to the timing of the obs_output_pause call, and audio data will be spliced down to the exact audio sample in accordance to that timing at the start/end marks. Outputs that support this (outputs used for recording) can set the OBS_OUTPUT_CAN_PAUSE capability flag.
2019-07-07 19:27:13 +00:00
pause_reset(&output->pause);
libobs: Correct raw output starting audio data If the audio subsystem was buffered to any extent, the audio of a raw output would start off at a negative offset, requiring each raw output to implement a "prepare_audio" function (as seen in the FFmpeg output) in order to ensure proper synchronization with video. This did not apply to encoded outputs because it was already being performed by the obs-encoder code.
2019-07-07 03:07:37 +00:00
}
libobs,plugins: Remove new obs_output_*2 functions Effectively reverting parts of d314d47, this commit removes the new functions that got added to remove the flags parameter. Instead, it just marks the parameter as unused and documents this. Having what is effectively an API break just to remove a parameter is a bit overkill. The other parts of d314d47 which cleaned up the usage of the flags parameter are untouched here.
2023-06-04 12:00:37 +00:00
bool obs_output_begin_data_capture(obs_output_t *output, uint32_t flags)
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
{
libobs,plugins: Remove new obs_output_*2 functions Effectively reverting parts of d314d47, this commit removes the new functions that got added to remove the flags parameter. Instead, it just marks the parameter as unused and documents this. Having what is effectively an API break just to remove a parameter is a bit overkill. The other parts of d314d47 which cleaned up the usage of the flags parameter are untouched here.
2023-06-04 12:00:37 +00:00
UNUSED_PARAMETER(flags);
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (!obs_output_valid(output, "obs_output_begin_data_capture"))
return false;
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
if (delay_active(output))
return begin_delayed_capture(output);
if (active(output))
return false;
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
Add counting of total video frames to outputs Before it would assign the encoder/media callbacks directly to the output's callbacks, so instead of doing that, it now goes through intermediary functions for the sake of counting the frames.
2014-07-06 21:16:31 +00:00
output->total_frames = 0;
libobs: Remove warning log for raw outputs when starting data capture #8873 accidentally used `log_flag_encoded()` instead of `flag_encoded()` in `obs_output_begin_data_capture()`, which was causing a warning to be logged when it shouldn't.
2023-05-27 20:18:41 +00:00
if (!flag_encoded(output))
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
reset_raw_output(output);
libobs, plugins: Deprecate obs_output_t functions with flag parameters This deprecates the following functions, replacing them with new versions: - `obs_output_can_begin_data_capture()` - now `*capture2()` - `obs_output_initialize_encoders()` - now `*encoders2()` - `obs_output_begin_data_capture()` - now `*capture2()` The flags parameter was initially designed to support audio-only or video-only operation of an output which had the `OBS_OUTPUT_AV` flag, however, full support for that was never implemented, and there are likely fundamental issues with an implementation, mainly that most outputs are programmed assuming that there will always be at least one audio and one video track. This requires new flags specifying support for optional audio/video, among other things. An implementation to allow audio/video to be optional is best done using the flag technique above, with audio/video enablement specified by whether media (raw, `video_t/audio_t`) or encoder (`obs_encoder_t`) objects are specified. Since every implementation I could find always specifies `flags` as 0, I was able to safely conclude that immediately removing the parameter's functionality is safe to do.
2023-05-09 06:05:27 +00:00
if (!can_begin_data_capture(output))
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
return false;
libobs, plugins: Deprecate obs_output_t functions with flag parameters This deprecates the following functions, replacing them with new versions: - `obs_output_can_begin_data_capture()` - now `*capture2()` - `obs_output_initialize_encoders()` - now `*encoders2()` - `obs_output_begin_data_capture()` - now `*capture2()` The flags parameter was initially designed to support audio-only or video-only operation of an output which had the `OBS_OUTPUT_AV` flag, however, full support for that was never implemented, and there are likely fundamental issues with an implementation, mainly that most outputs are programmed assuming that there will always be at least one audio and one video track. This requires new flags specifying support for optional audio/video, among other things. An implementation to allow audio/video to be optional is best done using the flag technique above, with audio/video enablement specified by whether media (raw, `video_t/audio_t`) or encoder (`obs_encoder_t`) objects are specified. Since every implementation I could find always specifies `flags` as 0, I was able to safely conclude that immediately removing the parameter's functionality is safe to do.
2023-05-09 06:05:27 +00:00
if (flag_video(output) && flag_audio(output))
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
pair_encoders(output);
libobs: Pair encoders only when output actually starts Normally, paired encoders are unpaired when they stop. However, if the pairing occurs before the encoders actually start, and the encoders never actually end up starting, they are never unpaired, and that pairing stays with them until the next time an output is started up again. That in turn can cause an output that uses one of the encoders but not the other to not function correctly, and neither properly "start" nor stop because the data is queued continually in the interleaved packet array. For example, let's say there are two outputs, two video encoders, and one audio encoder. This can be reproduced by using advanced output mode and making the two outputs use separate video encoders while sharing track 1's audio encoder. If you start up the stream output first and it fails to fully connect for whatever reason (bad server, bad stream key, etc), then you start up the recording output, the recording output will appear to be running, but will not stop when you hit "stop recording". It will stay perpetually on "stopping recording" and will get stuck that way. This is because when the streaming output started, the streaming output would initially pair video encoder A with audio encoder A before the encoders actually fully started up (as the encoders do not fully start up until a connection is successfully made), and when the recording output starts up after that disconnection, audio encoder A will wait for video encoder A rather than video encoder B because that pairing was never actually cleared. So, instead of pairing encoders when the output starts, wait until the encoders themselves are being started and then pair the encoders at that point in time. This ensures that the encoders start up and will clear their pairing when no longer in use.
2019-05-22 07:37:12 +00:00
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
os_atomic_set_bool(&output->data_active, true);
libobs, plugins: Deprecate obs_output_t functions with flag parameters This deprecates the following functions, replacing them with new versions: - `obs_output_can_begin_data_capture()` - now `*capture2()` - `obs_output_initialize_encoders()` - now `*encoders2()` - `obs_output_begin_data_capture()` - now `*capture2()` The flags parameter was initially designed to support audio-only or video-only operation of an output which had the `OBS_OUTPUT_AV` flag, however, full support for that was never implemented, and there are likely fundamental issues with an implementation, mainly that most outputs are programmed assuming that there will always be at least one audio and one video track. This requires new flags specifying support for optional audio/video, among other things. An implementation to allow audio/video to be optional is best done using the flag technique above, with audio/video enablement specified by whether media (raw, `video_t/audio_t`) or encoder (`obs_encoder_t`) objects are specified. Since every implementation I could find always specifies `flags` as 0, I was able to safely conclude that immediately removing the parameter's functionality is safe to do.
2023-05-09 06:05:27 +00:00
hook_data_capture(output);
obs-studio UI: Implement stream settings UI - Updated the services API so that it links up with an output and the output gets data from that service rather than via settings. This allows the service context to have control over how an output is used, and makes it so that the URL/key/etc isn't necessarily some static setting. Also, if the service is attached to an output, it will stick around until the output is destroyed. - The settings interface has been updated so that it can allow the usage of service plugins. What this means is that now you can create a service plugin that can control aspects of the stream, and it allows each service to create their own user interface if they create a service plugin module. - Testing out saving of current service information. Saves/loads from JSON in to obs_data_t, seems to be working quite nicely, and the service object information is saved/preserved on exit, and loaded again on startup. - I agonized over the settings user interface for days, and eventually I just decided that the only way that users weren't going to be fumbling over options was to split up the settings in to simple/basic output, pre-configured, and then advanced for advanced use (such as multiple outputs or services, which I'll implement later). This was particularly painful to really design right, I wanted more features and wanted to include everything in one interface but ultimately just realized from experience that users are just not technically knowledgable about it and will end up fumbling with the settings rather than getting things done. Basically, what this means is that casual users only have to enter in about 3 things to configure their stream: Stream key, audio bitrate, and video bitrate. I am really happy with this interface for those types of users, but it definitely won't be sufficient for advanced usage or for custom outputs, so that stuff will have to be separated. - Improved the JSON usage for the 'common streaming services' context, I realized that JSON arrays are there to ensure sorting, while forgetting that general items are optimized for hashing. So basically I'm just using arrays now to sort items in it.
2014-04-24 08:49:07 +00:00
libobs, plugins: Deprecate obs_output_t functions with flag parameters This deprecates the following functions, replacing them with new versions: - `obs_output_can_begin_data_capture()` - now `*capture2()` - `obs_output_initialize_encoders()` - now `*encoders2()` - `obs_output_begin_data_capture()` - now `*capture2()` The flags parameter was initially designed to support audio-only or video-only operation of an output which had the `OBS_OUTPUT_AV` flag, however, full support for that was never implemented, and there are likely fundamental issues with an implementation, mainly that most outputs are programmed assuming that there will always be at least one audio and one video track. This requires new flags specifying support for optional audio/video, among other things. An implementation to allow audio/video to be optional is best done using the flag technique above, with audio/video enablement specified by whether media (raw, `video_t/audio_t`) or encoder (`obs_encoder_t`) objects are specified. Since every implementation I could find always specifies `flags` as 0, I was able to safely conclude that immediately removing the parameter's functionality is safe to do.
2023-05-09 06:05:27 +00:00
if (flag_service(output))
obs-studio UI: Implement stream settings UI - Updated the services API so that it links up with an output and the output gets data from that service rather than via settings. This allows the service context to have control over how an output is used, and makes it so that the URL/key/etc isn't necessarily some static setting. Also, if the service is attached to an output, it will stick around until the output is destroyed. - The settings interface has been updated so that it can allow the usage of service plugins. What this means is that now you can create a service plugin that can control aspects of the stream, and it allows each service to create their own user interface if they create a service plugin module. - Testing out saving of current service information. Saves/loads from JSON in to obs_data_t, seems to be working quite nicely, and the service object information is saved/preserved on exit, and loaded again on startup. - I agonized over the settings user interface for days, and eventually I just decided that the only way that users weren't going to be fumbling over options was to split up the settings in to simple/basic output, pre-configured, and then advanced for advanced use (such as multiple outputs or services, which I'll implement later). This was particularly painful to really design right, I wanted more features and wanted to include everything in one interface but ultimately just realized from experience that users are just not technically knowledgable about it and will end up fumbling with the settings rather than getting things done. Basically, what this means is that casual users only have to enter in about 3 things to configure their stream: Stream key, audio bitrate, and video bitrate. I am really happy with this interface for those types of users, but it definitely won't be sufficient for advanced usage or for custom outputs, so that stuff will have to be separated. - Improved the JSON usage for the 'common streaming services' context, I realized that JSON arrays are there to ensure sorting, while forgetting that general items are optimized for hashing. So basically I'm just using arrays now to sort items in it.
2014-04-24 08:49:07 +00:00
obs_service_activate(output->service);
libobs: Add activate/deactivate output signals Indicates when an output is considered active/inactive.
2015-09-10 18:02:20 +00:00
do_output_signal(output, "activate");
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
os_atomic_set_bool(&output->active, true);
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
if (reconnecting(output)) {
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
signal_reconnect_success(output);
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
os_atomic_set_bool(&output->reconnecting, false);
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
} else if (delay_active(output)) {
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
do_output_signal(output, "starting");
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
} else {
signal_start(output);
}
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
return true;
}
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
static inline void stop_audio_encoders(obs_output_t *output,
encoded_callback_t encoded_callback)
{
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
obs_encoder_t *audio = output->audio_encoders[i];
if (audio)
obs_encoder_stop(audio, encoded_callback, output);
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
}
}
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
static inline void stop_video_encoders(obs_output_t *output,
encoded_callback_t encoded_callback)
{
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
obs_encoder_t *video = output->video_encoders[i];
if (video)
obs_encoder_stop(video, encoded_callback, output);
}
}
libobs: Add multi-track support to non-encoded outputs
2018-10-05 03:04:40 +00:00
static inline void stop_raw_audio(obs_output_t *output)
{
if (output->info.raw_audio2) {
for (int idx = 0; idx < MAX_AUDIO_MIXES; idx++) {
if ((output->mixer_mask & ((size_t)1 << idx)) != 0) {
audio_output_disconnect(
output->audio, idx,
default_raw_audio_callback, output);
}
}
} else {
audio_output_disconnect(output->audio, get_first_mixer(output),
default_raw_audio_callback, output);
}
}
libobs: Move output/encoder shutdown to independent thread obs_output_end_data_capture could cause a hard lock due to mutex lock ordering, depending on what thread it was called in.
2016-06-22 00:25:26 +00:00
static void *end_data_capture_thread(void *data)
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
{
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
encoded_callback_t encoded_callback;
libobs: Move output/encoder shutdown to independent thread obs_output_end_data_capture could cause a hard lock due to mutex lock ordering, depending on what thread it was called in.
2016-06-22 00:25:26 +00:00
obs_output_t *output = data;
libobs, plugins: Deprecate obs_output_t functions with flag parameters This deprecates the following functions, replacing them with new versions: - `obs_output_can_begin_data_capture()` - now `*capture2()` - `obs_output_initialize_encoders()` - now `*encoders2()` - `obs_output_begin_data_capture()` - now `*capture2()` The flags parameter was initially designed to support audio-only or video-only operation of an output which had the `OBS_OUTPUT_AV` flag, however, full support for that was never implemented, and there are likely fundamental issues with an implementation, mainly that most outputs are programmed assuming that there will always be at least one audio and one video track. This requires new flags specifying support for optional audio/video, among other things. An implementation to allow audio/video to be optional is best done using the flag technique above, with audio/video enablement specified by whether media (raw, `video_t/audio_t`) or encoder (`obs_encoder_t`) objects are specified. Since every implementation I could find always specifies `flags` as 0, I was able to safely conclude that immediately removing the parameter's functionality is safe to do.
2023-05-09 06:05:27 +00:00
bool has_video = flag_video(output);
bool has_audio = flag_audio(output);
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
libobs, plugins: Deprecate obs_output_t functions with flag parameters This deprecates the following functions, replacing them with new versions: - `obs_output_can_begin_data_capture()` - now `*capture2()` - `obs_output_initialize_encoders()` - now `*encoders2()` - `obs_output_begin_data_capture()` - now `*capture2()` The flags parameter was initially designed to support audio-only or video-only operation of an output which had the `OBS_OUTPUT_AV` flag, however, full support for that was never implemented, and there are likely fundamental issues with an implementation, mainly that most outputs are programmed assuming that there will always be at least one audio and one video track. This requires new flags specifying support for optional audio/video, among other things. An implementation to allow audio/video to be optional is best done using the flag technique above, with audio/video enablement specified by whether media (raw, `video_t/audio_t`) or encoder (`obs_encoder_t`) objects are specified. Since every implementation I could find always specifies `flags` as 0, I was able to safely conclude that immediately removing the parameter's functionality is safe to do.
2023-05-09 06:05:27 +00:00
if (flag_encoded(output)) {
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
if (output->active_delay_ns)
encoded_callback = process_delay;
else
encoded_callback = (has_video && has_audio)
? interleave_packets
: default_encoded_callback;
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 07:30:37 +00:00
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
if (has_video)
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
stop_video_encoders(output, encoded_callback);
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
if (has_audio)
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 10:12:08 +00:00
stop_audio_encoders(output, encoded_callback);
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
} else {
if (has_video)
libobs: Deactivate unnecessary GPU ops when not encoding Reduces GPU usage when encoding is not active. Does not perform color conversion, frame staging, or frame downloading unless encoding is explicitly active.
2018-02-01 02:54:36 +00:00
stop_raw_video(output->video,
Add counting of total video frames to outputs Before it would assign the encoder/media callbacks directly to the output's callbacks, so instead of doing that, it now goes through intermediary functions for the sake of counting the frames.
2014-07-06 21:16:31 +00:00
default_raw_video_callback, output);
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
if (has_audio)
libobs: Add multi-track support to non-encoded outputs
2018-10-05 03:04:40 +00:00
stop_raw_audio(output);
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
}
libobs, plugins: Deprecate obs_output_t functions with flag parameters This deprecates the following functions, replacing them with new versions: - `obs_output_can_begin_data_capture()` - now `*capture2()` - `obs_output_initialize_encoders()` - now `*encoders2()` - `obs_output_begin_data_capture()` - now `*capture2()` The flags parameter was initially designed to support audio-only or video-only operation of an output which had the `OBS_OUTPUT_AV` flag, however, full support for that was never implemented, and there are likely fundamental issues with an implementation, mainly that most outputs are programmed assuming that there will always be at least one audio and one video track. This requires new flags specifying support for optional audio/video, among other things. An implementation to allow audio/video to be optional is best done using the flag technique above, with audio/video enablement specified by whether media (raw, `video_t/audio_t`) or encoder (`obs_encoder_t`) objects are specified. Since every implementation I could find always specifies `flags` as 0, I was able to safely conclude that immediately removing the parameter's functionality is safe to do.
2023-05-09 06:05:27 +00:00
if (flag_service(output))
obs-studio UI: Implement stream settings UI - Updated the services API so that it links up with an output and the output gets data from that service rather than via settings. This allows the service context to have control over how an output is used, and makes it so that the URL/key/etc isn't necessarily some static setting. Also, if the service is attached to an output, it will stick around until the output is destroyed. - The settings interface has been updated so that it can allow the usage of service plugins. What this means is that now you can create a service plugin that can control aspects of the stream, and it allows each service to create their own user interface if they create a service plugin module. - Testing out saving of current service information. Saves/loads from JSON in to obs_data_t, seems to be working quite nicely, and the service object information is saved/preserved on exit, and loaded again on startup. - I agonized over the settings user interface for days, and eventually I just decided that the only way that users weren't going to be fumbling over options was to split up the settings in to simple/basic output, pre-configured, and then advanced for advanced use (such as multiple outputs or services, which I'll implement later). This was particularly painful to really design right, I wanted more features and wanted to include everything in one interface but ultimately just realized from experience that users are just not technically knowledgable about it and will end up fumbling with the settings rather than getting things done. Basically, what this means is that casual users only have to enter in about 3 things to configure their stream: Stream key, audio bitrate, and video bitrate. I am really happy with this interface for those types of users, but it definitely won't be sufficient for advanced usage or for custom outputs, so that stuff will have to be separated. - Improved the JSON usage for the 'common streaming services' context, I realized that JSON arrays are there to ensure sorting, while forgetting that general items are optimized for hashing. So basically I'm just using arrays now to sort items in it.
2014-04-24 08:49:07 +00:00
obs_service_deactivate(output->service, false);
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
if (output->active_delay_ns)
obs_output_cleanup_delay(output);
libobs: Add activate/deactivate output signals Indicates when an output is considered active/inactive.
2015-09-10 18:02:20 +00:00
do_output_signal(output, "deactivate");
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
os_atomic_set_bool(&output->active, false);
libobs: Do not allow output stop calls more than once
2016-06-21 00:09:21 +00:00
os_event_signal(output->stopping_event);
libobs: Move output/encoder shutdown to independent thread obs_output_end_data_capture could cause a hard lock due to mutex lock ordering, depending on what thread it was called in.
2016-06-22 00:25:26 +00:00
os_atomic_set_bool(&output->end_data_capture_thread_active, false);
return NULL;
}
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
static void obs_output_end_data_capture_internal(obs_output_t *output,
bool signal)
libobs: Move output/encoder shutdown to independent thread obs_output_end_data_capture could cause a hard lock due to mutex lock ordering, depending on what thread it was called in.
2016-06-22 00:25:26 +00:00
{
int ret;
if (!obs_output_valid(output, "obs_output_end_data_capture"))
return;
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
if (!active(output) || !data_active(output)) {
if (signal) {
signal_stop(output);
output->stop_code = OBS_OUTPUT_SUCCESS;
libobs: Fix bug where outputs would not set stopped event When an output fails to connect and it's already been prematurely stopped, the event to mark the output as stopped would not be signaled, causing obs_output_destroy to lock up indefinitely while waiting for the event to be signaled.
2017-05-20 20:11:59 +00:00
os_event_signal(output->stopping_event);
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
}
return;
}
libobs: Move output/encoder shutdown to independent thread obs_output_end_data_capture could cause a hard lock due to mutex lock ordering, depending on what thread it was called in.
2016-06-22 00:25:26 +00:00
if (delay_active(output)) {
os_atomic_set_bool(&output->delay_capturing, false);
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
if (!os_atomic_load_long(&output->delay_restart_refs)) {
os_atomic_set_bool(&output->delay_active, false);
} else {
os_event_signal(output->stopping_event);
return;
}
libobs: Move output/encoder shutdown to independent thread obs_output_end_data_capture could cause a hard lock due to mutex lock ordering, depending on what thread it was called in.
2016-06-22 00:25:26 +00:00
}
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
os_atomic_set_bool(&output->data_active, false);
libobs: Fix rendering stats not being logged on output stop
2023-10-13 08:21:12 +00:00
if (flag_video(output))
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
log_frame_info(output);
libobs: Move output/encoder shutdown to independent thread obs_output_end_data_capture could cause a hard lock due to mutex lock ordering, depending on what thread it was called in.
2016-06-22 00:25:26 +00:00
if (data_capture_ending(output))
pthread_join(output->end_data_capture_thread, NULL);
os_atomic_set_bool(&output->end_data_capture_thread_active, true);
ret = pthread_create(&output->end_data_capture_thread, NULL,
end_data_capture_thread, output);
if (ret != 0) {
blog(LOG_WARNING,
"Failed to create end_data_capture_thread "
"for output '%s'!",
output->context.name);
end_data_capture_thread(output);
}
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
if (signal) {
signal_stop(output);
output->stop_code = OBS_OUTPUT_SUCCESS;
}
}
void obs_output_end_data_capture(obs_output_t *output)
{
obs_output_end_data_capture_internal(output, true);
Add preliminary FLV/RTMP output (incomplete) - obs-outputs module: Add preliminary code to send out data, and add an FLV muxer. This time we don't really need to build the packets ourselves, we can just use the FLV muxer and send it directly to RTMP_Write and it should automatically parse the entire stream for us without us having to do much manual code at all. We'll see how it goes. - libobs: Add AVC NAL packet parsing code - libobs/media-io: Add quick helper functions for audio/video to get the width/height/fps/samplerate/etc rather than having to query the info structures each time. - libobs (obs-output.c): Change 'connect' signal to 'start' and 'stop' signals. 'start' now specifies an error code rather than whether it simply failed, that way the client can actually know *why* a failure occurred. Added those error codes to obs-defs.h. - libobs: Add a few functions to duplicate/free encoder packets
2014-04-01 18:55:18 +00:00
}
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
static void *reconnect_thread(void *param)
{
struct obs_output *output = param;
output->reconnect_thread_active = true;
libobs: Improve exponential backoff functionality - Changes the default base exponent value to 1.5 from 2.0 - Applies a random skew of +-0.05 to the exponent to lessen the "water hammer" effect caused by predictable backoff techniques - Fixes the logging associated with exponential backoff to log the true reconnect delay value
2022-06-25 23:19:48 +00:00
if (os_event_timedwait(output->reconnect_stop_event,
output->reconnect_retry_cur_msec) == ETIMEDOUT)
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
obs_output_actual_start(output);
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
if (os_event_try(output->reconnect_stop_event) == EAGAIN)
pthread_detach(output->reconnect_thread);
libobs: Set reconnect to false on user cancel This fixes the issue when an output cancels reconnecting, reconnect is left at true, causing obs_output_active to always return true even though reconnecting has actually been canceled.
2015-09-11 15:20:18 +00:00
else
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
os_atomic_set_bool(&output->reconnecting, false);
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
output->reconnect_thread_active = false;
return NULL;
}
static void output_reconnect(struct obs_output *output)
{
int ret;
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
if (!reconnecting(output)) {
libobs: Improve exponential backoff functionality - Changes the default base exponent value to 1.5 from 2.0 - Applies a random skew of +-0.05 to the exponent to lessen the "water hammer" effect caused by predictable backoff techniques - Fixes the logging associated with exponential backoff to log the true reconnect delay value
2022-06-25 23:19:48 +00:00
output->reconnect_retry_cur_msec =
output->reconnect_retry_sec * 1000;
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
output->reconnect_retries = 0;
libobs: Use exponential backoff for reconnecting Implements exponential backoff for consecutive reconnects, which is useful to prevent too many connections from trying to reconnect back to a service at once over a short period of time in the case of potential service downtime. Exponential backoff causes each subsequent reconnect attempt to double its timeout duration.
2015-05-10 23:07:22 +00:00
}
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
if (output->reconnect_retries >= output->reconnect_retry_max) {
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
output->stop_code = OBS_OUTPUT_DISCONNECTED;
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
os_atomic_set_bool(&output->reconnecting, false);
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
if (delay_active(output))
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
os_atomic_set_bool(&output->delay_active, false);
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
obs_output_end_data_capture(output);
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
return;
}
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
if (!reconnecting(output)) {
os_atomic_set_bool(&output->reconnecting, true);
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
os_event_reset(output->reconnect_stop_event);
}
libobs: Use exponential backoff for reconnecting Implements exponential backoff for consecutive reconnects, which is useful to prevent too many connections from trying to reconnect back to a service at once over a short period of time in the case of potential service downtime. Exponential backoff causes each subsequent reconnect attempt to double its timeout duration.
2015-05-10 23:07:22 +00:00
if (output->reconnect_retries) {
libobs: Fix warnings about type usage
2022-06-26 07:28:00 +00:00
output->reconnect_retry_cur_msec =
(uint32_t)(output->reconnect_retry_cur_msec *
output->reconnect_retry_exp);
if (output->reconnect_retry_cur_msec >
RECONNECT_RETRY_MAX_MSEC) {
libobs: Improve exponential backoff functionality - Changes the default base exponent value to 1.5 from 2.0 - Applies a random skew of +-0.05 to the exponent to lessen the "water hammer" effect caused by predictable backoff techniques - Fixes the logging associated with exponential backoff to log the true reconnect delay value
2022-06-25 23:19:48 +00:00
output->reconnect_retry_cur_msec =
RECONNECT_RETRY_MAX_MSEC;
libobs: Fix warnings about type usage
2022-06-26 07:28:00 +00:00
}
libobs: Use exponential backoff for reconnecting Implements exponential backoff for consecutive reconnects, which is useful to prevent too many connections from trying to reconnect back to a service at once over a short period of time in the case of potential service downtime. Exponential backoff causes each subsequent reconnect attempt to double its timeout duration.
2015-05-10 23:07:22 +00:00
}
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
output->reconnect_retries++;
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
output->stop_code = OBS_OUTPUT_DISCONNECTED;
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
ret = pthread_create(&output->reconnect_thread, NULL, &reconnect_thread,
output);
if (ret < 0) {
blog(LOG_WARNING, "Failed to create reconnect thread");
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
os_atomic_set_bool(&output->reconnecting, false);
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
} else {
libobs: Remove extra space in output reconnect log message It has been bothering me to no end.
2023-01-16 06:59:59 +00:00
blog(LOG_INFO, "Output '%s': Reconnecting in %.02f seconds..",
libobs: Improve exponential backoff functionality - Changes the default base exponent value to 1.5 from 2.0 - Applies a random skew of +-0.05 to the exponent to lessen the "water hammer" effect caused by predictable backoff techniques - Fixes the logging associated with exponential backoff to log the true reconnect delay value
2022-06-25 23:19:48 +00:00
output->context.name,
(float)(output->reconnect_retry_cur_msec / 1000.0));
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
signal_reconnect(output);
}
}
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
static inline bool can_reconnect(const obs_output_t *output, int code)
{
bool reconnect_active = output->reconnect_retry_max != 0;
return (reconnecting(output) && code != OBS_OUTPUT_SUCCESS) ||
(reconnect_active && code == OBS_OUTPUT_DISCONNECTED);
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-26 00:44:05 +00:00
void obs_output_signal_stop(obs_output_t *output, int code)
Add preliminary FLV/RTMP output (incomplete) - obs-outputs module: Add preliminary code to send out data, and add an FLV muxer. This time we don't really need to build the packets ourselves, we can just use the FLV muxer and send it directly to RTMP_Write and it should automatically parse the entire stream for us without us having to do much manual code at all. We'll see how it goes. - libobs: Add AVC NAL packet parsing code - libobs/media-io: Add quick helper functions for audio/video to get the width/height/fps/samplerate/etc rather than having to query the info structures each time. - libobs (obs-output.c): Change 'connect' signal to 'start' and 'stop' signals. 'start' now specifies an error code rather than whether it simply failed, that way the client can actually know *why* a failure occurred. Added those error codes to obs-defs.h. - libobs: Add a few functions to duplicate/free encoder packets
2014-04-01 18:55:18 +00:00
{
libobs: Add null debug messages for base obs funcs
2015-10-17 09:51:13 +00:00
if (!obs_output_valid(output, "obs_output_signal_stop"))
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
return;
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
output->stop_code = code;
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
if (can_reconnect(output, code)) {
if (delay_active(output))
os_atomic_inc_long(&output->delay_restart_refs);
obs_output_end_data_capture_internal(output, false);
Implement reconnecting The core itself now provides reconnection options (enabled by default, 2 second timeout between reconnects, 20 retries max until actual disconnection occurs). This will make things easier for both module developers and UI developers. Reconnecting treats the stream as though it were still active, and signals are sent when reconnecting and upon successful reconnection. Need to implement user interface information for reconnections.
2014-07-02 23:38:29 +00:00
output_reconnect(output);
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
} else {
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
if (delay_active(output))
libobs: Use atomics for certain output boolean variables
2016-06-20 23:07:29 +00:00
os_atomic_set_bool(&output->delay_active, false);
(API Change) libobs: Fix output data cutoff on stop (Note: This commit also modifies obs-ffmpeg and obs-outputs) API Changed: obs_output_info::void (*stop)(void *data); To: obs_output_info::void (*stop)(void *data, uint64_t ts); This fixes the long-time design flaw where obs_output_stop and the output 'stop' callback would just shut down the output without considering the timing of when obs_output_stop was used, discarding any possible buffering and causing the output to get cut off at an unexpected timing. The 'stop' callback of obs_output_info now takes a timestamp with the expectation that the output will use that timestamp to stop output data in accordance to that timing. obs_output_stop now records the timestamp at the time that the function is called and calls the 'stop' callback with that timestamp. If needed, obs_output_force_stop will still stop the output immediately without buffering.
2016-06-11 18:42:29 +00:00
obs_output_end_data_capture(output);
libobs: Add encoded output delay support This feature allows a user to delay an output (as long as the output itself supports it). Needless to say this intended for live streams, where users may want to delay their streams to prevent stream sniping, cheating, and other such things. The design this time was a bit more elaborate, but still simple in design: the user can now schedule stops/starts without having to wait for the stream itself to stop before being able to take any action. Optionally, they can also forcibly stop stream (and delay) in case something happens which they might not want to be streamed. Additionally, a new option was added to preserve stream cutoff point on disconnections/reconnections, so that if you get disconnected while streaming, when it reconnects, it will reconnect right at the point where it left off. This will probably be quite useful for a number of applications in addition to regular delay, such as setting the delay to 1 second and then using this feature to minimize, for example, a critical stream such as a tournament stream from getting any of its stream data cut off. However, using this feature will of course cause the stream data to buffer and increase delay (and memory usage) while it's in the process of reconnecting.
2015-09-06 22:39:46 +00:00
}
Implement encoder usage with outputs - Make it so that encoders can be assigned to outputs. If an encoder is destroyed, it will automatically remove itself from that output. I specifically didn't want to do reference counting because it leaves too much potential for unchecked references and it just felt like it would be more trouble than it's worth. - Add a 'flags' value to the output definition structure. This lets the output specify if it uses video/audio, and whether the output is meant to be used with OBS encoders or not. - Remove boilerplate code for outputs. This makes it easier to program outputs. The boilerplate code involved before was mostly just involving connecting to the audio/video data streams directly in each output plugin. Instead of doing that, simply add plugin callback functions for receiving video/audio (either encoded or non-encoded, whichever it's set to use), and then call obs_output_begin_data_capture and obs_output_end_data_capture to automatically handle setting up connections to raw or encoded video/audio streams for the plugin. - Remove 'active' function from output callbacks, as it's no longer really needed now that the libobs output context automatically knows when the output is active or not. - Make it so that an encoder cannot be destroyed until all data connections to the encoder have been removed. - Change the 'start' and 'stop' functions in the encoder interface to just an 'initialize' callback, which initializes the encoder. - Make it so that the encoder must be initialized first before the data stream can be started. The reason why initialization was separated from starting the encoder stream was because we need to be able to check that the settings used with the encoder *can* be used first. This problem was especially annoying if you had both video/audio encoding. Before, you'd have to check the return value from obs_encoder_start, and if that second encoder fails, then you basically had to stop the first encoder again, making for unnecessary boilerplate code whenever starting up two encoders.
2014-03-28 04:50:15 +00:00
}
(API Change) libobs: Make obs_output refcounted
2015-05-03 23:55:43 +00:00
void obs_output_addref(obs_output_t *output)
{
if (!output)
return;
libobs: Add obs_object abstraction and functions With this, you can now cast normal obs objects (services, outputs, sources, encoders) to an obs_object_t, and then use obs_object_* functions to get references, release references, and similar for weak object references as well. This allows the ability for the frontend to use an object of any of those types interchangeably in certain situations without having to handle each specific type individually. This is useful because the properties view in particular doesn't care what type of object it uses, it just needs to be able to hold weak references to abstract OBS objects.
2022-02-03 05:56:30 +00:00
obs_ref_addref(&output->context.control->ref);
(API Change) libobs: Make obs_output refcounted
2015-05-03 23:55:43 +00:00
}
void obs_output_release(obs_output_t *output)
{
if (!output)
return;
libobs: Add obs_object abstraction and functions With this, you can now cast normal obs objects (services, outputs, sources, encoders) to an obs_object_t, and then use obs_object_* functions to get references, release references, and similar for weak object references as well. This allows the ability for the frontend to use an object of any of those types interchangeably in certain situations without having to handle each specific type individually. This is useful because the properties view in particular doesn't care what type of object it uses, it just needs to be able to hold weak references to abstract OBS objects.
2022-02-03 05:56:30 +00:00
obs_weak_output_t *control = get_weak(output);
(API Change) libobs: Make obs_output refcounted
2015-05-03 23:55:43 +00:00
if (obs_ref_release(&control->ref)) {
// The order of operations is important here since
// get_context_by_name in obs.c relies on weak refs
// being alive while the context is listed
obs_output_destroy(output);
obs_weak_output_release(control);
}
}
void obs_weak_output_addref(obs_weak_output_t *weak)
{
if (!weak)
return;
obs_weak_ref_addref(&weak->ref);
}
void obs_weak_output_release(obs_weak_output_t *weak)
{
if (!weak)
return;
if (obs_weak_ref_release(&weak->ref))
bfree(weak);
}
obs_output_t *obs_output_get_ref(obs_output_t *output)
{
if (!output)
return NULL;
libobs: Add obs_object abstraction and functions With this, you can now cast normal obs objects (services, outputs, sources, encoders) to an obs_object_t, and then use obs_object_* functions to get references, release references, and similar for weak object references as well. This allows the ability for the frontend to use an object of any of those types interchangeably in certain situations without having to handle each specific type individually. This is useful because the properties view in particular doesn't care what type of object it uses, it just needs to be able to hold weak references to abstract OBS objects.
2022-02-03 05:56:30 +00:00
return obs_weak_output_get_output(get_weak(output));
(API Change) libobs: Make obs_output refcounted
2015-05-03 23:55:43 +00:00
}
obs_weak_output_t *obs_output_get_weak_output(obs_output_t *output)
{
if (!output)
return NULL;
libobs: Add obs_object abstraction and functions With this, you can now cast normal obs objects (services, outputs, sources, encoders) to an obs_object_t, and then use obs_object_* functions to get references, release references, and similar for weak object references as well. This allows the ability for the frontend to use an object of any of those types interchangeably in certain situations without having to handle each specific type individually. This is useful because the properties view in particular doesn't care what type of object it uses, it just needs to be able to hold weak references to abstract OBS objects.
2022-02-03 05:56:30 +00:00
obs_weak_output_t *weak = get_weak(output);
(API Change) libobs: Make obs_output refcounted
2015-05-03 23:55:43 +00:00
obs_weak_output_addref(weak);
return weak;
}
obs_output_t *obs_weak_output_get_output(obs_weak_output_t *weak)
{
if (!weak)
return NULL;
if (obs_weak_ref_get_ref(&weak->ref))
return weak->output;
return NULL;
}
bool obs_weak_output_references_output(obs_weak_output_t *weak,
obs_output_t *output)
{
return weak && output && weak->output == output;
}
libobs: Add functions to get private type data The private type data is the type_data variable that's provided when object types are registered by plugins.
2015-09-16 05:51:37 +00:00
void *obs_output_get_type_data(obs_output_t *output)
{
return obs_output_valid(output, "obs_output_get_type_data")
? output->info.type_data
: NULL;
}
libobs: Add API to get object ids
2015-10-19 22:01:25 +00:00
const char *obs_output_get_id(const obs_output_t *output)
{
return obs_output_valid(output, "obs_output_get_id") ? output->info.id
: NULL;
}
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
decklink: Add ability to ingest/embed cea 708 captions (This commit also modifies libobs, UI)
2019-08-26 22:58:20 +00:00
void obs_output_caption(obs_output_t *output,
const struct obs_source_cea_708 *captions)
{
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
for (int i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
struct caption_track_data *ctrack = output->caption_tracks[i];
if (!ctrack) {
continue;
}
pthread_mutex_lock(&ctrack->caption_mutex);
for (size_t i = 0; i < captions->packets; i++) {
deque_push_back(&ctrack->caption_data,
captions->data + (i * 3),
3 * sizeof(uint8_t));
}
pthread_mutex_unlock(&ctrack->caption_mutex);
decklink: Add ability to ingest/embed cea 708 captions (This commit also modifies libobs, UI)
2019-08-26 22:58:20 +00:00
}
}
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
static struct caption_text *caption_text_new(const char *text, size_t bytes,
libobs: Add minimum display duration to caption data Adds display_duration declaring the minimum duration a caption text is not going to be overwritten by a new one. To keep the functions backwards-compatible obs_output_output_caption_text2 was added while obs_output_output_caption_text1 continues having a 2 second default.
2019-02-20 04:33:33 +00:00
struct caption_text *tail,
struct caption_text **head,
double display_duration)
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
{
struct caption_text *next = bzalloc(sizeof(struct caption_text));
cmake, libobs, win-capture: Fix VS2017 warnings
2018-03-12 23:16:38 +00:00
snprintf(&next->text[0], CAPTION_LINE_BYTES + 1, "%.*s", (int)bytes,
text);
libobs: Add minimum display duration to caption data Adds display_duration declaring the minimum duration a caption text is not going to be overwritten by a new one. To keep the functions backwards-compatible obs_output_output_caption_text2 was added while obs_output_output_caption_text1 continues having a 2 second default.
2019-02-20 04:33:33 +00:00
next->display_duration = display_duration;
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
if (!*head) {
*head = next;
} else {
tail->next = next;
}
return next;
}
void obs_output_output_caption_text1(obs_output_t *output, const char *text)
{
if (!obs_output_valid(output, "obs_output_output_caption_text1"))
return;
libobs: Add minimum display duration to caption data Adds display_duration declaring the minimum duration a caption text is not going to be overwritten by a new one. To keep the functions backwards-compatible obs_output_output_caption_text2 was added while obs_output_output_caption_text1 continues having a 2 second default.
2019-02-20 04:33:33 +00:00
obs_output_output_caption_text2(output, text, 2.0f);
}
void obs_output_output_caption_text2(obs_output_t *output, const char *text,
double display_duration)
{
if (!obs_output_valid(output, "obs_output_output_caption_text2"))
return;
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
if (!active(output))
return;
Fix various typos across multiple modules
2017-03-19 11:35:51 +00:00
// split text into 32 character strings
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
int size = (int)strlen(text);
blog(LOG_DEBUG, "Caption text: %s", text);
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
struct caption_track_data *ctrack = output->caption_tracks[i];
if (!ctrack) {
continue;
}
pthread_mutex_lock(&ctrack->caption_mutex);
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
ctrack->caption_tail = caption_text_new(text, size,
ctrack->caption_tail,
&ctrack->caption_head,
display_duration);
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
libobs: Insert captions on all video tracks We will now keep a per track list of caption data. When caption insertion is triggered we will add that to the list for each actively encoding video track. When doing interleaved send, we pull the data from the caption data for the corresponding video. This ensures that captions get copied to all video tracks.
2024-03-11 18:53:04 +00:00
pthread_mutex_unlock(&ctrack->caption_mutex);
}
libobs: Add ability to insert captions into frames Uses the libcaption library to allow insertion of caption data directly in to H.264 frame data.
2016-11-17 13:25:23 +00:00
}
libobs: Add ability to get output congestion From 0.0 (not congested) to 1.0 (completely congested/dropping).
2017-01-24 23:30:01 +00:00
float obs_output_get_congestion(obs_output_t *output)
{
if (!obs_output_valid(output, "obs_output_get_congestion"))
return 0;
if (output->info.get_congestion) {
float val = output->info.get_congestion(output->context.data);
if (val < 0.0f)
val = 0.0f;
else if (val > 1.0f)
val = 1.0f;
return val;
}
return 0;
}
libobs: Add function to allow getting output connect time
2017-04-24 10:23:34 +00:00
int obs_output_get_connect_time_ms(obs_output_t *output)
{
if (!obs_output_valid(output, "obs_output_get_connect_time_ms"))
return -1;
if (output->info.get_connect_time_ms)
return output->info.get_connect_time_ms(output->context.data);
return -1;
}
libobs: Add obs_output_reconnecting func Returns whether the output is currently in a state of reconnecting or not.
2017-05-13 05:02:50 +00:00
libobs: Add support for output error messages
2017-05-15 10:04:11 +00:00
const char *obs_output_get_last_error(obs_output_t *output)
{
if (!obs_output_valid(output, "obs_output_get_last_error"))
return NULL;
libobs: Allow last encoder error for last output error (This commit also modifies UI) This makes it more trivial for encoder plugins to communicate to users why specifically an encoder error might have occurred mid-stream.
2021-10-23 12:31:16 +00:00
if (output->last_error_message) {
return output->last_error_message;
} else {
libobs: Add support to obs-outputs for multi video encoders This adds support in outputs to handle multiple video encoders and their interleaving with the encoded audio.
2023-01-17 15:34:13 +00:00
for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) {
obs_encoder_t *vencoder = output->video_encoders[i];
if (vencoder && vencoder->last_error_message) {
return vencoder->last_error_message;
}
libobs: Allow last encoder error for last output error (This commit also modifies UI) This makes it more trivial for encoder plugins to communicate to users why specifically an encoder error might have occurred mid-stream.
2021-10-23 12:31:16 +00:00
}
libobs: Refactor obs-output encoded use of mixes There was quite a bit of conflated usage of mixes (which refers to raw audio) and encoder counts. This fully separates the two and makes a distinct separation when iterating over mixes vs encoders.
2023-01-17 06:48:34 +00:00
for (size_t i = 0; i < MAX_OUTPUT_AUDIO_ENCODERS; i++) {
libobs: Allow last encoder error for last output error (This commit also modifies UI) This makes it more trivial for encoder plugins to communicate to users why specifically an encoder error might have occurred mid-stream.
2021-10-23 12:31:16 +00:00
obs_encoder_t *aencoder = output->audio_encoders[i];
if (aencoder && aencoder->last_error_message) {
return aencoder->last_error_message;
}
}
}
return NULL;
libobs: Add support for output error messages
2017-05-15 10:04:11 +00:00
}
void obs_output_set_last_error(obs_output_t *output, const char *message)
{
if (!obs_output_valid(output, "obs_output_set_last_error"))
return;
if (output->last_error_message)
bfree(output->last_error_message);
if (message)
output->last_error_message = bstrdup(message);
else
output->last_error_message = NULL;
}
libobs: Add obs_output_reconnecting func Returns whether the output is currently in a state of reconnecting or not.
2017-05-13 05:02:50 +00:00
bool obs_output_reconnecting(const obs_output_t *output)
{
if (!obs_output_valid(output, "obs_output_reconnecting"))
return false;
return reconnecting(output);
}
libobs: Add API to specify codec support on encoded outputs (This commit also modifies obs-outputs)
2017-07-13 05:54:04 +00:00
const char *obs_output_get_supported_video_codecs(const obs_output_t *output)
{
return obs_output_valid(output, __FUNCTION__)
? output->info.encoded_video_codecs
: NULL;
}
const char *obs_output_get_supported_audio_codecs(const obs_output_t *output)
{
return obs_output_valid(output, __FUNCTION__)
? output->info.encoded_audio_codecs
: NULL;
}
libobs,docs: Add protocol in Outputs API
2021-08-21 06:51:21 +00:00
const char *obs_output_get_protocols(const obs_output_t *output)
{
if (!obs_output_valid(output, "obs_output_get_protocols"))
return NULL;
libobs: Add sanity checks to some obs_output_t functions Since OBS outputs can have any combination of flags for encoded, video, audio, and service, there are a number of cases where it would be a good idea to validate that we're not allowing output changes that risk undefined behavior given the supported flags. This also does a mild amount of code cleanup, adding inline functions for checking the flags mentioned above.
2023-05-09 04:52:32 +00:00
return flag_service(output) ? output->info.protocols : NULL;
libobs,docs: Add protocol in Outputs API
2021-08-21 06:51:21 +00:00
}
libobs,docs: Add protocol enumeration functions
2022-09-05 12:58:27 +00:00
void obs_enum_output_types_with_protocol(const char *protocol, void *data,
bool (*enum_cb)(void *data,
const char *id))
{
if (!obs_is_output_protocol_registered(protocol))
return;
size_t protocol_len = strlen(protocol);
for (size_t i = 0; i < obs->output_types.num; i++) {
if (!(obs->output_types.array[i].flags & OBS_OUTPUT_SERVICE))
continue;
const char *substr = obs->output_types.array[i].protocols;
while (substr && substr[0] != '\0') {
const char *next = strchr(substr, ';');
size_t len = next ? (size_t)(next - substr)
: strlen(substr);
if (protocol_len == len &&
strncmp(substr, protocol, len) == 0) {
if (!enum_cb(data,
obs->output_types.array[i].id))
return;
}
substr = next ? next + 1 : NULL;
}
}
}
libobs,docs: Add supported codecs functions with output id
2022-09-28 16:18:24 +00:00
const char *obs_get_output_supported_video_codecs(const char *id)
{
const struct obs_output_info *info = find_output(id);
return info ? info->encoded_video_codecs : NULL;
}
const char *obs_get_output_supported_audio_codecs(const char *id)
{
const struct obs_output_info *info = find_output(id);
return info ? info->encoded_audio_codecs : NULL;
}
Reference in a new issue Copy permalink