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/or obs_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() or obs_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 stopped

OBS_OUTPUT_BAD_PATH - The specified path was invalid

OBS_OUTPUT_CONNECT_FAILED - Failed to connect to a server

OBS_OUTPUT_INVALID_STREAM - Invalid stream path

OBS_OUTPUT_ERROR - Generic error

OBS_OUTPUT_DISCONNECTED - Unexpectedly disconnected

OBS_OUTPUT_UNSUPPORTED - The settings, video/audio format, or codecs are unsupported by this output

OBS_OUTPUT_NO_SPACE - Ran out of disk space

OBS_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

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() and obs_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

void obs_output_output_caption_text1(obs_output_t *output, const char *text)

void obs_output_output_caption_text2(obs_output_t *output, const char *text, double display_duration)

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() and obs_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.

void obs_output_add_packet_callback(obs_output_t *output, void (*packet_cb)(obs_output_t *output,

struct encoder_packet *pkt, struct encoder_packet_time *pkt_time, void *param), void *param)

Register a packet callback function for the output. The callback is invoked for each compressed packet just before sending to the service. This packet callback mechanism is the preferred method for all packet-level processing that is not required to be implemented in libobs. Any reallocation of the packet buffer, if necessary, must be done with functions in libobsutilbmem.h, otherwise a memory leak may occur. Never use memset() to clear the packet buffer, as the buffer data is needed for subsequent callback processing.

Parameters:

output – The output to register the packet_cb() function against
packet_cb – Function pointer to the callback function
param – Data passed to the callback

Returns:

When the callback is added

packet_cb() arguments: :param output: The output associated with the invoked callback function :param pkt: Compressed data packet (audio or video) :param pkt_time: encoder_packet_time structure associated with the data packet :param param: Data passed to the callback

Added in version 31.0.

void obs_output_remove_packet_callback(obs_output_t *output, void (*packet_cb)(obs_output_t *output,

struct encoder_packet *pkt, struct encoder_packet_time *pkt_time, void *param), void *param)

Remove a packet callback function for the output, that had been previously registered with obs_output_add_packet_callback().

Parameters:

output – The output to remove the packet_cb() function against
packet_cb – Function pointer to the callback function
param – Data passed to the callback

Returns:

When the callback is removed

Added in version 31.0.

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 stopped

OBS_OUTPUT_BAD_PATH - The specified path was invalid

OBS_OUTPUT_CONNECT_FAILED - Failed to connect to a server

OBS_OUTPUT_INVALID_STREAM - Invalid stream path

OBS_OUTPUT_ERROR - Generic error

OBS_OUTPUT_DISCONNECTED - Unexpectedly disconnected

OBS_OUTPUT_UNSUPPORTED - The settings, video/audio format, or codecs are unsupported by this output

OBS_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).