Output API Reference (obs_output_t)
Outputs allow the ability to output the currently rendering audio/video. Streaming and recording are two common examples of outputs, but not the only types of outputs. Outputs can receive the raw data or receive encoded data. The libobs/obs-output.h file is the dedicated header for implementing outputs
-
type obs_output_t
A reference-counted output object.
-
type obs_weak_output_t
A weak reference to an output object.
#include <obs.h>
Output Definition Structure (obs_output_info)
-
struct obs_output_info
Output definition structure.
-
const char *obs_output_info.id
Unique string identifier for the source (required).
-
uint32_t obs_output_info.flags
Output capability flags (required).
(Author’s note: This should be renamed to “capability_flags”)
A bitwise OR combination of one or more of the following values:
OBS_OUTPUT_VIDEO - Can output video.
OBS_OUTPUT_AUDIO - Can output audio.
OBS_OUTPUT_AV - Combines OBS_OUTPUT_VIDEO and OBS_OUTPUT_AUDIO.
OBS_OUTPUT_ENCODED - Output is encoded.
When this capability flag is used, the output must have encoders assigned to it via the
obs_output_set_video_encoder()
and/orobs_output_set_audio_encoder()
functions in order to be started.OBS_OUTPUT_SERVICE - Output requires a service object.
When this capability flag is used, the output must have a service assigned to it via the
obs_output_set_service()
function in order to be started.This is usually used with live streaming outputs that stream to specific services.
OBS_OUTPUT_MULTI_TRACK - Output supports multiple audio tracks.
When this capability flag is used, specifies that this output supports multiple encoded audio tracks simultaneously.
OBS_OUTPUT_CAN_PAUSE - Output supports pausing.
When this capability flag is used, the output supports pausing. When an output is paused, raw or encoded audio/video data will be halted when paused down to the exact point to the closest video frame. Audio data will be correctly truncated down to the exact audio sample according to that video frame timing.
-
const char *(*obs_output_info.get_name)(void *type_data)
Get the translated name of the output type.
- Param type_data:
The type_data variable of this structure
- Return:
The translated name of the output type
-
void *(*obs_output_info.create)(obs_data_t *settings, obs_output_t *output)
Creates the implementation data for the output.
- Param settings:
Settings to initialize the output with
- Param output:
Output that this data is associated with
- Return:
The implementation data associated with this output
-
void (*obs_output_info.destroy)(void *data)
Destroys the implementation data for the output.
-
bool (*obs_output_info.start)(void *data)
Starts the output. If needed, this function can spawn a thread, return true immediately, and then signal for failure later.
- Return:
true if successful or deferring to a signal to indicate failure, false on failure to start
-
void (*obs_output_info.stop)(void *data, uint64_t ts)
Requests an output to stop at a specified time. The ts parameter indicates when the stop should occur. Output will actually stop when either the
obs_output_end_data_capture()
orobs_output_signal_stop()
functions are called. If ts is 0, an immediate stop was requested.- Param ts:
The timestamp to stop. If 0, the output should attempt to stop immediately rather than wait for any more data to process
-
void (*obs_output_info.raw_video)(void *data, struct video_data *frame)
This is called when the output receives raw video data. Only applies to outputs that are not encoded.
- Param frame:
The raw video frame
-
void (*obs_output_info.raw_audio)(void *data, struct audio_data *frames)
This is called when the output receives raw audio data. Only applies to outputs that are not encoded.
This callback must be used with single-track raw outputs.
- Param frames:
The raw audio frames
-
void (*obs_output_info.raw_audio2)(void *data, size_t idx, struct audio_data *frames)
This is called when the output receives raw audio data. Only applies to outputs that are not encoded.
This callback must be used with multi-track raw outputs.
- Param idx:
The audio track index
- Param frames:
The raw audio frames
-
void (*obs_output_info.encoded_packet)(void *data, struct encoder_packet *packet)
This is called when the output receives encoded video/audio data. Only applies to outputs that are encoded. Packets will always be given in monotonic timestamp order.
- Param packet:
The video or audio packet. If NULL, an encoder error occurred, and the output should call
obs_output_signal_stop()
with the error code OBS_OUTPUT_ENCODE_ERROR.
-
void (*obs_output_info.update)(void *data, obs_data_t *settings)
Updates the settings for this output.
(Optional)
- Param settings:
New settings for this output
-
void (*obs_output_info.get_defaults)(obs_data_t *settings)
-
void (*obs_output_info.get_defaults2)(void *type_data, obs_data_t *settings)
Sets the default settings for this output.
(Optional)
- Param settings:
Default settings. Call obs_data_set_default* functions on this object to set default setting values
-
obs_properties_t *(*obs_output_info.get_properties)(void *data)
-
obs_properties_t *(*obs_output_info.get_properties2)(void *data, void *type_data)
Gets the property information of this output.
(Optional)
- Return:
The properties of the output
-
void (*obs_output_info.unused1)(void *data)
This callback is no longer used.
-
uint64_t (*obs_output_info.get_total_bytes)(void *data)
Returns the number of total bytes processed by this output.
(Optional)
- Return:
Total bytes processed by this output since it started
-
int (*obs_output_info.get_dropped_frames)(void *data)
Returns the number of dropped frames.
(Optional)
- Return:
Number of dropped frames due to network congestion by this output since it started
-
void *obs_output_info.type_data
-
void (*obs_output_info.free_type_data)(void *type_data)
Private data associated with this entry. Note that this is not the same as the implementation data; this is used to differentiate between two different types if the same callbacks are used for more than one different type.
(Optional)
-
float (*obs_output_info.get_congestion)(void *data)
This function is used to indicate how currently congested the output is. Useful for visualizing how much data is backed up on streaming outputs.
(Optional)
- Return:
Current congestion value (0.0f..1.0f)
-
int (*obs_output_info.get_connect_time_ms)(void *data)
This function is used to determine how many milliseconds it took to connect to its current server.
(Optional)
- Return:
Milliseconds it took to connect to its current server
-
const char *obs_output_info.encoded_video_codecs
-
const char *obs_output_info.encoded_audio_codecs
This variable specifies which codecs are supported by an encoded output, separated by semicolon.
Required if OBS_OUTPUT_SERVICE flag is set, otherwise recommended.
-
const char *obs_output_info.protocols
This variable specifies which protocols are supported by an output, separated by semicolon.
Required only if OBS_OUTPUT_SERVICE flag is set.
Added in version 29.1.
Output Signals
start (ptr output)
Called when the output starts.
stop (ptr output, int code)
Called when the output stops.
- Parameters:
code - Can be one of the following values:
OBS_OUTPUT_SUCCESS - Successfully stoppedOBS_OUTPUT_BAD_PATH - The specified path was invalidOBS_OUTPUT_CONNECT_FAILED - Failed to connect to a serverOBS_OUTPUT_INVALID_STREAM - Invalid stream pathOBS_OUTPUT_ERROR - Generic errorOBS_OUTPUT_DISCONNECTED - Unexpectedly disconnectedOBS_OUTPUT_UNSUPPORTED - The settings, video/audio format, or codecs are unsupported by this outputOBS_OUTPUT_NO_SPACE - Ran out of disk spaceOBS_OUTPUT_ENCODE_ERROR - Encoder error
pause (ptr output)
Called when the output has been paused.
unpause (ptr output)
Called when the output has been unpaused.
starting (ptr output)
Called when the output is starting.
stopping (ptr output)
Called when the output is stopping.
activate (ptr output)
Called when the output activates (starts capturing data).
deactivate (ptr output)
Called when the output deactivates (stops capturing data).
reconnect (ptr output)
Called when the output is reconnecting.
reconnect_success (ptr output)
Called when the output has successfully reconnected.
General Output Functions
-
void obs_register_output(struct obs_output_info *info)
Registers an output type. Typically used in
obs_module_load()
or in the program’s initialization phase.
-
const char *obs_output_get_display_name(const char *id)
Calls the
obs_output_info.get_name
callback to get the translated display name of an output type.- Parameters:
id – The output type string identifier
- Returns:
The translated display name of an output type
-
obs_output_t *obs_output_create(const char *id, const char *name, obs_data_t *settings, obs_data_t *hotkey_data)
Creates an output with the specified settings.
The “output” context is used for anything related to outputting the final video/audio mix (E.g. streaming or recording). Use obs_output_release to release it.
- Parameters:
id – The output type string identifier
name – The desired name of the output. If this is not unique, it will be made to be unique
settings – The settings for the output, or NULL if none
hotkey_data – Saved hotkey data for the output, or NULL if none
- Returns:
A reference to the newly created output, or NULL if failed
-
void obs_output_addref(obs_output_t *output)
Adds a reference to an output.
Deprecated since version 27.2.0: Use obs_output_get_ref()
instead.
-
obs_output_t *obs_output_get_ref(obs_output_t *output)
Returns an incremented reference if still valid, otherwise returns NULL. Release with
obs_output_release()
.
-
void obs_output_release(obs_output_t *output)
Releases a reference to an output. When the last reference is released, the output is destroyed.
-
obs_weak_output_t *obs_output_get_weak_output(obs_output_t *output)
-
obs_output_t *obs_weak_output_get_output(obs_weak_output_t *weak)
These functions are used to get a weak reference from a strong output reference, or a strong output reference from a weak reference. If the output is destroyed, obs_weak_output_get_output will return NULL.
-
void obs_weak_output_addref(obs_weak_output_t *weak)
-
void obs_weak_output_release(obs_weak_output_t *weak)
Adds/releases a weak reference to an output.
-
bool obs_weak_output_references_output(obs_weak_output_t *weak, obs_output_t *output)
Compares a weak output reference with an output.
- Returns:
Whether the weak output reference ties back to the specified output
-
const char *obs_output_get_name(const obs_output_t *output)
- Returns:
The name of the output
-
const char *obs_output_get_id(const obs_output_t *output)
- Returns:
The output’s type identifier string
-
bool obs_output_start(obs_output_t *output)
Starts the output.
- Returns:
true if output successfully started, false otherwise. If the output failed to start,
obs_output_get_last_error()
may contain a specific error string related to the reason
-
void obs_output_stop(obs_output_t *output)
Requests the output to stop. The output will wait until all data is sent up until the time the call was made, then when the output has successfully stopped, it will send the “stop” signal. See Output Signals for more information on output signals.
-
void obs_output_set_delay(obs_output_t *output, uint32_t delay_sec, uint32_t flags)
Sets the current output delay, in seconds (if the output supports delay)
If delay is currently active, it will set the delay value, but will not affect the current delay, it will only affect the next time the output is activated.
- Parameters:
delay_sec – Amount to delay the output, in seconds
flags –
Can be 0 or a combination of one of the following values:OBS_OUTPUT_DELAY_PRESERVE - On reconnection, start where it left of on reconnection. Note however that this option will consume extra memory to continually increase delay while waiting to reconnect
-
uint32_t obs_output_get_delay(const obs_output_t *output)
Gets the currently set delay value, in seconds.
-
uint32_t obs_output_get_active_delay(const obs_output_t *output)
If delay is active, gets the currently active delay value, in seconds. The active delay can increase if the OBS_OUTPUT_DELAY_PRESERVE flag was set when setting a delay.
-
void obs_output_force_stop(obs_output_t *output)
Attempts to get the output to stop immediately without waiting for data to send.
-
bool obs_output_active(const obs_output_t *output)
- Returns:
true if the output is currently active, false otherwise
-
obs_data_t *obs_output_defaults(const char *id)
- Returns:
An incremented reference to the output’s default settings. Release with
obs_data_release()
.
-
obs_properties_t *obs_output_properties(const obs_output_t *output)
-
obs_properties_t *obs_get_output_properties(const char *id)
Use these functions to get the properties of an output or output type. Properties are optionally used (if desired) to automatically generate user interface widgets to allow users to update settings.
- Returns:
The properties list for a specific existing output. Free with
obs_properties_destroy()
-
void obs_output_update(obs_output_t *output, obs_data_t *settings)
Updates the settings for this output context.
-
bool obs_output_can_pause(const obs_output_t *output)
- Returns:
true if the output can be paused, false otherwise
-
bool obs_output_pause(obs_output_t *output, bool pause)
Pause an output (if supported by the output).
- Returns:
true if the output was paused successfully, false otherwise
-
bool obs_output_paused(const obs_output_t *output)
- Returns:
true if the output is paused, false otherwise
-
obs_data_t *obs_output_get_settings(const obs_output_t *output)
- Returns:
An incremented reference to the output’s settings. Release with
obs_data_release()
.
-
signal_handler_t *obs_output_get_signal_handler(const obs_output_t *output)
- Returns:
The signal handler of the output. Should not be manually freed, as its lifecycle is managed by libobs.
-
proc_handler_t *obs_output_get_proc_handler(const obs_output_t *output)
- Returns:
The procedure handler of the output. Should not be manually freed, as its lifecycle is managed by libobs.
-
void obs_output_set_media(obs_output_t *output, video_t *video, audio_t *audio)
Sets the current video/audio handlers for the output (typically
obs_get_video()
andobs_get_audio()
). Only used with raw outputs so they can catch the raw video/audio frames.
-
video_t *obs_output_video(const obs_output_t *output)
-
audio_t *obs_output_audio(const obs_output_t *output)
Gets the current video/audio handlers for the output.
-
void obs_output_set_mixer(obs_output_t *output, size_t mixer_idx)
-
size_t obs_output_get_mixer(const obs_output_t *output)
Sets/gets the current audio mixer for non-encoded outputs. For multi-track outputs, this would be the equivalent of setting the mask only for the specified mixer index.
-
void obs_output_set_mixers(obs_output_t *output, size_t mixers)
-
size_t obs_output_get_mixers(const obs_output_t *output)
Sets/gets the current audio mixers (via mask) for non-encoded multi-track outputs. If used with single-track outputs, the single-track output will use either the first set mixer track in the bitmask, or the first track if none is set in the bitmask.
-
void obs_output_set_video_encoder(obs_output_t *output, obs_encoder_t *encoder)
-
void obs_output_set_audio_encoder(obs_output_t *output, obs_encoder_t *encoder, size_t idx)
Sets the video/audio encoders for an encoded output.
- Parameters:
encoder – The video/audio encoder
idx – The audio encoder index if the output supports multiple audio streams at once
-
obs_encoder_t *obs_output_get_video_encoder(const obs_output_t *output)
-
obs_encoder_t *obs_output_get_audio_encoder(const obs_output_t *output, size_t idx)
Gets the video/audio encoders for an encoded output.
- Parameters:
idx – The audio encoder index if the output supports multiple audio streams at once
- Returns:
The video/audio encoder. The reference is not incremented
-
void obs_output_set_service(obs_output_t *output, obs_service_t *service)
-
obs_service_t *obs_output_get_service(const obs_output_t *output)
Sets/gets the service for outputs that require services (such as RTMP outputs). obs_output_get_service does not return an incremented reference.
-
void obs_output_set_reconnect_settings(obs_output_t *output, int retry_count, int retry_sec);
Sets the auto-reconnect settings for outputs that support it. The retry time will double on each retry to prevent overloading services.
- Parameters:
retry_count – Maximum retry count. Set to 0 to disable reconnecting
retry_sec – Starting retry wait duration, in seconds
-
uint64_t obs_output_get_total_bytes(const obs_output_t *output)
- Returns:
Total bytes sent/processed
-
int obs_output_get_frames_dropped(const obs_output_t *output)
- Returns:
Number of frames that were dropped due to network congestion
-
int obs_output_get_total_frames(const obs_output_t *output)
- Returns:
Total frames sent/processed
-
void obs_output_set_preferred_size(obs_output_t *output, uint32_t width, uint32_t height)
Sets the preferred scaled resolution for this output. Set width and height to 0 to disable scaling.
If this output uses an encoder, it will call obs_encoder_set_scaled_size on the encoder before the stream is started. If the encoder is already active, then this function will trigger a warning and do nothing.
-
uint32_t obs_output_get_width(const obs_output_t *output)
-
uint32_t obs_output_get_height(const obs_output_t *output)
- Returns:
The width/height of the output
Outputs captions from the specified text input. text1 is the same as text2, except that the display_duration is hardcoded to 2.0 seconds.
display_duration represents the minimum quantity of time that a given caption can be displayed for before moving onto the next caption in the queue.
-
float obs_output_get_congestion(obs_output_t *output)
- Returns:
The congestion value. This value is used to visualize the current congestion of a network output. For example, if there is no congestion, the value will be 0.0f, if it’s fully congested, the value will be 1.0f
-
int obs_output_get_connect_time_ms(obs_output_t *output)
- Returns:
How long the output took to connect to a server, in milliseconds
-
bool obs_output_reconnecting(const obs_output_t *output)
- Returns:
true if the output is currently reconnecting to a server, false otherwise
-
const char *obs_output_get_supported_video_codecs(const obs_output_t *output)
-
const char *obs_get_output_supported_video_codecs(const char *id)
-
const char *obs_output_get_supported_audio_codecs(const obs_output_t *output)
-
const char *obs_get_output_supported_audio_codecs(const char *id)
- Returns:
Supported video/audio codecs of an encoded output, separated by semicolon
Added in version 29.1:
obs_get_output_supported_video_codecs()
andobs_get_output_supported_audio_codecs()
-
uint32_t obs_output_get_flags(const obs_output_t *output)
-
uint32_t obs_get_output_flags(const char *id)
- Returns:
The output capability flags
-
const char *obs_output_get_protocols(const obs_output_t *output)
- Returns:
Supported protocols, separated by semicolon. Always NULL if the output is not OBS_OUTPUT_SERVICE.
Added in version 29.1.
-
bool obs_is_output_protocol_registered(const char *protocol)
Check if one of the registered output use the given protocol.
- Returns:
A boolean showing if an output with the given protocol is registered
Added in version 29.1.
-
bool obs_enum_output_protocols(size_t idx, char **protocol)
Enumerates all registered protocol.
Added in version 29.1.
-
void obs_enum_output_types_with_protocol(const char *protocol, void *data, bool (*enum_cb)(void *data, const char *id))
Enumerates through a callback all available output types for the given protocol.
- Parameters:
protocol – Protocol of the outputs to enumerate
data – Data passed to the callback
enum_cb – Callback used when a matching output is found, the id of the output is passed to the callback
- Returns:
When all outputs are enumerated or if the callback return false
Added in version 29.1.
Functions used by outputs
-
void obs_output_set_last_error(obs_output_t *output, const char *message)
-
const char *obs_output_get_last_error(obs_output_t *output)
Sets/gets the translated error message that is presented to a user in case of disconnection, inability to connect, etc.
-
void obs_output_set_video_conversion(obs_output_t *output, const struct video_scale_info *conversion)
-
const struct video_scale_info *obs_output_get_video_conversion(obs_output_t *output)
Optionally sets/gets the video conversion information. Only used by raw outputs.
Added in version 29.1:
obs_output_get_video_conversion()
Relevant data types used with this function:
enum video_format {
VIDEO_FORMAT_NONE,
/* planar 4:2:0 formats */
VIDEO_FORMAT_I420, /* three-plane */
VIDEO_FORMAT_NV12, /* two-plane, luma and packed chroma */
/* packed 4:2:2 formats */
VIDEO_FORMAT_YVYU,
VIDEO_FORMAT_YUY2, /* YUYV */
VIDEO_FORMAT_UYVY,
/* packed uncompressed formats */
VIDEO_FORMAT_RGBA,
VIDEO_FORMAT_BGRA,
VIDEO_FORMAT_BGRX,
VIDEO_FORMAT_Y800, /* grayscale */
/* planar 4:4:4 */
VIDEO_FORMAT_I444,
/* more packed uncompressed formats */
VIDEO_FORMAT_BGR3,
/* planar 4:2:2 */
VIDEO_FORMAT_I422,
/* planar 4:2:0 with alpha */
VIDEO_FORMAT_I40A,
/* planar 4:2:2 with alpha */
VIDEO_FORMAT_I42A,
/* planar 4:4:4 with alpha */
VIDEO_FORMAT_YUVA,
/* packed 4:4:4 with alpha */
VIDEO_FORMAT_AYUV,
/* planar 4:2:0 format, 10 bpp */
VIDEO_FORMAT_I010, /* three-plane */
VIDEO_FORMAT_P010, /* two-plane, luma and packed chroma */
/* planar 4:2:2 format, 10 bpp */
VIDEO_FORMAT_I210,
/* planar 4:4:4 format, 12 bpp */
VIDEO_FORMAT_I412,
/* planar 4:4:4:4 format, 12 bpp */
VIDEO_FORMAT_YA2L,
/* planar 4:2:2 format, 16 bpp */
VIDEO_FORMAT_P216, /* two-plane, luma and packed chroma */
/* planar 4:4:4 format, 16 bpp */
VIDEO_FORMAT_P416, /* two-plane, luma and packed chroma */
/* packed 4:2:2 format, 10 bpp */
VIDEO_FORMAT_V210,
/* packed uncompressed 10-bit format */
VIDEO_FORMAT_R10L,
};
enum video_colorspace {
VIDEO_CS_DEFAULT,
VIDEO_CS_601,
VIDEO_CS_709,
VIDEO_CS_SRGB,
VIDEO_CS_2100_PQ,
VIDEO_CS_2100_HLG,
};
enum video_range_type {
VIDEO_RANGE_DEFAULT,
VIDEO_RANGE_PARTIAL,
VIDEO_RANGE_FULL
};
struct video_scale_info {
enum video_format format;
uint32_t width;
uint32_t height;
enum video_range_type range;
enum video_colorspace colorspace;
};
-
void obs_output_set_audio_conversion(obs_output_t *output, const struct audio_convert_info *conversion)
Optionally sets the audio conversion information. Only used by raw outputs.
Relevant data types used with this function:
enum audio_format {
AUDIO_FORMAT_UNKNOWN,
AUDIO_FORMAT_U8BIT,
AUDIO_FORMAT_16BIT,
AUDIO_FORMAT_32BIT,
AUDIO_FORMAT_FLOAT,
AUDIO_FORMAT_U8BIT_PLANAR,
AUDIO_FORMAT_16BIT_PLANAR,
AUDIO_FORMAT_32BIT_PLANAR,
AUDIO_FORMAT_FLOAT_PLANAR,
};
enum speaker_layout {
SPEAKERS_UNKNOWN,
SPEAKERS_MONO,
SPEAKERS_STEREO,
SPEAKERS_2POINT1,
SPEAKERS_4POINT0,
SPEAKERS_4POINT1,
SPEAKERS_5POINT1,
SPEAKERS_5POINT1_SURROUND,
SPEAKERS_7POINT1,
SPEAKERS_7POINT1_SURROUND,
SPEAKERS_SURROUND,
};
struct audio_convert_info {
uint32_t samples_per_sec;
enum audio_format format;
enum speaker_layout speakers;
};
-
bool obs_output_can_begin_data_capture(const obs_output_t *output, int flags)
Determines whether video/audio capture (encoded or raw) is able to start. Call this before initializing any output state to ensure that the output can start.
- Parameters:
output – The output
flags – Reserved. Set this to 0.
- Returns:
true if data capture can begin
-
bool obs_output_initialize_encoders(obs_output_t *output, int flags)
Initializes any encoders/services associated with the output. This must be called for encoded outputs before calling
obs_output_begin_data_capture()
.- Parameters:
output – The output
flags – Reserved. Set this to 0.
- Returns:
true if successful, false otherwise
-
bool obs_output_begin_data_capture(obs_output_t *output, int flags)
Begins data capture from raw media or encoders. This is typically when the output actually activates (starts) internally. Video/audio data will start being sent to the callbacks of the output.
- Parameters:
output – The output
flags – Reserved. Set this to 0.
- Returns:
true if successful, false otherwise. Typically the return value does not need to be checked if
obs_output_can_begin_data_capture2()
was called
-
void obs_output_end_data_capture(obs_output_t *output)
Ends data capture of an output. This is typically when the output actually intentionally deactivates (stops). Video/audio data will stop being sent to the callbacks of the output. The output will trigger the “stop” signal with the OBS_OUTPUT_SUCCESS code to indicate that the output has stopped successfully. See Output Signals for more information on output signals.
-
void obs_output_signal_stop(obs_output_t *output, int code)
Ends data capture of an output with an output code, indicating that the output stopped unexpectedly. This is typically used if for example the server was disconnected for some reason, or if there was an error saving to file. The output will trigger the “stop” signal with the the desired code to indicate that the output has stopped successfully. See Output Signals for more information on output signals.
obs_output_set_last_error()
may be used in conjunction with these error codes to optionally relay more detailed error information to the user- Parameters:
code –
Can be one of the following values:OBS_OUTPUT_SUCCESS - Successfully stoppedOBS_OUTPUT_BAD_PATH - The specified path was invalidOBS_OUTPUT_CONNECT_FAILED - Failed to connect to a serverOBS_OUTPUT_INVALID_STREAM - Invalid stream pathOBS_OUTPUT_ERROR - Generic errorOBS_OUTPUT_DISCONNECTED - Unexpectedly disconnectedOBS_OUTPUT_UNSUPPORTED - The settings, video/audio format, or codecs are unsupported by this outputOBS_OUTPUT_NO_SPACE - Ran out of disk space
-
uint64_t obs_output_get_pause_offset(obs_output_t *output)
Returns the current pause offset of the output. Used with raw outputs to calculate system timestamps when using calculated timestamps (see FFmpeg output for an example).