mirror/obs-studio
0
0
Fork 0
mirror of https://github.com/obsproject/obs-studio.git synced 2024-09-19 20:32:15 +02:00
Code
3c7b1c8297
obs-studio/UI/window-basic-main-outputs.cpp

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

2125 lines
61 KiB
C++
Raw Normal View History

UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
#include <string>
UI: Allow directories in file formatting settings When configuring file formatting settings in advanced, allow the ability to specify formatted directories. For example, "%CCYY-%MM/%DD %hh-%mm-%ss" would make the year and month a subdirectory, then the day/hour/minute/seconds as the file name. January 21st 2121 at 4pm would end up being: "21 04-00-00.mp4" in the subdirectory "2121-01".
2016-07-05 08:11:24 +02:00
#include <algorithm>
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
#include <QMessageBox>
UI: Make sure all message box buttons are translated Instead of QMessageBox::question and QMessageBox::information, use the OBSMessageBox class, which translates all buttons.
2017-05-13 23:06:32 +02:00
#include "qt-wrappers.hpp"
UI: Create best matching audio encoder for given bitrate
2015-07-02 10:00:22 +02:00
#include "audio-encoders.hpp"
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
#include "window-basic-main.hpp"
#include "window-basic-main-outputs.hpp"
UI: Add Virtual Camera source selector dialog
2022-07-19 18:32:39 +02:00
#include "window-basic-vcam-config.hpp"
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
using namespace std;
UI: Use new NVENC by default in simple output mode If the new texture-based NVENC implementation is available, uses it by default when a user is using simple output mode.
2019-02-06 03:22:40 +01:00
extern bool EncoderAvailable(const char *encoder);
UI: Make workaround for Logitech plugin hard lock In commit d17ee20863, we attempted to fix a race condition crash in the Logitech plugin by deferring the "stream/recording/replay buffer active" calls to the UI thread. However, the Logitech plugin loop_function funciton can call obs_frontend_streaming_active/etc functions while the UI thread waits for the loop_function thread for many OBS events, causing a hard lock in the Logitech plugin. This fixes that by making the obs_frontend_streaming_active/etc functions completely atomic instead. It's a bit of a hack but it's better than accessing objects.
2019-02-26 15:37:01 +01:00
volatile bool streaming_active = false;
volatile bool recording_active = false;
UI: Add pause support Adds support for pausing recordings. When settings are eligible for recordings, a pause button will appear next to the recording button. If the settings are not eligible, it will warn the user in the output settings that they cannot pause recordings if those settings are used.
2019-07-08 00:47:29 +02:00
volatile bool recording_paused = false;
UI: Make workaround for Logitech plugin hard lock In commit d17ee20863, we attempted to fix a race condition crash in the Logitech plugin by deferring the "stream/recording/replay buffer active" calls to the UI thread. However, the Logitech plugin loop_function funciton can call obs_frontend_streaming_active/etc functions while the UI thread waits for the loop_function thread for many OBS events, causing a hard lock in the Logitech plugin. This fixes that by making the obs_frontend_streaming_active/etc functions completely atomic instead. It's a bit of a hack but it's better than accessing objects.
2019-02-26 15:37:01 +01:00
volatile bool replaybuf_active = false;
UI: Add virtual camera to UI Adds a virtual camera button to the main user interface. If virtual camera is not installed, it will not add the button. On Windows, it detects whether the virtual camera filters are properly registered, and will only add the button if the virtual camera filter is confirmed registered. Also adds a virtual camera option to the auto-configuration wizard, which will just simply set the user's resolution/scale to 1920x1080 at 30 FPS.
2020-06-20 16:42:14 +02:00
volatile bool virtualcam_active = false;
UI: Make workaround for Logitech plugin hard lock In commit d17ee20863, we attempted to fix a race condition crash in the Logitech plugin by deferring the "stream/recording/replay buffer active" calls to the UI thread. However, the Logitech plugin loop_function funciton can call obs_frontend_streaming_active/etc functions while the UI thread waits for the loop_function thread for many OBS events, causing a hard lock in the Logitech plugin. This fixes that by making the obs_frontend_streaming_active/etc functions completely atomic instead. It's a bit of a hack but it's better than accessing objects.
2019-02-26 15:37:01 +01:00
UI: Support FTL URLs for custom streaming service Custom streaming service URLs beginning with `ftl` are handled by the `ftl_output` plugin.
2020-12-06 10:54:29 +01:00
#define FTL_PROTOCOL "ftl"
UI: Use new ffmpeg-encoded-output for non-RTMP urls
2019-04-19 20:58:31 +02:00
#define RTMP_PROTOCOL "rtmp"
UI: Implement stream delay When stream delay is active, the "Start/Stop Streaming" button is changed in to a menu button, which allows the user to select either the option to stop the stream (which causes it to count down), or forcibly stop the stream (which immediately stops the stream and cuts off all delayed data). If the user decides they want to start the stream again while in the process of counting down, they can safely do so without having to wait for it to stop, and it will schedule it to start up again with the same delay after the stop. On the status bar, it will now show whether delay is active, and its duration. If the stream is in the process of stopping/starting, it will count down to the stop/start. If the option to preserve stream cutoff point on unexpected disconnections/reconnections is enabled, it will update the current delay duration accordingly.
2015-09-07 01:19:53 +02:00
static void OBSStreamStarting(void *data, calldata_t *params)
{
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
obs_output_t *obj = (obs_output_t *)calldata_ptr(params, "output");
int sec = (int)obs_output_get_active_delay(obj);
if (sec == 0)
return;
output->delayActive = true;
QMetaObject::invokeMethod(output->main, "StreamDelayStarting",
Q_ARG(int, sec));
}
static void OBSStreamStopping(void *data, calldata_t *params)
{
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
obs_output_t *obj = (obs_output_t *)calldata_ptr(params, "output");
int sec = (int)obs_output_get_active_delay(obj);
if (sec == 0)
UI: Show "stopping" text on buttons when waiting for stop The new cutoff timing fix means that streaming/recording has to remain active for bit until the stream/recording has reached the expecting stop timestamp. This means that the buttons would continue to say "Stop streaming/recording" while waiting for the output to stop itself at the appropriate timing. So instead of letting it do that and confusing the user, the buttons will now say "stopping" when the button is pressed to indicate to the user that the stream/recording is in the process of stopping.
2016-06-22 10:47:08 +02:00
QMetaObject::invokeMethod(output->main, "StreamStopping");
else
QMetaObject::invokeMethod(output->main, "StreamDelayStopping",
Q_ARG(int, sec));
UI: Implement stream delay When stream delay is active, the "Start/Stop Streaming" button is changed in to a menu button, which allows the user to select either the option to stop the stream (which causes it to count down), or forcibly stop the stream (which immediately stops the stream and cuts off all delayed data). If the user decides they want to start the stream again while in the process of counting down, they can safely do so without having to wait for it to stop, and it will schedule it to start up again with the same delay after the stop. On the status bar, it will now show whether delay is active, and its duration. If the stream is in the process of stopping/starting, it will count down to the stop/start. If the option to preserve stream cutoff point on unexpected disconnections/reconnections is enabled, it will update the current delay duration accordingly.
2015-09-07 01:19:53 +02:00
}
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
static void OBSStartStreaming(void *data, calldata_t *params)
{
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
UI: Don't use activeRefs to determine if active Due to certain design changes for delay, it's better to simply determine whether outputs are active via booleans rather than an activeRefs variable, which could get decremented more than once if say, the signal for stopping the stream gets called more than once for whatever reason (which may happen in the case of delay due to the way delay works)
2015-09-07 01:07:45 +02:00
output->streamingActive = true;
UI: Make workaround for Logitech plugin hard lock In commit d17ee20863, we attempted to fix a race condition crash in the Logitech plugin by deferring the "stream/recording/replay buffer active" calls to the UI thread. However, the Logitech plugin loop_function funciton can call obs_frontend_streaming_active/etc functions while the UI thread waits for the loop_function thread for many OBS events, causing a hard lock in the Logitech plugin. This fixes that by making the obs_frontend_streaming_active/etc functions completely atomic instead. It's a bit of a hack but it's better than accessing objects.
2019-02-26 15:37:01 +01:00
os_atomic_set_bool(&streaming_active, true);
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
QMetaObject::invokeMethod(output->main, "StreamingStart");
UNUSED_PARAMETER(params);
}
static void OBSStopStreaming(void *data, calldata_t *params)
{
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
int code = (int)calldata_int(params, "code");
UI: Add support for showing output error messages
2017-05-15 12:03:00 +02:00
const char *last_error = calldata_string(params, "last_error");
QString arg_last_error = QString::fromUtf8(last_error);
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
UI: Don't use activeRefs to determine if active Due to certain design changes for delay, it's better to simply determine whether outputs are active via booleans rather than an activeRefs variable, which could get decremented more than once if say, the signal for stopping the stream gets called more than once for whatever reason (which may happen in the case of delay due to the way delay works)
2015-09-07 01:07:45 +02:00
output->streamingActive = false;
UI: Implement stream delay When stream delay is active, the "Start/Stop Streaming" button is changed in to a menu button, which allows the user to select either the option to stop the stream (which causes it to count down), or forcibly stop the stream (which immediately stops the stream and cuts off all delayed data). If the user decides they want to start the stream again while in the process of counting down, they can safely do so without having to wait for it to stop, and it will schedule it to start up again with the same delay after the stop. On the status bar, it will now show whether delay is active, and its duration. If the stream is in the process of stopping/starting, it will count down to the stop/start. If the option to preserve stream cutoff point on unexpected disconnections/reconnections is enabled, it will update the current delay duration accordingly.
2015-09-07 01:19:53 +02:00
output->delayActive = false;
UI: Make workaround for Logitech plugin hard lock In commit d17ee20863, we attempted to fix a race condition crash in the Logitech plugin by deferring the "stream/recording/replay buffer active" calls to the UI thread. However, the Logitech plugin loop_function funciton can call obs_frontend_streaming_active/etc functions while the UI thread waits for the loop_function thread for many OBS events, causing a hard lock in the Logitech plugin. This fixes that by making the obs_frontend_streaming_active/etc functions completely atomic instead. It's a bit of a hack but it's better than accessing objects.
2019-02-26 15:37:01 +01:00
os_atomic_set_bool(&streaming_active, false);
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
QMetaObject::invokeMethod(output->main, "StreamingStop",
UI: Update error message severity levels and show additional info
2019-03-30 15:44:44 +01:00
Q_ARG(int, code),
Q_ARG(QString, arg_last_error));
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
}
static void OBSStartRecording(void *data, calldata_t *params)
{
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
UI: Don't use activeRefs to determine if active Due to certain design changes for delay, it's better to simply determine whether outputs are active via booleans rather than an activeRefs variable, which could get decremented more than once if say, the signal for stopping the stream gets called more than once for whatever reason (which may happen in the case of delay due to the way delay works)
2015-09-07 01:07:45 +02:00
output->recordingActive = true;
UI: Make workaround for Logitech plugin hard lock In commit d17ee20863, we attempted to fix a race condition crash in the Logitech plugin by deferring the "stream/recording/replay buffer active" calls to the UI thread. However, the Logitech plugin loop_function funciton can call obs_frontend_streaming_active/etc functions while the UI thread waits for the loop_function thread for many OBS events, causing a hard lock in the Logitech plugin. This fixes that by making the obs_frontend_streaming_active/etc functions completely atomic instead. It's a bit of a hack but it's better than accessing objects.
2019-02-26 15:37:01 +01:00
os_atomic_set_bool(&recording_active, true);
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
QMetaObject::invokeMethod(output->main, "RecordingStart");
UNUSED_PARAMETER(params);
}
static void OBSStopRecording(void *data, calldata_t *params)
{
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
UI: Warn user if recording format unsupported If the recording format is unsupported or doesn't support multiple tracks, warn the user to check their settings.
2015-06-10 06:00:22 +02:00
int code = (int)calldata_int(params, "code");
UI: Update error message severity levels and show additional info
2019-03-30 15:44:44 +01:00
const char *last_error = calldata_string(params, "last_error");
QString arg_last_error = QString::fromUtf8(last_error);
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
UI: Don't use activeRefs to determine if active Due to certain design changes for delay, it's better to simply determine whether outputs are active via booleans rather than an activeRefs variable, which could get decremented more than once if say, the signal for stopping the stream gets called more than once for whatever reason (which may happen in the case of delay due to the way delay works)
2015-09-07 01:07:45 +02:00
output->recordingActive = false;
UI: Make workaround for Logitech plugin hard lock In commit d17ee20863, we attempted to fix a race condition crash in the Logitech plugin by deferring the "stream/recording/replay buffer active" calls to the UI thread. However, the Logitech plugin loop_function funciton can call obs_frontend_streaming_active/etc functions while the UI thread waits for the loop_function thread for many OBS events, causing a hard lock in the Logitech plugin. This fixes that by making the obs_frontend_streaming_active/etc functions completely atomic instead. It's a bit of a hack but it's better than accessing objects.
2019-02-26 15:37:01 +01:00
os_atomic_set_bool(&recording_active, false);
UI: Add pause support Adds support for pausing recordings. When settings are eligible for recordings, a pause button will appear next to the recording button. If the settings are not eligible, it will warn the user in the output settings that they cannot pause recordings if those settings are used.
2019-07-08 00:47:29 +02:00
os_atomic_set_bool(&recording_paused, false);
UI: Warn user if recording format unsupported If the recording format is unsupported or doesn't support multiple tracks, warn the user to check their settings.
2015-06-10 06:00:22 +02:00
QMetaObject::invokeMethod(output->main, "RecordingStop",
UI: Update error message severity levels and show additional info
2019-03-30 15:44:44 +01:00
Q_ARG(int, code),
Q_ARG(QString, arg_last_error));
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
}
UI: Show "stopping" text on buttons when waiting for stop The new cutoff timing fix means that streaming/recording has to remain active for bit until the stream/recording has reached the expecting stop timestamp. This means that the buttons would continue to say "Stop streaming/recording" while waiting for the output to stop itself at the appropriate timing. So instead of letting it do that and confusing the user, the buttons will now say "stopping" when the button is pressed to indicate to the user that the stream/recording is in the process of stopping.
2016-06-22 10:47:08 +02:00
static void OBSRecordStopping(void *data, calldata_t *params)
{
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
QMetaObject::invokeMethod(output->main, "RecordStopping");
UNUSED_PARAMETER(params);
}
UI: Add automatic file splitting This commit implements a new feature to split recordings in split files in Advanced output mode. These basic settings are implemented. - Enable/disable the feature. Default is disabled. - Select a type of the limit, time or size. - Specifies the limit in seconds or MiB.
2021-10-03 12:06:46 +02:00
static void OBSRecordFileChanged(void *data, calldata_t *params)
{
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
const char *next_file = calldata_string(params, "next_file");
QString arg_last_file =
QString::fromUtf8(output->lastRecordingPath.c_str());
QMetaObject::invokeMethod(output->main, "RecordingFileChanged",
Q_ARG(QString, arg_last_file));
output->lastRecordingPath = next_file;
}
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
static void OBSStartReplayBuffer(void *data, calldata_t *params)
{
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
output->replayBufferActive = true;
UI: Make workaround for Logitech plugin hard lock In commit d17ee20863, we attempted to fix a race condition crash in the Logitech plugin by deferring the "stream/recording/replay buffer active" calls to the UI thread. However, the Logitech plugin loop_function funciton can call obs_frontend_streaming_active/etc functions while the UI thread waits for the loop_function thread for many OBS events, causing a hard lock in the Logitech plugin. This fixes that by making the obs_frontend_streaming_active/etc functions completely atomic instead. It's a bit of a hack but it's better than accessing objects.
2019-02-26 15:37:01 +01:00
os_atomic_set_bool(&replaybuf_active, true);
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
QMetaObject::invokeMethod(output->main, "ReplayBufferStart");
UNUSED_PARAMETER(params);
}
static void OBSStopReplayBuffer(void *data, calldata_t *params)
{
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
int code = (int)calldata_int(params, "code");
output->replayBufferActive = false;
UI: Make workaround for Logitech plugin hard lock In commit d17ee20863, we attempted to fix a race condition crash in the Logitech plugin by deferring the "stream/recording/replay buffer active" calls to the UI thread. However, the Logitech plugin loop_function funciton can call obs_frontend_streaming_active/etc functions while the UI thread waits for the loop_function thread for many OBS events, causing a hard lock in the Logitech plugin. This fixes that by making the obs_frontend_streaming_active/etc functions completely atomic instead. It's a bit of a hack but it's better than accessing objects.
2019-02-26 15:37:01 +01:00
os_atomic_set_bool(&replaybuf_active, false);
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
QMetaObject::invokeMethod(output->main, "ReplayBufferStop",
Q_ARG(int, code));
}
static void OBSReplayBufferStopping(void *data, calldata_t *params)
{
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
QMetaObject::invokeMethod(output->main, "ReplayBufferStopping");
UNUSED_PARAMETER(params);
}
UI: Fix replay buffer frontend event not triggering The frontend API event OBS_FRONTEND_EVENT_REPLAY_BUFFER_SAVED was not being triggered when hotkeys were used because it was only set to trigger when the replay buffer button was clicked, not when a hotkey was used. This fixes it so that the frontend event sends a signal to the frontend so that hotkeys will actually work.
2020-10-13 01:55:01 +02:00
static void OBSReplayBufferSaved(void *data, calldata_t *)
{
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
QMetaObject::invokeMethod(output->main, "ReplayBufferSaved",
Qt::QueuedConnection);
}
UI: Add virtual camera to UI Adds a virtual camera button to the main user interface. If virtual camera is not installed, it will not add the button. On Windows, it detects whether the virtual camera filters are properly registered, and will only add the button if the virtual camera filter is confirmed registered. Also adds a virtual camera option to the auto-configuration wizard, which will just simply set the user's resolution/scale to 1920x1080 at 30 FPS.
2020-06-20 16:42:14 +02:00
static void OBSStartVirtualCam(void *data, calldata_t *params)
{
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
output->virtualCamActive = true;
os_atomic_set_bool(&virtualcam_active, true);
QMetaObject::invokeMethod(output->main, "OnVirtualCamStart");
UNUSED_PARAMETER(params);
}
static void OBSStopVirtualCam(void *data, calldata_t *params)
{
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
int code = (int)calldata_int(params, "code");
output->virtualCamActive = false;
os_atomic_set_bool(&virtualcam_active, false);
QMetaObject::invokeMethod(output->main, "OnVirtualCamStop",
Q_ARG(int, code));
UI: Add Virtual Camera source selector dialog
2022-07-19 18:32:39 +02:00
obs_output_set_media(output->virtualCam, nullptr, nullptr);
OBSBasicVCamConfig::StopVideo();
UI: Add virtual camera to UI Adds a virtual camera button to the main user interface. If virtual camera is not installed, it will not add the button. On Windows, it detects whether the virtual camera filters are properly registered, and will only add the button if the virtual camera filter is confirmed registered. Also adds a virtual camera option to the auto-configuration wizard, which will just simply set the user's resolution/scale to 1920x1080 at 30 FPS.
2020-06-20 16:42:14 +02:00
}
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
/* ------------------------------------------------------------------------ */
UI: Create best matching audio encoder for given bitrate
2015-07-02 10:00:22 +02:00
static bool CreateAACEncoder(OBSEncoder &res, string &id, int bitrate,
const char *name, size_t idx)
UI: Move AAC encoder creation
2015-06-06 01:52:22 +02:00
{
UI: Create best matching audio encoder for given bitrate
2015-07-02 10:00:22 +02:00
const char *id_ = GetAACEncoderForBitrate(bitrate);
if (!id_) {
id.clear();
res = nullptr;
return false;
UI: Move AAC encoder creation
2015-06-06 01:52:22 +02:00
}
UI: Create best matching audio encoder for given bitrate
2015-07-02 10:00:22 +02:00
if (id == id_)
return true;
id = id_;
res = obs_audio_encoder_create(id_, name, nullptr, idx, nullptr);
if (res) {
obs_encoder_release(res);
return true;
}
return false;
UI: Move AAC encoder creation
2015-06-06 01:52:22 +02:00
}
/* ------------------------------------------------------------------------ */
UI: Add virtual camera to UI Adds a virtual camera button to the main user interface. If virtual camera is not installed, it will not add the button. On Windows, it detects whether the virtual camera filters are properly registered, and will only add the button if the virtual camera filter is confirmed registered. Also adds a virtual camera option to the auto-configuration wizard, which will just simply set the user's resolution/scale to 1920x1080 at 30 FPS.
2020-06-20 16:42:14 +02:00
inline BasicOutputHandler::BasicOutputHandler(OBSBasic *main_) : main(main_)
{
if (main->vcamEnabled) {
virtualCam = obs_output_create("virtualcam_output",
"virtualcam_output", nullptr,
nullptr);
signal_handler_t *signal =
obs_output_get_signal_handler(virtualCam);
startVirtualCam.Connect(signal, "start", OBSStartVirtualCam,
this);
stopVirtualCam.Connect(signal, "stop", OBSStopVirtualCam, this);
}
}
bool BasicOutputHandler::StartVirtualCam()
{
if (main->vcamEnabled) {
UI: Add Virtual Camera source selector dialog
2022-07-19 18:32:39 +02:00
video_t *video = OBSBasicVCamConfig::StartVideo();
if (!video)
return false;
obs_output_set_media(virtualCam, video, obs_get_audio());
UI: Make SetupOutputs virtual instead of ignoring vcam In 218b936b1dae, the virtual camera was ignored when checking the active state, which is kind of a lackluster solution. Instead, this makes SetupOutputs() a virtual function, and calls it before starting the virtual camera to be more consistent with the rest of the outputs.
2020-09-03 15:56:03 +02:00
if (!Active())
SetupOutputs();
UI: Fix memory leak when virtualcam fails to start
2022-08-11 07:28:27 +02:00
bool success = obs_output_start(virtualCam);
if (!success)
OBSBasicVCamConfig::StopVideo();
return success;
UI: Add virtual camera to UI Adds a virtual camera button to the main user interface. If virtual camera is not installed, it will not add the button. On Windows, it detects whether the virtual camera filters are properly registered, and will only add the button if the virtual camera filter is confirmed registered. Also adds a virtual camera option to the auto-configuration wizard, which will just simply set the user's resolution/scale to 1920x1080 at 30 FPS.
2020-06-20 16:42:14 +02:00
}
return false;
}
void BasicOutputHandler::StopVirtualCam()
{
if (main->vcamEnabled) {
obs_output_stop(virtualCam);
}
}
bool BasicOutputHandler::VirtualCamActive() const
{
if (main->vcamEnabled) {
return obs_output_active(virtualCam);
}
return false;
}
/* ------------------------------------------------------------------------ */
UI: Move AAC encoder creation
2015-06-06 01:52:22 +02:00
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
struct SimpleOutput : BasicOutputHandler {
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
OBSEncoder aacStreaming;
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
OBSEncoder videoStreaming;
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
OBSEncoder aacRecording;
UI: Add Twitch VOD track to simple output mode Allows the ability to use the separated Twitch VOD track with simple output mode in addition to advanced output mode.
2020-11-14 17:05:52 +01:00
OBSEncoder aacArchive;
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
OBSEncoder videoRecording;
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
string aacRecEncID;
string aacStreamEncID;
UI: Add Twitch VOD track to simple output mode Allows the ability to use the separated Twitch VOD track with simple output mode in addition to advanced output mode.
2020-11-14 17:05:52 +01:00
string aacArchiveEncID;
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
string videoEncoder;
string videoQuality;
bool usingRecordingPreset = false;
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
bool recordingConfigured = false;
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
bool ffmpegOutput = false;
bool lowCPUx264 = false;
UI: Create best matching audio encoder for given bitrate
2015-07-02 10:00:22 +02:00
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
SimpleOutput(OBSBasic *main_);
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
int CalcCRF(int crf);
void UpdateRecordingSettings_x264_crf(int crf);
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
void UpdateRecordingSettings_qsv11(int crf);
UI: Use CQP for NVENC when using simple output mode When using simple output mode, previously NVENC did not support a constant quality rate control method, and you'd have to use VBR with bitrate. However CQP has since been added to NVENC, and it's preferable to use for recording when available instead of using VBR.
2016-05-08 20:21:37 +02:00
void UpdateRecordingSettings_nvenc(int cqp);
UI: Add NVENC AV1 to simple output mode
2022-09-19 10:55:19 +02:00
void UpdateRecordingSettings_nvenc_hevc_av1(int cqp);
UI: Implement simple output mode presets for AMD Closes jp9000/obs-studio#630
2016-09-27 01:29:33 +02:00
void UpdateRecordingSettings_amd_cqp(int cqp);
UI: Add Apple H.264 hardware encoder to simple mode Adds the Apple Silicon hardware encoder as a simple mode option. For recordings this only requires being on Apple Silicon (since we use the Constant Quality setting), while for streaming it requires the user to be on macOS 13 or newer (since we're using CBR).
2022-06-23 02:46:03 +02:00
void UpdateRecordingSettings_apple(int quality);
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
void UpdateRecordingSettings();
void UpdateRecordingAudioSettings();
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
virtual void Update() override;
UI: Make SetupOutputs virtual instead of ignoring vcam In 218b936b1dae, the virtual camera was ignored when checking the active state, which is kind of a lackluster solution. Instead, this makes SetupOutputs() a virtual function, and calls it before starting the virtual camera to be more consistent with the rest of the outputs.
2020-09-03 15:56:03 +02:00
void SetupOutputs() override;
UI: Move output handler audio bitrate config access
2015-07-02 09:58:28 +02:00
int GetAudioBitrate() const;
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
void LoadRecordingPreset_Lossy(const char *encoder);
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
void LoadRecordingPreset_Lossless();
void LoadRecordingPreset();
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
void LoadStreamingPreset_Lossy(const char *encoder);
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
void UpdateRecording();
bool ConfigureRecording(bool useReplayBuffer);
UI: Add Twitch VOD track to simple output mode Allows the ability to use the separated Twitch VOD track with simple output mode in addition to advanced output mode.
2020-11-14 17:05:52 +01:00
void SetupVodTrack(obs_service_t *service);
UI: Create output before calling start stream event Allows modifying the output OBS_FRONTEND_EVENT_STREAMING_STARTING.
2020-09-17 07:20:02 +02:00
virtual bool SetupStreaming(obs_service_t *service) override;
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
virtual bool StartStreaming(obs_service_t *service) override;
virtual bool StartRecording() override;
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
virtual bool StartReplayBuffer() override;
UI: Add ability to forcibly stop streams/recordings If the user hits the "stop stream" button it'll transition in to "stopping stream..." and will continue to output until the stream reaches the timing in which "stop" was pressed. However, if there is significant congestion, stopping the stream can take far longer than the user may like. So there needs to be an option to forcibly stop the stream in that case; pushing the "stop" button a second time should allow the user to tell the stream/recording to stop right away instead of waiting for the precise stop timing.
2016-09-09 16:37:54 +02:00
virtual void StopStreaming(bool force) override;
virtual void StopRecording(bool force) override;
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
virtual void StopReplayBuffer(bool force) override;
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
virtual bool StreamingActive() const override;
virtual bool RecordingActive() const override;
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
virtual bool ReplayBufferActive() const override;
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
};
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
void SimpleOutput::LoadRecordingPreset_Lossless()
{
fileOutput = obs_output_create("ffmpeg_output", "simple_ffmpeg_output",
nullptr, nullptr);
if (!fileOutput)
throw "Failed to create recording FFmpeg output "
"(simple output)";
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease settings = obs_data_create();
Revert "UI: Use flac for lossless audio" This reverts commit 6e20310945ad181938b6e096f2af0b13bb1f97d6. FLAC doesn't work properly in AVI files, and MKV files don't work in vegas. So, sadly the only solution is to use lossless audio at a super high bitrate for the time being.
2016-02-10 03:46:15 +01:00
obs_data_set_string(settings, "format_name", "avi");
UI: Use utvideo for lossless compression After some more testing, utvideo not only gives better encoding performance, but also better compression and better decoding performance. It's pretty much superior all around over huffyuv.
2015-09-20 06:21:34 +02:00
obs_data_set_string(settings, "video_encoder", "utvideo");
UI: Use uncompressed audio for lossless Originally there was an issue using FLAC for audio in AVI files, AVI files wouldn't play back with some players. Because FLAC doesn't work, and lossless should be lossless, instead just used uncompressed WAV data for the lossless audio, which is always supported.
2016-02-10 04:24:44 +01:00
obs_data_set_string(settings, "audio_encoder", "pcm_s16le");
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
UI: Fix audio recording for lossless simple (#1616) The first audio track was not recorded following the API changes for custom ffmpeg recording (adding multi-track support). This fixes the issue (spotted by EposVox, thanks to him for the report).
2019-01-31 05:58:22 +01:00
int aMixes = 1;
obs_output_set_mixers(fileOutput, aMixes);
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
obs_output_update(fileOutput, settings);
}
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
void SimpleOutput::LoadRecordingPreset_Lossy(const char *encoderId)
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
{
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
videoRecording = obs_video_encoder_create(
encoderId, "simple_video_recording", nullptr, nullptr);
if (!videoRecording)
throw "Failed to create video recording encoder (simple output)";
obs_encoder_release(videoRecording);
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
}
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
void SimpleOutput::LoadStreamingPreset_Lossy(const char *encoderId)
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
{
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
videoStreaming = obs_video_encoder_create(
encoderId, "simple_video_stream", nullptr, nullptr);
if (!videoStreaming)
throw "Failed to create video streaming encoder (simple output)";
obs_encoder_release(videoStreaming);
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
}
UI: Refactor simple encoders to a func
2022-07-24 05:52:14 +02:00
/* mistakes have been made to lead us to this. */
const char *get_simple_output_encoder(const char *encoder)
{
if (strcmp(encoder, SIMPLE_ENCODER_X264) == 0) {
return "obs_x264";
} else if (strcmp(encoder, SIMPLE_ENCODER_X264_LOWCPU) == 0) {
return "obs_x264";
} else if (strcmp(encoder, SIMPLE_ENCODER_QSV) == 0) {
return "obs_qsv11";
} else if (strcmp(encoder, SIMPLE_ENCODER_AMD) == 0) {
return "h264_texture_amf";
#ifdef ENABLE_HEVC
} else if (strcmp(encoder, SIMPLE_ENCODER_AMD_HEVC) == 0) {
return "h265_texture_amf";
#endif
} else if (strcmp(encoder, SIMPLE_ENCODER_NVENC) == 0) {
return EncoderAvailable("jim_nvenc") ? "jim_nvenc"
: "ffmpeg_nvenc";
#ifdef ENABLE_HEVC
} else if (strcmp(encoder, SIMPLE_ENCODER_NVENC_HEVC) == 0) {
return EncoderAvailable("jim_hevc_nvenc") ? "jim_hevc_nvenc"
: "ffmpeg_hevc_nvenc";
#endif
UI: Add NVENC AV1 to simple output mode
2022-09-19 10:55:19 +02:00
} else if (strcmp(encoder, SIMPLE_ENCODER_NVENC_AV1) == 0) {
return "jim_av1_nvenc";
UI: Refactor simple encoders to a func
2022-07-24 05:52:14 +02:00
} else if (strcmp(encoder, SIMPLE_ENCODER_APPLE_H264) == 0) {
return "com.apple.videotoolbox.videoencoder.ave.avc";
}
return "obs_x264";
}
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
void SimpleOutput::LoadRecordingPreset()
{
const char *quality =
config_get_string(main->Config(), "SimpleOutput", "RecQuality");
const char *encoder =
config_get_string(main->Config(), "SimpleOutput", "RecEncoder");
videoEncoder = encoder;
videoQuality = quality;
ffmpegOutput = false;
if (strcmp(quality, "Stream") == 0) {
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
videoRecording = videoStreaming;
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
aacRecording = aacStreaming;
usingRecordingPreset = false;
return;
} else if (strcmp(quality, "Lossless") == 0) {
LoadRecordingPreset_Lossless();
usingRecordingPreset = true;
ffmpegOutput = true;
return;
} else {
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
lowCPUx264 = false;
UI: Refactor simple encoders to a func
2022-07-24 05:52:14 +02:00
if (strcmp(encoder, SIMPLE_ENCODER_X264_LOWCPU) == 0)
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
lowCPUx264 = true;
UI: Refactor simple encoders to a func
2022-07-24 05:52:14 +02:00
LoadRecordingPreset_Lossy(get_simple_output_encoder(encoder));
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
usingRecordingPreset = true;
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
if (!CreateAACEncoder(aacRecording, aacRecEncID, 192,
"simple_aac_recording", 0))
throw "Failed to create aac recording encoder "
"(simple output)";
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
}
}
UI: Fix vod track not working with twitch soundtrack The vod track in advanced output mode would be overwritten by twitch soundtrack's vod track. Additionally, simple output mode would overwrite twitch's soundtrack vod track even when vod track was turned off in settings. So instead, if vod track is off, don't clear the secondary encoder unless it's explicitly our encoder. Additionally, make sure that advanced output mode's vod track encoder behaves consistently with simple output mode's vod track so it doesn't get overwritten.
2020-12-03 09:59:43 +01:00
#define SIMPLE_ARCHIVE_NAME "simple_archive_aac"
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
SimpleOutput::SimpleOutput(OBSBasic *main_) : BasicOutputHandler(main_)
{
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
const char *encoder = config_get_string(main->Config(), "SimpleOutput",
"StreamEncoder");
UI: Use new NVENC by default in simple output mode If the new texture-based NVENC implementation is available, uses it by default when a user is using simple output mode.
2019-02-06 03:22:40 +01:00
UI: Refactor simple encoders to a func
2022-07-24 05:52:14 +02:00
LoadStreamingPreset_Lossy(get_simple_output_encoder(encoder));
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
if (!CreateAACEncoder(aacStreaming, aacStreamEncID, GetAudioBitrate(),
UI: Create best matching audio encoder for given bitrate
2015-07-02 10:00:22 +02:00
"simple_aac", 0))
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
throw "Failed to create aac streaming encoder (simple output)";
UI: Add Twitch VOD track to simple output mode Allows the ability to use the separated Twitch VOD track with simple output mode in addition to advanced output mode.
2020-11-14 17:05:52 +01:00
if (!CreateAACEncoder(aacArchive, aacArchiveEncID, GetAudioBitrate(),
UI: Fix vod track not working with twitch soundtrack The vod track in advanced output mode would be overwritten by twitch soundtrack's vod track. Additionally, simple output mode would overwrite twitch's soundtrack vod track even when vod track was turned off in settings. So instead, if vod track is off, don't clear the secondary encoder unless it's explicitly our encoder. Additionally, make sure that advanced output mode's vod track encoder behaves consistently with simple output mode's vod track so it doesn't get overwritten.
2020-12-03 09:59:43 +01:00
SIMPLE_ARCHIVE_NAME, 1))
UI: Add Twitch VOD track to simple output mode Allows the ability to use the separated Twitch VOD track with simple output mode in addition to advanced output mode.
2020-11-14 17:05:52 +01:00
throw "Failed to create aac arhive encoder (simple output)";
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
LoadRecordingPreset();
if (!ffmpegOutput) {
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
bool useReplayBuffer = config_get_bool(main->Config(),
UI: Add replay buffer options to simple output mode
2016-12-07 14:21:44 +01:00
"SimpleOutput", "RecRB");
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
if (useReplayBuffer) {
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease hotkey;
UI: Add replay buffer options to simple output mode
2016-12-07 14:21:44 +01:00
const char *str = config_get_string(
main->Config(), "Hotkeys", "ReplayBuffer");
UI: Don't try to load replay buffer hotkey if null If replay buffer hotkey isn't set, this would cause an error to be logged due to a null string.
2020-06-18 23:43:52 +02:00
if (str)
hotkey = obs_data_create_from_json(str);
else
hotkey = nullptr;
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
replayBuffer = obs_output_create("replay_buffer",
UI: Add replay buffer options to simple output mode
2016-12-07 14:21:44 +01:00
Str("ReplayBuffer"),
nullptr, hotkey);
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
if (!replayBuffer)
throw "Failed to create replay buffer output "
"(simple output)";
signal_handler_t *signal =
obs_output_get_signal_handler(replayBuffer);
startReplayBuffer.Connect(signal, "start",
OBSStartReplayBuffer, this);
stopReplayBuffer.Connect(signal, "stop",
OBSStopReplayBuffer, this);
replayBufferStopping.Connect(signal, "stopping",
OBSReplayBufferStopping,
this);
UI: Fix replay buffer frontend event not triggering The frontend API event OBS_FRONTEND_EVENT_REPLAY_BUFFER_SAVED was not being triggered when hotkeys were used because it was only set to trigger when the replay buffer button was clicked, not when a hotkey was used. This fixes it so that the frontend event sends a signal to the frontend so that hotkeys will actually work.
2020-10-13 01:55:01 +02:00
replayBufferSaved.Connect(signal, "saved",
OBSReplayBufferSaved, this);
UI: Add replay buffer options to simple output mode
2016-12-07 14:21:44 +01:00
}
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
fileOutput = obs_output_create(
"ffmpeg_muxer", "simple_file_output", nullptr, nullptr);
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
if (!fileOutput)
throw "Failed to create recording output "
"(simple output)";
}
UI: Release recording/streaming signals before outputs
2015-07-04 08:00:21 +02:00
startRecording.Connect(obs_output_get_signal_handler(fileOutput),
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
"start", OBSStartRecording, this);
UI: Release recording/streaming signals before outputs
2015-07-04 08:00:21 +02:00
stopRecording.Connect(obs_output_get_signal_handler(fileOutput), "stop",
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
OBSStopRecording, this);
UI: Show "stopping" text on buttons when waiting for stop The new cutoff timing fix means that streaming/recording has to remain active for bit until the stream/recording has reached the expecting stop timestamp. This means that the buttons would continue to say "Stop streaming/recording" while waiting for the output to stop itself at the appropriate timing. So instead of letting it do that and confusing the user, the buttons will now say "stopping" when the button is pressed to indicate to the user that the stream/recording is in the process of stopping.
2016-06-22 10:47:08 +02:00
recordStopping.Connect(obs_output_get_signal_handler(fileOutput),
"stopping", OBSRecordStopping, this);
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
}
UI: Move output handler audio bitrate config access
2015-07-02 09:58:28 +02:00
int SimpleOutput::GetAudioBitrate() const
{
UI: If audio bitrate not available, use closest When an encoder has been removed (such as CoreAudio) and the audio bitrates currently configured no longer are available to the current audio encoders anymore, it would cause GetAACEncoderForBitrate to return false with no encoder available. To fix the issue, instead just choose the closest bitrate relative to the current bitrate (rounded up).
2015-09-22 03:36:26 +02:00
int bitrate = (int)config_get_uint(main->Config(), "SimpleOutput",
"ABitrate");
return FindClosestAvailableAACBitrate(bitrate);
UI: Move output handler audio bitrate config access
2015-07-02 09:58:28 +02:00
}
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
void SimpleOutput::Update()
{
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
OBSDataAutoRelease videoSettings = obs_data_create();
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease aacSettings = obs_data_create();
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
int videoBitrate =
config_get_uint(main->Config(), "SimpleOutput", "VBitrate");
UI: Move output handler audio bitrate config access
2015-07-02 09:58:28 +02:00
int audioBitrate = GetAudioBitrate();
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
bool advanced =
config_get_bool(main->Config(), "SimpleOutput", "UseAdvanced");
UI: Move "enforce" setting to "ignore" stream section Moves the "Enforce streaming service bitrate" option from simple output mode to the stream section, renames it to "Ignore streaming service setting recommendations" (inverting it). When trying to check it, it will now also display a message box warning the user that it's generally a not-so-good idea. Also displays recommended settings for the service.
2020-11-11 18:48:39 +01:00
bool enforceBitrate = !config_get_bool(main->Config(), "Stream1",
"IgnoreRecommended");
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
const char *custom = config_get_string(main->Config(), "SimpleOutput",
"x264Settings");
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
const char *encoder = config_get_string(main->Config(), "SimpleOutput",
"StreamEncoder");
const char *presetType;
const char *preset;
UI: Implement simple output mode presets for AMD Closes jp9000/obs-studio#630
2016-09-27 01:29:33 +02:00
if (strcmp(encoder, SIMPLE_ENCODER_QSV) == 0) {
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
presetType = "QSVPreset";
UI: Implement simple output mode presets for AMD Closes jp9000/obs-studio#630
2016-09-27 01:29:33 +02:00
} else if (strcmp(encoder, SIMPLE_ENCODER_AMD) == 0) {
presetType = "AMDPreset";
UI: Update simple output to use new AMD encoder
2022-07-21 22:02:21 +02:00
#ifdef ENABLE_HEVC
} else if (strcmp(encoder, SIMPLE_ENCODER_AMD_HEVC) == 0) {
presetType = "AMDPreset";
#endif
UI: Implement simple output mode presets for AMD Closes jp9000/obs-studio#630
2016-09-27 01:29:33 +02:00
} else if (strcmp(encoder, SIMPLE_ENCODER_NVENC) == 0) {
UI: Add NVENC support to simple output
2016-04-19 01:12:59 +02:00
presetType = "NVENCPreset";
UI: Implement simple output mode presets for AMD Closes jp9000/obs-studio#630
2016-09-27 01:29:33 +02:00
UI: Simple Output Mode for NVENC HEVC
2022-05-19 06:53:37 +02:00
#ifdef ENABLE_HEVC
} else if (strcmp(encoder, SIMPLE_ENCODER_NVENC_HEVC) == 0) {
presetType = "NVENCPreset";
#endif
UI: Add NVENC AV1 to simple output mode
2022-09-19 10:55:19 +02:00
} else if (strcmp(encoder, SIMPLE_ENCODER_NVENC_AV1) == 0) {
presetType = "NVENCPreset";
UI: Implement simple output mode presets for AMD Closes jp9000/obs-studio#630
2016-09-27 01:29:33 +02:00
} else {
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
presetType = "Preset";
UI: Implement simple output mode presets for AMD Closes jp9000/obs-studio#630
2016-09-27 01:29:33 +02:00
}
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
preset = config_get_string(main->Config(), "SimpleOutput", presetType);
UI: Move Simple Mode encoder preset out of Advanced
2022-06-25 19:24:04 +02:00
obs_data_set_string(videoSettings, "preset", preset);
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_data_set_string(videoSettings, "rate_control", "CBR");
obs_data_set_int(videoSettings, "bitrate", videoBitrate);
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
UI: Move Simple Mode encoder preset out of Advanced
2022-06-25 19:24:04 +02:00
if (advanced)
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_data_set_string(videoSettings, "x264opts", custom);
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
UI: Use "rate_control" instead of deprecated "cbr" For setting CBR on encoders, use "rate_control" set to "CBR" instead of setting the "cbr" setting (which is now deprecated) to true.
2016-05-08 20:20:51 +02:00
obs_data_set_string(aacSettings, "rate_control", "CBR");
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
obs_data_set_int(aacSettings, "bitrate", audioBitrate);
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_service_apply_encoder_settings(main->GetService(), videoSettings,
(API Change) Fix "apply service settings" functions API changed from: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); void obs_service_info::apply_encoder_settings(void *data obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); To: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); void obs_service_info::apply_encoder_settings(void *data obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); These changes make it so that instead of an encoder potentially being updated more than once with different settings, that these functions will be called for the specific settings being used, and the settings will be updated according to what's required by the service. This fixes that design flaw and ensures that there's no case where obs_encoder_update is called where the settings might not have service-specific settings applied.
2015-03-08 01:32:00 +01:00
aacSettings);
UI: Move "enforce" setting to "ignore" stream section Moves the "Enforce streaming service bitrate" option from simple output mode to the stream section, renames it to "Ignore streaming service setting recommendations" (inverting it). When trying to check it, it will now also display a message box warning the user that it's generally a not-so-good idea. Also displays recommended settings for the service.
2020-11-11 18:48:39 +01:00
if (!enforceBitrate) {
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_data_set_int(videoSettings, "bitrate", videoBitrate);
UI: Fix audio bitrate unlock if bitrate enforcing off Fixes a bug where audio bitrate would not be unlocked if maximum bitrate enforcement is disabled.
2016-04-11 07:53:42 +02:00
obs_data_set_int(aacSettings, "bitrate", audioBitrate);
}
UI: Add "Enforce streaming bitrate limits" setting Allows the user to disable streaming bitrate limits in simple output mode if they so choose. This option is enabled by default.
2016-04-10 12:10:36 +02:00
UI: Ensure NV12/I420 format for streaming encoder Due to the fact that flash cannot decode formats such as YUV 4:4:4, do not allow the streaming encoders to use formats other than NV12/I420.
2015-04-17 11:48:06 +02:00
video_t *video = obs_get_video();
enum video_format format = video_output_get_format(video);
UI: Do not prefer NV12 for I010/P010 Can cause videos to save as 8-bit.
2022-04-29 18:45:56 +02:00
switch (format) {
case VIDEO_FORMAT_I420:
case VIDEO_FORMAT_NV12:
case VIDEO_FORMAT_I010:
case VIDEO_FORMAT_P010:
break;
default:
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_encoder_set_preferred_video_format(videoStreaming,
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
VIDEO_FORMAT_NV12);
UI: Do not prefer NV12 for I010/P010 Can cause videos to save as 8-bit.
2022-04-29 18:45:56 +02:00
}
UI: Ensure NV12/I420 format for streaming encoder Due to the fact that flash cannot decode formats such as YUV 4:4:4, do not allow the streaming encoders to use formats other than NV12/I420.
2015-04-17 11:48:06 +02:00
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_encoder_update(videoStreaming, videoSettings);
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
obs_encoder_update(aacStreaming, aacSettings);
UI: Add Twitch VOD track to simple output mode Allows the ability to use the separated Twitch VOD track with simple output mode in addition to advanced output mode.
2020-11-14 17:05:52 +01:00
obs_encoder_update(aacArchive, aacSettings);
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
}
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
void SimpleOutput::UpdateRecordingAudioSettings()
{
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease settings = obs_data_create();
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
obs_data_set_int(settings, "bitrate", 192);
UI: Use "rate_control" instead of deprecated "cbr" For setting CBR on encoders, use "rate_control" set to "CBR" instead of setting the "cbr" setting (which is now deprecated) to true.
2016-05-08 20:20:51 +02:00
obs_data_set_string(settings, "rate_control", "CBR");
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
obs_encoder_update(aacRecording, settings);
}
#define CROSS_DIST_CUTOFF 2000.0
int SimpleOutput::CalcCRF(int crf)
{
int cx = config_get_uint(main->Config(), "Video", "OutputCX");
int cy = config_get_uint(main->Config(), "Video", "OutputCY");
double fCX = double(cx);
double fCY = double(cy);
if (lowCPUx264)
crf -= 2;
double crossDist = sqrt(fCX * fCX + fCY * fCY);
double crfResReduction =
fmin(CROSS_DIST_CUTOFF, crossDist) / CROSS_DIST_CUTOFF;
crfResReduction = (1.0 - crfResReduction) * 10.0;
return crf - int(crfResReduction);
}
void SimpleOutput::UpdateRecordingSettings_x264_crf(int crf)
{
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease settings = obs_data_create();
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
obs_data_set_int(settings, "crf", crf);
obs_data_set_bool(settings, "use_bufsize", true);
UI: Use "rate_control" instead of deprecated "cbr" For setting CBR on encoders, use "rate_control" set to "CBR" instead of setting the "cbr" setting (which is now deprecated) to true.
2016-05-08 20:20:51 +02:00
obs_data_set_string(settings, "rate_control", "CRF");
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
obs_data_set_string(settings, "profile", "high");
obs_data_set_string(settings, "preset",
lowCPUx264 ? "ultrafast" : "veryfast");
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_encoder_update(videoRecording, settings);
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
}
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
static bool icq_available(obs_encoder_t *encoder)
{
obs_properties_t *props = obs_encoder_properties(encoder);
obs_property_t *p = obs_properties_get(props, "rate_control");
bool icq_found = false;
size_t num = obs_property_list_item_count(p);
for (size_t i = 0; i < num; i++) {
const char *val = obs_property_list_item_string(p, i);
UI: Use regular ICQ for simple output mode QSV After testing, LA_ICQ may not always be supported, so use regular ICQ for recordings instead. Also fixes a bug where simple output mode wouldn't even use LA_ICQ.
2016-05-11 22:19:38 +02:00
if (strcmp(val, "ICQ") == 0) {
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
icq_found = true;
break;
}
}
obs_properties_destroy(props);
return icq_found;
}
void SimpleOutput::UpdateRecordingSettings_qsv11(int crf)
{
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
bool icq = icq_available(videoRecording);
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease settings = obs_data_create();
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
obs_data_set_string(settings, "profile", "high");
if (icq) {
UI: Use regular ICQ for simple output mode QSV After testing, LA_ICQ may not always be supported, so use regular ICQ for recordings instead. Also fixes a bug where simple output mode wouldn't even use LA_ICQ.
2016-05-11 22:19:38 +02:00
obs_data_set_string(settings, "rate_control", "ICQ");
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
obs_data_set_int(settings, "icq_quality", crf);
} else {
obs_data_set_string(settings, "rate_control", "CQP");
obs_data_set_int(settings, "qpi", crf);
obs_data_set_int(settings, "qpp", crf);
obs_data_set_int(settings, "qpb", crf);
}
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_encoder_update(videoRecording, settings);
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
}
UI: Use CQP for NVENC when using simple output mode When using simple output mode, previously NVENC did not support a constant quality rate control method, and you'd have to use VBR with bitrate. However CQP has since been added to NVENC, and it's preferable to use for recording when available instead of using VBR.
2016-05-08 20:21:37 +02:00
void SimpleOutput::UpdateRecordingSettings_nvenc(int cqp)
UI: Add NVENC support to simple output
2016-04-19 01:12:59 +02:00
{
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease settings = obs_data_create();
UI: Use CQP for NVENC when using simple output mode When using simple output mode, previously NVENC did not support a constant quality rate control method, and you'd have to use VBR with bitrate. However CQP has since been added to NVENC, and it's preferable to use for recording when available instead of using VBR.
2016-05-08 20:21:37 +02:00
obs_data_set_string(settings, "rate_control", "CQP");
UI: Add NVENC support to simple output
2016-04-19 01:12:59 +02:00
obs_data_set_string(settings, "profile", "high");
UI: Use CQP for NVENC when using simple output mode When using simple output mode, previously NVENC did not support a constant quality rate control method, and you'd have to use VBR with bitrate. However CQP has since been added to NVENC, and it's preferable to use for recording when available instead of using VBR.
2016-05-08 20:21:37 +02:00
obs_data_set_int(settings, "cqp", cqp);
UI: Add NVENC support to simple output
2016-04-19 01:12:59 +02:00
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_encoder_update(videoRecording, settings);
UI: Add NVENC support to simple output
2016-04-19 01:12:59 +02:00
}
UI: Add NVENC AV1 to simple output mode
2022-09-19 10:55:19 +02:00
void SimpleOutput::UpdateRecordingSettings_nvenc_hevc_av1(int cqp)
UI: Simple Output Mode for NVENC HEVC
2022-05-19 06:53:37 +02:00
{
OBSDataAutoRelease settings = obs_data_create();
obs_data_set_string(settings, "rate_control", "CQP");
obs_data_set_string(settings, "profile", "main");
obs_data_set_int(settings, "cqp", cqp);
obs_encoder_update(videoRecording, settings);
}
UI: Add Apple H.264 hardware encoder to simple mode Adds the Apple Silicon hardware encoder as a simple mode option. For recordings this only requires being on Apple Silicon (since we use the Constant Quality setting), while for streaming it requires the user to be on macOS 13 or newer (since we're using CBR).
2022-06-23 02:46:03 +02:00
void SimpleOutput::UpdateRecordingSettings_apple(int quality)
{
OBSDataAutoRelease settings = obs_data_create();
obs_data_set_string(settings, "rate_control", "CRF");
obs_data_set_string(settings, "profile", "high");
obs_data_set_int(settings, "quality", quality);
obs_encoder_update(videoRecording, settings);
}
UI: Implement simple output mode presets for AMD Closes jp9000/obs-studio#630
2016-09-27 01:29:33 +02:00
void SimpleOutput::UpdateRecordingSettings_amd_cqp(int cqp)
{
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease settings = obs_data_create();
UI: Update simple output to use new AMD encoder
2022-07-21 22:02:21 +02:00
obs_data_set_string(settings, "rate_control", "CQP");
obs_data_set_string(settings, "profile", "high");
UI: Fix wrong AMD recording preset (simple output) "hq" is not a valid preset. "quality" is the correct preset to use.
2022-07-24 20:14:17 +02:00
obs_data_set_string(settings, "preset", "quality");
UI: Update simple output to use new AMD encoder
2022-07-21 22:02:21 +02:00
obs_data_set_int(settings, "cqp", cqp);
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_encoder_update(videoRecording, settings);
UI: Implement simple output mode presets for AMD Closes jp9000/obs-studio#630
2016-09-27 01:29:33 +02:00
}
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
void SimpleOutput::UpdateRecordingSettings()
{
UI: Add NVENC support to simple output
2016-04-19 01:12:59 +02:00
bool ultra_hq = (videoQuality == "HQ");
int crf = CalcCRF(ultra_hq ? 16 : 23);
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
if (astrcmp_n(videoEncoder.c_str(), "x264", 4) == 0) {
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
UpdateRecordingSettings_x264_crf(crf);
} else if (videoEncoder == SIMPLE_ENCODER_QSV) {
UpdateRecordingSettings_qsv11(crf);
UI: Add NVENC support to simple output
2016-04-19 01:12:59 +02:00
UI: Implement simple output mode presets for AMD Closes jp9000/obs-studio#630
2016-09-27 01:29:33 +02:00
} else if (videoEncoder == SIMPLE_ENCODER_AMD) {
UpdateRecordingSettings_amd_cqp(crf);
UI: Update simple output to use new AMD encoder
2022-07-21 22:02:21 +02:00
#ifdef ENABLE_HEVC
} else if (videoEncoder == SIMPLE_ENCODER_AMD_HEVC) {
UpdateRecordingSettings_amd_cqp(crf);
#endif
UI: Add NVENC support to simple output
2016-04-19 01:12:59 +02:00
} else if (videoEncoder == SIMPLE_ENCODER_NVENC) {
UI: Use CQP for NVENC when using simple output mode When using simple output mode, previously NVENC did not support a constant quality rate control method, and you'd have to use VBR with bitrate. However CQP has since been added to NVENC, and it's preferable to use for recording when available instead of using VBR.
2016-05-08 20:21:37 +02:00
UpdateRecordingSettings_nvenc(crf);
UI: Simple Output Mode for NVENC HEVC
2022-05-19 06:53:37 +02:00
#ifdef ENABLE_HEVC
} else if (videoEncoder == SIMPLE_ENCODER_NVENC_HEVC) {
UI: Add NVENC AV1 to simple output mode
2022-09-19 10:55:19 +02:00
UpdateRecordingSettings_nvenc_hevc_av1(crf);
UI: Simple Output Mode for NVENC HEVC
2022-05-19 06:53:37 +02:00
#endif
UI: Add NVENC AV1 to simple output mode
2022-09-19 10:55:19 +02:00
} else if (videoEncoder == SIMPLE_ENCODER_NVENC_AV1) {
UpdateRecordingSettings_nvenc_hevc_av1(crf);
UI: Add Apple H.264 hardware encoder to simple mode Adds the Apple Silicon hardware encoder as a simple mode option. For recordings this only requires being on Apple Silicon (since we use the Constant Quality setting), while for streaming it requires the user to be on macOS 13 or newer (since we're using CBR).
2022-06-23 02:46:03 +02:00
} else if (videoEncoder == SIMPLE_ENCODER_APPLE_H264) {
/* These are magic numbers. 0 - 100, more is better. */
UpdateRecordingSettings_apple(ultra_hq ? 70 : 50);
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
}
UI: Fix audio bitrate not being set in simple mode
2019-10-25 17:56:26 +02:00
UpdateRecordingAudioSettings();
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
}
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
inline void SimpleOutput::SetupOutputs()
{
SimpleOutput::Update();
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_encoder_set_video(videoStreaming, obs_get_video());
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
obs_encoder_set_audio(aacStreaming, obs_get_audio());
UI: Add Twitch VOD track to simple output mode Allows the ability to use the separated Twitch VOD track with simple output mode in addition to advanced output mode.
2020-11-14 17:05:52 +01:00
obs_encoder_set_audio(aacArchive, obs_get_audio());
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
if (usingRecordingPreset) {
if (ffmpegOutput) {
obs_output_set_media(fileOutput, obs_get_video(),
obs_get_audio());
} else {
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_encoder_set_video(videoRecording, obs_get_video());
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
obs_encoder_set_audio(aacRecording, obs_get_audio());
}
}
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
}
UI: Allow services to use different outputs Allows a service to specify the output it needs in order to function as configured. NOTE: This functionality should be considered temporary as a seamless means of implementing support for different output types within the same service. Ideally, different services should be used for this functionality.
2017-07-13 12:57:42 +02:00
const char *FindAudioEncoderFromCodec(const char *type)
{
const char *alt_enc_id = nullptr;
size_t i = 0;
while (obs_enum_encoder_types(i++, &alt_enc_id)) {
const char *codec = obs_get_encoder_codec(alt_enc_id);
if (strcmp(type, codec) == 0) {
return alt_enc_id;
}
}
return nullptr;
}
UI: Create output before calling start stream event Allows modifying the output OBS_FRONTEND_EVENT_STREAMING_STARTING.
2020-09-17 07:20:02 +02:00
bool SimpleOutput::SetupStreaming(obs_service_t *service)
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
{
UI: Make SetupOutputs virtual instead of ignoring vcam In 218b936b1dae, the virtual camera was ignored when checking the active state, which is kind of a lackluster solution. Instead, this makes SetupOutputs() a virtual function, and calls it before starting the virtual camera to be more consistent with the rest of the outputs.
2020-09-03 15:56:03 +02:00
if (!Active())
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
SetupOutputs();
UI: Add Auth and OAuth classes Allows the ability to authenticate to a specific service. Typically via OAuth.
2019-02-07 07:24:25 +01:00
Auth *auth = main->GetAuth();
if (auth)
auth->OnStreamConfig();
UI: Allow services to use different outputs Allows a service to specify the output it needs in order to function as configured. NOTE: This functionality should be considered temporary as a seamless means of implementing support for different output types within the same service. Ideally, different services should be used for this functionality.
2017-07-13 12:57:42 +02:00
/* --------------------- */
const char *type = obs_service_get_output_type(service);
UI: Use new ffmpeg-encoded-output for non-RTMP urls
2019-04-19 20:58:31 +02:00
if (!type) {
UI: Allow services to use different outputs Allows a service to specify the output it needs in order to function as configured. NOTE: This functionality should be considered temporary as a seamless means of implementing support for different output types within the same service. Ideally, different services should be used for this functionality.
2017-07-13 12:57:42 +02:00
type = "rtmp_output";
UI: Use new ffmpeg-encoded-output for non-RTMP urls
2019-04-19 20:58:31 +02:00
const char *url = obs_service_get_url(service);
if (url != NULL &&
UI: Support FTL URLs for custom streaming service Custom streaming service URLs beginning with `ftl` are handled by the `ftl_output` plugin.
2020-12-06 10:54:29 +01:00
strncmp(url, FTL_PROTOCOL, strlen(FTL_PROTOCOL)) == 0) {
type = "ftl_output";
} else if (url != NULL && strncmp(url, RTMP_PROTOCOL,
strlen(RTMP_PROTOCOL)) != 0) {
UI: Swap to new srt output Redirect non rtmp streaming to ffmpeg-mux instead of previous ffmpeg-encoded-output which has been removed.
2020-03-25 16:21:31 +01:00
type = "ffmpeg_mpegts_muxer";
UI: Use new ffmpeg-encoded-output for non-RTMP urls
2019-04-19 20:58:31 +02:00
}
}
UI: Allow services to use different outputs Allows a service to specify the output it needs in order to function as configured. NOTE: This functionality should be considered temporary as a seamless means of implementing support for different output types within the same service. Ideally, different services should be used for this functionality.
2017-07-13 12:57:42 +02:00
/* XXX: this is messy and disgusting and should be refactored */
if (outputType != type) {
UI: Fix potential crash when outputs change If the service settings change and the output type changes, the previous signals would attempt to disconnect after the output has been destroyed, and subsequently that would cause a crash.
2017-07-26 04:01:29 +02:00
streamDelayStarting.Disconnect();
streamStopping.Disconnect();
startStreaming.Disconnect();
stopStreaming.Disconnect();
UI: Allow services to use different outputs Allows a service to specify the output it needs in order to function as configured. NOTE: This functionality should be considered temporary as a seamless means of implementing support for different output types within the same service. Ideally, different services should be used for this functionality.
2017-07-13 12:57:42 +02:00
streamOutput = obs_output_create(type, "simple_stream", nullptr,
nullptr);
UI: Log generic stream startup failures These code paths had no logging on failure, resulting in a log file that would confuse people attempting to perform support for users.
2017-10-06 13:48:24 +02:00
if (!streamOutput) {
blog(LOG_WARNING,
"Creation of stream output type '%s' "
"failed!",
type);
UI: Allow services to use different outputs Allows a service to specify the output it needs in order to function as configured. NOTE: This functionality should be considered temporary as a seamless means of implementing support for different output types within the same service. Ideally, different services should be used for this functionality.
2017-07-13 12:57:42 +02:00
return false;
UI: Log generic stream startup failures These code paths had no logging on failure, resulting in a log file that would confuse people attempting to perform support for users.
2017-10-06 13:48:24 +02:00
}
UI: Allow services to use different outputs Allows a service to specify the output it needs in order to function as configured. NOTE: This functionality should be considered temporary as a seamless means of implementing support for different output types within the same service. Ideally, different services should be used for this functionality.
2017-07-13 12:57:42 +02:00
streamDelayStarting.Connect(
obs_output_get_signal_handler(streamOutput), "starting",
OBSStreamStarting, this);
streamStopping.Connect(
obs_output_get_signal_handler(streamOutput), "stopping",
OBSStreamStopping, this);
startStreaming.Connect(
obs_output_get_signal_handler(streamOutput), "start",
OBSStartStreaming, this);
stopStreaming.Connect(
obs_output_get_signal_handler(streamOutput), "stop",
OBSStopStreaming, this);
UI: Fix unencoded stream failure A stream will fail to start if the output_info does not have an encoded_audio_codecs string, even if the output is not flagged as encoded. This allows unencoded outputs to omit that string.
2018-09-26 20:39:34 +02:00
bool isEncoded = obs_output_get_flags(streamOutput) &
OBS_OUTPUT_ENCODED;
if (isEncoded) {
const char *codec =
obs_output_get_supported_audio_codecs(
streamOutput);
if (!codec) {
blog(LOG_WARNING, "Failed to load audio codec");
UI: Allow outputs to use different audio codecs Allows an output to automatically specify which audio codec it requires and use it instead of AAC. This change is intended to be behind-the-scenes and seamless to the user.
2017-07-13 13:04:17 +02:00
return false;
UI: Fix unencoded stream failure A stream will fail to start if the output_info does not have an encoded_audio_codecs string, even if the output is not flagged as encoded. This allows unencoded outputs to omit that string.
2018-09-26 20:39:34 +02:00
}
UI: Allow outputs to use different audio codecs Allows an output to automatically specify which audio codec it requires and use it instead of AAC. This change is intended to be behind-the-scenes and seamless to the user.
2017-07-13 13:04:17 +02:00
UI: Fix unencoded stream failure A stream will fail to start if the output_info does not have an encoded_audio_codecs string, even if the output is not flagged as encoded. This allows unencoded outputs to omit that string.
2018-09-26 20:39:34 +02:00
if (strcmp(codec, "aac") != 0) {
const char *id =
FindAudioEncoderFromCodec(codec);
int audioBitrate = GetAudioBitrate();
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease settings = obs_data_create();
UI: Fix unencoded stream failure A stream will fail to start if the output_info does not have an encoded_audio_codecs string, even if the output is not flagged as encoded. This allows unencoded outputs to omit that string.
2018-09-26 20:39:34 +02:00
obs_data_set_int(settings, "bitrate",
audioBitrate);
aacStreaming = obs_audio_encoder_create(
id, "alt_audio_enc", nullptr, 0,
nullptr);
obs_encoder_release(aacStreaming);
if (!aacStreaming)
return false;
obs_encoder_update(aacStreaming, settings);
obs_encoder_set_audio(aacStreaming,
obs_get_audio());
}
UI: Allow outputs to use different audio codecs Allows an output to automatically specify which audio codec it requires and use it instead of AAC. This change is intended to be behind-the-scenes and seamless to the user.
2017-07-13 13:04:17 +02:00
}
UI: Allow services to use different outputs Allows a service to specify the output it needs in order to function as configured. NOTE: This functionality should be considered temporary as a seamless means of implementing support for different output types within the same service. Ideally, different services should be used for this functionality.
2017-07-13 12:57:42 +02:00
outputType = type;
}
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_output_set_video_encoder(streamOutput, videoStreaming);
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
obs_output_set_audio_encoder(streamOutput, aacStreaming, 0);
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
obs_output_set_service(streamOutput, service);
UI: Create output before calling start stream event Allows modifying the output OBS_FRONTEND_EVENT_STREAMING_STARTING.
2020-09-17 07:20:02 +02:00
return true;
}
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
UI: Add Twitch VOD track to simple output mode Allows the ability to use the separated Twitch VOD track with simple output mode in addition to advanced output mode.
2020-11-14 17:05:52 +01:00
static inline bool ServiceSupportsVodTrack(const char *service);
UI: Fix vod track not working with twitch soundtrack The vod track in advanced output mode would be overwritten by twitch soundtrack's vod track. Additionally, simple output mode would overwrite twitch's soundtrack vod track even when vod track was turned off in settings. So instead, if vod track is off, don't clear the secondary encoder unless it's explicitly our encoder. Additionally, make sure that advanced output mode's vod track encoder behaves consistently with simple output mode's vod track so it doesn't get overwritten.
2020-12-03 09:59:43 +01:00
static void clear_archive_encoder(obs_output_t *output,
const char *expected_name)
{
obs_encoder_t *last = obs_output_get_audio_encoder(output, 1);
bool clear = false;
/* ensures that we don't remove twitch's soundtrack encoder */
if (last) {
const char *name = obs_encoder_get_name(last);
clear = name && strcmp(name, expected_name) == 0;
obs_encoder_release(last);
}
if (clear)
obs_output_set_audio_encoder(output, nullptr, 1);
}
UI: Add Twitch VOD track to simple output mode Allows the ability to use the separated Twitch VOD track with simple output mode in addition to advanced output mode.
2020-11-14 17:05:52 +01:00
void SimpleOutput::SetupVodTrack(obs_service_t *service)
{
bool advanced =
config_get_bool(main->Config(), "SimpleOutput", "UseAdvanced");
bool enable = config_get_bool(main->Config(), "SimpleOutput",
"VodTrackEnabled");
UI: Allow enabling vod track on custom via ini
2020-12-03 10:31:32 +01:00
bool enableForCustomServer = config_get_bool(
GetGlobalConfig(), "General", "EnableCustomServerVodTrack");
UI: Add Twitch VOD track to simple output mode Allows the ability to use the separated Twitch VOD track with simple output mode in addition to advanced output mode.
2020-11-14 17:05:52 +01:00
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease settings = obs_service_get_settings(service);
UI: Add Twitch VOD track to simple output mode Allows the ability to use the separated Twitch VOD track with simple output mode in addition to advanced output mode.
2020-11-14 17:05:52 +01:00
const char *name = obs_data_get_string(settings, "service");
UI: Fix vod track working with custom server
2020-12-03 10:20:37 +01:00
const char *id = obs_service_get_id(service);
if (strcmp(id, "rtmp_custom") == 0)
UI: Allow enabling vod track on custom via ini
2020-12-03 10:31:32 +01:00
enable = enableForCustomServer ? enable : false;
UI: Fix vod track working with custom server
2020-12-03 10:20:37 +01:00
else
enable = advanced && enable && ServiceSupportsVodTrack(name);
if (enable)
UI: Add Twitch VOD track to simple output mode Allows the ability to use the separated Twitch VOD track with simple output mode in addition to advanced output mode.
2020-11-14 17:05:52 +01:00
obs_output_set_audio_encoder(streamOutput, aacArchive, 1);
UI: Fix vod track not working with twitch soundtrack The vod track in advanced output mode would be overwritten by twitch soundtrack's vod track. Additionally, simple output mode would overwrite twitch's soundtrack vod track even when vod track was turned off in settings. So instead, if vod track is off, don't clear the secondary encoder unless it's explicitly our encoder. Additionally, make sure that advanced output mode's vod track encoder behaves consistently with simple output mode's vod track so it doesn't get overwritten.
2020-12-03 09:59:43 +01:00
else
clear_archive_encoder(streamOutput, SIMPLE_ARCHIVE_NAME);
UI: Add Twitch VOD track to simple output mode Allows the ability to use the separated Twitch VOD track with simple output mode in addition to advanced output mode.
2020-11-14 17:05:52 +01:00
}
UI: Create output before calling start stream event Allows modifying the output OBS_FRONTEND_EVENT_STREAMING_STARTING.
2020-09-17 07:20:02 +02:00
bool SimpleOutput::StartStreaming(obs_service_t *service)
{
UI: Move reconnect options to advanced settings This is mostly just to remove the unnecessary clutter from the output sections. The reconnect settings are generally rarely modified by users as it is.
2015-09-11 04:10:40 +02:00
bool reconnect = config_get_bool(main->Config(), "Output", "Reconnect");
int retryDelay =
config_get_uint(main->Config(), "Output", "RetryDelay");
int maxRetries =
config_get_uint(main->Config(), "Output", "MaxRetries");
UI: Implement stream delay When stream delay is active, the "Start/Stop Streaming" button is changed in to a menu button, which allows the user to select either the option to stop the stream (which causes it to count down), or forcibly stop the stream (which immediately stops the stream and cuts off all delayed data). If the user decides they want to start the stream again while in the process of counting down, they can safely do so without having to wait for it to stop, and it will schedule it to start up again with the same delay after the stop. On the status bar, it will now show whether delay is active, and its duration. If the stream is in the process of stopping/starting, it will count down to the stop/start. If the option to preserve stream cutoff point on unexpected disconnections/reconnections is enabled, it will update the current delay duration accordingly.
2015-09-07 01:19:53 +02:00
bool useDelay =
config_get_bool(main->Config(), "Output", "DelayEnable");
int delaySec = config_get_int(main->Config(), "Output", "DelaySec");
bool preserveDelay =
config_get_bool(main->Config(), "Output", "DelayPreserve");
UI: Add "Bind to IP" setting to advanced settings
2016-07-29 17:30:54 +02:00
const char *bindIP =
config_get_string(main->Config(), "Output", "BindIP");
UI: Add options for new socket loop
2017-02-22 02:05:45 +01:00
bool enableNewSocketLoop = config_get_bool(main->Config(), "Output",
"NewSocketLoopEnable");
bool enableLowLatencyMode =
config_get_bool(main->Config(), "Output", "LowLatencyEnable");
UI: Add dynamic bitrate support to the UI Adds dynamic bitrate support (marked as beta) to the advanced settings for now.
2019-08-15 17:50:09 +02:00
bool enableDynBitrate =
config_get_bool(main->Config(), "Output", "DynamicBitrate");
UI: Add "Bind to IP" setting to advanced settings
2016-07-29 17:30:54 +02:00
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease settings = obs_data_create();
UI: Add "Bind to IP" setting to advanced settings
2016-07-29 17:30:54 +02:00
obs_data_set_string(settings, "bind_ip", bindIP);
UI: Add options for new socket loop
2017-02-22 02:05:45 +01:00
obs_data_set_bool(settings, "new_socket_loop_enabled",
enableNewSocketLoop);
obs_data_set_bool(settings, "low_latency_mode_enabled",
enableLowLatencyMode);
UI: Add dynamic bitrate support to the UI Adds dynamic bitrate support (marked as beta) to the advanced settings for now.
2019-08-15 17:50:09 +02:00
obs_data_set_bool(settings, "dyn_bitrate", enableDynBitrate);
UI: Add "Bind to IP" setting to advanced settings
2016-07-29 17:30:54 +02:00
obs_output_update(streamOutput, settings);
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
if (!reconnect)
maxRetries = 0;
UI: Implement stream delay When stream delay is active, the "Start/Stop Streaming" button is changed in to a menu button, which allows the user to select either the option to stop the stream (which causes it to count down), or forcibly stop the stream (which immediately stops the stream and cuts off all delayed data). If the user decides they want to start the stream again while in the process of counting down, they can safely do so without having to wait for it to stop, and it will schedule it to start up again with the same delay after the stop. On the status bar, it will now show whether delay is active, and its duration. If the stream is in the process of stopping/starting, it will count down to the stop/start. If the option to preserve stream cutoff point on unexpected disconnections/reconnections is enabled, it will update the current delay duration accordingly.
2015-09-07 01:19:53 +02:00
obs_output_set_delay(streamOutput, useDelay ? delaySec : 0,
preserveDelay ? OBS_OUTPUT_DELAY_PRESERVE : 0);
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
obs_output_set_reconnect_settings(streamOutput, maxRetries, retryDelay);
UI: Add Twitch VOD track to simple output mode Allows the ability to use the separated Twitch VOD track with simple output mode in addition to advanced output mode.
2020-11-14 17:05:52 +01:00
SetupVodTrack(service);
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
if (obs_output_start(streamOutput)) {
return true;
}
UI: Log generic stream startup failures These code paths had no logging on failure, resulting in a log file that would confuse people attempting to perform support for users.
2017-10-06 13:48:24 +02:00
const char *error = obs_output_get_last_error(streamOutput);
UI: Show output's last error in failure dialog Logs the last output error if given.
2018-12-13 00:20:48 +01:00
bool hasLastError = error && *error;
if (hasLastError)
lastError = error;
else
lastError = string();
UI: Log generic stream startup failures These code paths had no logging on failure, resulting in a log file that would confuse people attempting to perform support for users.
2017-10-06 13:48:24 +02:00
UI: Create output before calling start stream event Allows modifying the output OBS_FRONTEND_EVENT_STREAMING_STARTING.
2020-09-17 07:20:02 +02:00
const char *type = obs_service_get_output_type(service);
UI: Show output's last error in failure dialog Logs the last output error if given.
2018-12-13 00:20:48 +01:00
blog(LOG_WARNING, "Stream output type '%s' failed to start!%s%s", type,
hasLastError ? " Last Error: " : "", hasLastError ? error : "");
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
return false;
}
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
void SimpleOutput::UpdateRecording()
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
{
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
if (replayBufferActive || recordingActive)
return;
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-19 07:29:36 +02:00
if (usingRecordingPreset) {
if (!ffmpegOutput)
UpdateRecordingSettings();
} else if (!obs_output_active(streamOutput)) {
Update();
}
UI: Make SetupOutputs virtual instead of ignoring vcam In 218b936b1dae, the virtual camera was ignored when checking the active state, which is kind of a lackluster solution. Instead, this makes SetupOutputs() a virtual function, and calls it before starting the virtual camera to be more consistent with the rest of the outputs.
2020-09-03 15:56:03 +02:00
if (!Active())
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
SetupOutputs();
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
if (!ffmpegOutput) {
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_output_set_video_encoder(fileOutput, videoRecording);
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
obs_output_set_audio_encoder(fileOutput, aacRecording, 0);
}
if (replayBuffer) {
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_output_set_video_encoder(replayBuffer, videoRecording);
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
obs_output_set_audio_encoder(replayBuffer, aacRecording, 0);
}
recordingConfigured = true;
}
bool SimpleOutput::ConfigureRecording(bool updateReplayBuffer)
{
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
const char *path =
config_get_string(main->Config(), "SimpleOutput", "FilePath");
UI: Add option to select recording format Add a listboxes to recording to allow changing file formats (allows mp4, mov, mkv, ts, flv)
2015-05-29 18:45:54 +02:00
const char *format =
config_get_string(main->Config(), "SimpleOutput", "RecFormat");
UI: Add custom muxer settings for ffmpeg-mux
2015-11-23 15:36:06 +01:00
const char *mux = config_get_string(main->Config(), "SimpleOutput",
"MuxerCustom");
UI: Allow file name generation without spaces This will probably go away once proper file name formatting is implemented (https://obsproject.com/mantis/view.php?id=361)
2015-11-27 12:14:18 +01:00
bool noSpace = config_get_bool(main->Config(), "SimpleOutput",
"FileNameWithoutSpace");
UI: Add file formatting options for recording Allows the user to specify custom formatting for their recording file names with many formatting options, viewed via tooltip. The options have been added to the advanced settings section. Closes jp9000/obs-studio#507
2016-03-25 10:43:38 +01:00
const char *filenameFormat = config_get_string(main->Config(), "Output",
"FilenameFormatting");
bool overwriteIfExists =
config_get_bool(main->Config(), "Output", "OverwriteIfExists");
UI: Add file prefix/suffix options for replay buffer Adds the ability to use a specific prefix and/or suffix on replay buffer filenames to distinguish them from normal recordings. Defaults to having the prefix "Replay".
2016-12-09 23:42:14 +01:00
const char *rbPrefix = config_get_string(main->Config(), "SimpleOutput",
"RecRBPrefix");
const char *rbSuffix = config_get_string(main->Config(), "SimpleOutput",
"RecRBSuffix");
UI: Add replay buffer options to simple output mode
2016-12-07 14:21:44 +01:00
int rbTime =
config_get_int(main->Config(), "SimpleOutput", "RecRBTime");
int rbSize =
config_get_int(main->Config(), "SimpleOutput", "RecRBSize");
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
UI: Simplify path generation code
2020-07-23 15:45:03 +02:00
string f;
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
string strPath;
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease settings = obs_data_create();
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
if (updateReplayBuffer) {
UI: Simplify path generation code
2020-07-23 15:45:03 +02:00
f = GetFormatString(filenameFormat, rbPrefix, rbSuffix);
strPath = GetOutputFilename(path, ffmpegOutput ? "avi" : format,
noSpace, overwriteIfExists,
f.c_str());
UI: Add replay buffer options to simple output mode
2016-12-07 14:21:44 +01:00
obs_data_set_string(settings, "directory", path);
UI: Add file prefix/suffix options for replay buffer Adds the ability to use a specific prefix and/or suffix on replay buffer filenames to distinguish them from normal recordings. Defaults to having the prefix "Replay".
2016-12-09 23:42:14 +01:00
obs_data_set_string(settings, "format", f.c_str());
UI: Add replay buffer options to simple output mode
2016-12-07 14:21:44 +01:00
obs_data_set_string(settings, "extension", format);
UI: Fix no_space file naming for replays Replays was ignoring user's settings when generating replays filenames.
2018-04-26 17:54:47 +02:00
obs_data_set_bool(settings, "allow_spaces", !noSpace);
UI: Add replay buffer options to simple output mode
2016-12-07 14:21:44 +01:00
obs_data_set_int(settings, "max_time_sec", rbTime);
obs_data_set_int(settings, "max_size_mb",
usingRecordingPreset ? rbSize : 0);
} else {
UI: Simplify path generation code
2020-07-23 15:45:03 +02:00
f = GetFormatString(filenameFormat, nullptr, nullptr);
UI: Fix screenshots preventing auto-remux Due to the fact that a global was used on GenerateSpecifiedFilename to save the remux file name, when a screenshot was made, it would overwrite the filename being remuxed, because screenshots use the same function to generate filenames as well. This solves that problem by removing the global and the changes to GeneratedSpecifiedFilename, and isolating that to the output handler. Coincidentally, this bug probably also happened with replay buffers under certain circumstances. Fixes obsproject/obs-studio#3497 Closes obsproject/obs-studio#3498
2020-09-26 17:19:27 +02:00
strPath = GetRecordingFilename(path,
ffmpegOutput ? "avi" : format,
noSpace, overwriteIfExists,
f.c_str(), ffmpegOutput);
UI: Add replay buffer options to simple output mode
2016-12-07 14:21:44 +01:00
obs_data_set_string(settings, ffmpegOutput ? "url" : "path",
strPath.c_str());
}
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
UI: Add custom muxer settings for ffmpeg-mux
2015-11-23 15:36:06 +01:00
obs_data_set_string(settings, "muxer_settings", mux);
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
if (updateReplayBuffer)
obs_output_update(replayBuffer, settings);
else
obs_output_update(fileOutput, settings);
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
return true;
}
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
bool SimpleOutput::StartRecording()
{
UpdateRecording();
if (!ConfigureRecording(false))
return false;
UI: Add warning if starting the output fails This is mainly to give visual feedback to those affected by NVENC not working with older driver versions. Currenlty obs fails silently which could go unnoticed for users who are using hotkeys as well as confuse users who are not trained to read their logs when issues occur. Closes jp9000/obs-studio#788
2017-02-04 05:29:09 +01:00
if (!obs_output_start(fileOutput)) {
UI: Report more detailed output errors if available
2017-08-07 00:24:44 +02:00
QString error_reason;
const char *error = obs_output_get_last_error(fileOutput);
if (error)
error_reason = QT_UTF8(error);
else
error_reason = QTStr("Output.StartFailedGeneric");
UI: Add warning if starting the output fails This is mainly to give visual feedback to those affected by NVENC not working with older driver versions. Currenlty obs fails silently which could go unnoticed for users who are using hotkeys as well as confuse users who are not trained to read their logs when issues occur. Closes jp9000/obs-studio#788
2017-02-04 05:29:09 +01:00
QMessageBox::critical(main,
UI: Report more detailed output errors if available
2017-08-07 00:24:44 +02:00
QTStr("Output.StartRecordingFailed"),
error_reason);
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
return false;
UI: Add warning if starting the output fails This is mainly to give visual feedback to those affected by NVENC not working with older driver versions. Currenlty obs fails silently which could go unnoticed for users who are using hotkeys as well as confuse users who are not trained to read their logs when issues occur. Closes jp9000/obs-studio#788
2017-02-04 05:29:09 +01:00
}
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
return true;
}
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
bool SimpleOutput::StartReplayBuffer()
{
UpdateRecording();
if (!ConfigureRecording(true))
return false;
UI: Add warning if starting the output fails This is mainly to give visual feedback to those affected by NVENC not working with older driver versions. Currenlty obs fails silently which could go unnoticed for users who are using hotkeys as well as confuse users who are not trained to read their logs when issues occur. Closes jp9000/obs-studio#788
2017-02-04 05:29:09 +01:00
if (!obs_output_start(replayBuffer)) {
QMessageBox::critical(main, QTStr("Output.StartReplayFailed"),
QTStr("Output.StartFailedGeneric"));
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
return false;
UI: Add warning if starting the output fails This is mainly to give visual feedback to those affected by NVENC not working with older driver versions. Currenlty obs fails silently which could go unnoticed for users who are using hotkeys as well as confuse users who are not trained to read their logs when issues occur. Closes jp9000/obs-studio#788
2017-02-04 05:29:09 +01:00
}
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
return true;
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
}
UI: Add ability to forcibly stop streams/recordings If the user hits the "stop stream" button it'll transition in to "stopping stream..." and will continue to output until the stream reaches the timing in which "stop" was pressed. However, if there is significant congestion, stopping the stream can take far longer than the user may like. So there needs to be an option to forcibly stop the stream in that case; pushing the "stop" button a second time should allow the user to tell the stream/recording to stop right away instead of waiting for the precise stop timing.
2016-09-09 16:37:54 +02:00
void SimpleOutput::StopStreaming(bool force)
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
{
UI: Add ability to forcibly stop streams/recordings If the user hits the "stop stream" button it'll transition in to "stopping stream..." and will continue to output until the stream reaches the timing in which "stop" was pressed. However, if there is significant congestion, stopping the stream can take far longer than the user may like. So there needs to be an option to forcibly stop the stream in that case; pushing the "stop" button a second time should allow the user to tell the stream/recording to stop right away instead of waiting for the precise stop timing.
2016-09-09 16:37:54 +02:00
if (force)
obs_output_force_stop(streamOutput);
else
obs_output_stop(streamOutput);
UI: Implement stream delay When stream delay is active, the "Start/Stop Streaming" button is changed in to a menu button, which allows the user to select either the option to stop the stream (which causes it to count down), or forcibly stop the stream (which immediately stops the stream and cuts off all delayed data). If the user decides they want to start the stream again while in the process of counting down, they can safely do so without having to wait for it to stop, and it will schedule it to start up again with the same delay after the stop. On the status bar, it will now show whether delay is active, and its duration. If the stream is in the process of stopping/starting, it will count down to the stop/start. If the option to preserve stream cutoff point on unexpected disconnections/reconnections is enabled, it will update the current delay duration accordingly.
2015-09-07 01:19:53 +02:00
}
UI: Add ability to forcibly stop streams/recordings If the user hits the "stop stream" button it'll transition in to "stopping stream..." and will continue to output until the stream reaches the timing in which "stop" was pressed. However, if there is significant congestion, stopping the stream can take far longer than the user may like. So there needs to be an option to forcibly stop the stream in that case; pushing the "stop" button a second time should allow the user to tell the stream/recording to stop right away instead of waiting for the precise stop timing.
2016-09-09 16:37:54 +02:00
void SimpleOutput::StopRecording(bool force)
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
{
UI: Add ability to forcibly stop streams/recordings If the user hits the "stop stream" button it'll transition in to "stopping stream..." and will continue to output until the stream reaches the timing in which "stop" was pressed. However, if there is significant congestion, stopping the stream can take far longer than the user may like. So there needs to be an option to forcibly stop the stream in that case; pushing the "stop" button a second time should allow the user to tell the stream/recording to stop right away instead of waiting for the precise stop timing.
2016-09-09 16:37:54 +02:00
if (force)
obs_output_force_stop(fileOutput);
else
obs_output_stop(fileOutput);
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
}
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
void SimpleOutput::StopReplayBuffer(bool force)
{
if (force)
obs_output_force_stop(replayBuffer);
else
obs_output_stop(replayBuffer);
}
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
bool SimpleOutput::StreamingActive() const
{
return obs_output_active(streamOutput);
}
bool SimpleOutput::RecordingActive() const
{
return obs_output_active(fileOutput);
}
UI: Separate replay buffer from recording Replay buffer and recording should be separate in case the user wants to start recording from a specific point rather being forced to reconfigure for regular recording. Creates a new button on the main window below the recording button for turning on/off the replay buffer.
2016-12-09 23:40:04 +01:00
bool SimpleOutput::ReplayBufferActive() const
{
return obs_output_active(replayBuffer);
}
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
/* ------------------------------------------------------------------------ */
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
struct AdvancedOutput : BasicOutputHandler {
UI: Fix bug where FTL was using AAC instead of opus When the streaming audio track was separated from the recording tracks in advanced output mode in be8c06334, it mistakenly removed the opus audio encoder code when FTL is used. This restores that code.
2019-08-23 00:08:24 +02:00
OBSEncoder streamAudioEnc;
UI: Add VOD track support in advanced output Adds a VOD track option (specific to Twitch) that allows a user to specify which audio track to use for their Twitch VODs, which uses a separate encoder to encode the track. This allows users the ability to choose what audio goes on their VOD, separately from the live stream.
2020-11-01 10:54:27 +01:00
OBSEncoder streamArchiveEnc;
UI: Increase maximum audio tracks to 6
2016-12-22 02:14:24 +01:00
OBSEncoder aacTrack[MAX_AUDIO_MIXES];
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
OBSEncoder videoStreaming;
OBSEncoder videoRecording;
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
UI: Allow generated filenames for FFmpeg output This changes the way the advanced output section's FFmpeg output settings work by allowing the user to select whether they want to output to a file or output to a URL, and makes it so file names are automatically generated like other recording outputs. If they choose to output to a file, it'll only require an output directory similarly to how other recording outputs work. They can select a directory to output to rather than being required to type in a full path and filename; the filename is automatically generated. The extension is also automatically retrieved from libff depending on the format selected. Otherwise if they have Output to URL selected, it'll show a simple edit box where they can type in the target URL.
2015-08-19 05:58:24 +02:00
bool ffmpegOutput;
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
bool ffmpegRecording;
bool useStreamEncoder;
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
bool usesBitrate = false;
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
UI: Increase maximum audio tracks to 6
2016-12-22 02:14:24 +01:00
string aacEncoderID[MAX_AUDIO_MIXES];
UI: Create best matching audio encoder for given bitrate
2015-07-02 10:00:22 +02:00
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
AdvancedOutput(OBSBasic *main_);
inline void UpdateStreamSettings();
inline void UpdateRecordingSettings();
(API Change) Fix "apply service settings" functions API changed from: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); void obs_service_info::apply_encoder_settings(void *data obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); To: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); void obs_service_info::apply_encoder_settings(void *data obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); These changes make it so that instead of an encoder potentially being updated more than once with different settings, that these functions will be called for the specific settings being used, and the settings will be updated according to what's required by the service. This fixes that design flaw and ensures that there's no case where obs_encoder_update is called where the settings might not have service-specific settings applied.
2015-03-08 01:32:00 +01:00
inline void UpdateAudioSettings();
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
virtual void Update() override;
UI: Fix vod track not working with twitch soundtrack The vod track in advanced output mode would be overwritten by twitch soundtrack's vod track. Additionally, simple output mode would overwrite twitch's soundtrack vod track even when vod track was turned off in settings. So instead, if vod track is off, don't clear the secondary encoder unless it's explicitly our encoder. Additionally, make sure that advanced output mode's vod track encoder behaves consistently with simple output mode's vod track so it doesn't get overwritten.
2020-12-03 09:59:43 +01:00
inline void SetupVodTrack(obs_service_t *service);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
inline void SetupStreaming();
inline void SetupRecording();
inline void SetupFFmpeg();
UI: Make SetupOutputs virtual instead of ignoring vcam In 218b936b1dae, the virtual camera was ignored when checking the active state, which is kind of a lackluster solution. Instead, this makes SetupOutputs() a virtual function, and calls it before starting the virtual camera to be more consistent with the rest of the outputs.
2020-09-03 15:56:03 +02:00
void SetupOutputs() override;
UI: Move output handler audio bitrate config access
2015-07-02 09:58:28 +02:00
int GetAudioBitrate(size_t i) const;
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
UI: Create output before calling start stream event Allows modifying the output OBS_FRONTEND_EVENT_STREAMING_STARTING.
2020-09-17 07:20:02 +02:00
virtual bool SetupStreaming(obs_service_t *service) override;
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
virtual bool StartStreaming(obs_service_t *service) override;
virtual bool StartRecording() override;
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
virtual bool StartReplayBuffer() override;
UI: Add ability to forcibly stop streams/recordings If the user hits the "stop stream" button it'll transition in to "stopping stream..." and will continue to output until the stream reaches the timing in which "stop" was pressed. However, if there is significant congestion, stopping the stream can take far longer than the user may like. So there needs to be an option to forcibly stop the stream in that case; pushing the "stop" button a second time should allow the user to tell the stream/recording to stop right away instead of waiting for the precise stop timing.
2016-09-09 16:37:54 +02:00
virtual void StopStreaming(bool force) override;
virtual void StopRecording(bool force) override;
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
virtual void StopReplayBuffer(bool force) override;
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
virtual bool StreamingActive() const override;
virtual bool RecordingActive() const override;
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
virtual bool ReplayBufferActive() const override;
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
};
static OBSData GetDataFromJsonFile(const char *jsonFile)
{
char fullPath[512];
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease data = nullptr;
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
UI: Add Profiles Adds setting profiles to the basic user interface. For each profile, a subdirectory for the profile will be created in [config_dir]/obs-studio/basic/profiles which will contain the settings data for each profile.
2015-06-24 04:38:01 +02:00
int ret = GetProfilePath(fullPath, sizeof(fullPath), jsonFile);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
if (ret > 0) {
BPtr<char> jsonData = os_quick_read_utf8_file(fullPath);
if (!!jsonData) {
UI: Fix bug with advanced output service settings When the user had advanced output mode selected and they created a new profile, enforced service settings for advanced output mode would not be applied because GetDataFromJsonFile would return a nullptr (because the settings file did not yet exist). Instead of returning nullptr, always return a valid data object, and in addition, apply the defaults of the encoder to pass to obs_service_apply_encoder_settings just to be safe.
2018-07-20 10:50:29 +02:00
data = obs_data_create_from_json(jsonData);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
}
}
UI: Fix bug with advanced output service settings When the user had advanced output mode selected and they created a new profile, enforced service settings for advanced output mode would not be applied because GetDataFromJsonFile would return a nullptr (because the settings file did not yet exist). Instead of returning nullptr, always return a valid data object, and in addition, apply the defaults of the encoder to pass to obs_service_apply_encoder_settings just to be safe.
2018-07-20 10:50:29 +02:00
if (!data)
data = obs_data_create();
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
return data.Get();
UI: Fix bug with advanced output service settings When the user had advanced output mode selected and they created a new profile, enforced service settings for advanced output mode would not be applied because GetDataFromJsonFile would return a nullptr (because the settings file did not yet exist). Instead of returning nullptr, always return a valid data object, and in addition, apply the defaults of the encoder to pass to obs_service_apply_encoder_settings just to be safe.
2018-07-20 10:50:29 +02:00
}
static void ApplyEncoderDefaults(OBSData &settings,
const obs_encoder_t *encoder)
{
OBSData dataRet = obs_encoder_get_defaults(encoder);
obs_data_release(dataRet);
if (!!settings)
obs_data_apply(dataRet, settings);
settings = std::move(dataRet);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
}
UI: Fix vod track not working with twitch soundtrack The vod track in advanced output mode would be overwritten by twitch soundtrack's vod track. Additionally, simple output mode would overwrite twitch's soundtrack vod track even when vod track was turned off in settings. So instead, if vod track is off, don't clear the secondary encoder unless it's explicitly our encoder. Additionally, make sure that advanced output mode's vod track encoder behaves consistently with simple output mode's vod track so it doesn't get overwritten.
2020-12-03 09:59:43 +01:00
#define ADV_ARCHIVE_NAME "adv_archive_aac"
UI: Handle mac-vth264 encoder ID change Before OBS Studio 27, we used our own hard-coded internal encoder IDs on for the mac-vth264 plugin: vt_h264_hw and vt_h264_sw. As of OBS Studio 27, we changed to using the encoder IDs that Apple's API reports. Specifically, this behavior occurs due to PR #4105 and commit 6a9f25c8ea1b244b4a439667be33f4a5cc6cdf4b. Unfortunately, this change in encoder IDs failed to take into account existing user configurations, resulting in users with broken encoder settings. This change attempts to gracefully upgrade user configurations to handle the changed encoder IDs. Fixes #4799.
2021-06-10 01:33:59 +02:00
#ifdef __APPLE__
static void translate_macvth264_encoder(const char *&encoder)
{
if (strcmp(encoder, "vt_h264_hw") == 0) {
encoder = "com.apple.videotoolbox.videoencoder.h264.gva";
} else if (strcmp(encoder, "vt_h264_sw") == 0) {
encoder = "com.apple.videotoolbox.videoencoder.h264";
}
}
#endif
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
AdvancedOutput::AdvancedOutput(OBSBasic *main_) : BasicOutputHandler(main_)
{
const char *recType =
config_get_string(main->Config(), "AdvOut", "RecType");
const char *streamEncoder =
config_get_string(main->Config(), "AdvOut", "Encoder");
const char *recordEncoder =
config_get_string(main->Config(), "AdvOut", "RecEncoder");
UI: Handle mac-vth264 encoder ID change Before OBS Studio 27, we used our own hard-coded internal encoder IDs on for the mac-vth264 plugin: vt_h264_hw and vt_h264_sw. As of OBS Studio 27, we changed to using the encoder IDs that Apple's API reports. Specifically, this behavior occurs due to PR #4105 and commit 6a9f25c8ea1b244b4a439667be33f4a5cc6cdf4b. Unfortunately, this change in encoder IDs failed to take into account existing user configurations, resulting in users with broken encoder settings. This change attempts to gracefully upgrade user configurations to handle the changed encoder IDs. Fixes #4799.
2021-06-10 01:33:59 +02:00
#ifdef __APPLE__
translate_macvth264_encoder(streamEncoder);
translate_macvth264_encoder(recordEncoder);
#endif
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
UI: Allow generated filenames for FFmpeg output This changes the way the advanced output section's FFmpeg output settings work by allowing the user to select whether they want to output to a file or output to a URL, and makes it so file names are automatically generated like other recording outputs. If they choose to output to a file, it'll only require an output directory similarly to how other recording outputs work. They can select a directory to output to rather than being required to type in a full path and filename; the filename is automatically generated. The extension is also automatically retrieved from libff depending on the format selected. Otherwise if they have Output to URL selected, it'll show a simple edit box where they can type in the target URL.
2015-08-19 05:58:24 +02:00
ffmpegOutput = astrcmpi(recType, "FFmpeg") == 0;
ffmpegRecording =
ffmpegOutput &&
config_get_bool(main->Config(), "AdvOut", "FFOutputToFile");
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
useStreamEncoder = astrcmpi(recordEncoder, "none") == 0;
UI: Add Profiles Adds setting profiles to the basic user interface. For each profile, a subdirectory for the profile will be created in [config_dir]/obs-studio/basic/profiles which will contain the settings data for each profile.
2015-06-24 04:38:01 +02:00
OBSData streamEncSettings = GetDataFromJsonFile("streamEncoder.json");
OBSData recordEncSettings = GetDataFromJsonFile("recordEncoder.json");
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
UI: Allow generated filenames for FFmpeg output This changes the way the advanced output section's FFmpeg output settings work by allowing the user to select whether they want to output to a file or output to a URL, and makes it so file names are automatically generated like other recording outputs. If they choose to output to a file, it'll only require an output directory similarly to how other recording outputs work. They can select a directory to output to rather than being required to type in a full path and filename; the filename is automatically generated. The extension is also automatically retrieved from libff depending on the format selected. Otherwise if they have Output to URL selected, it'll show a simple edit box where they can type in the target URL.
2015-08-19 05:58:24 +02:00
if (ffmpegOutput) {
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
fileOutput = obs_output_create(
(API Change) libobs: Add hotkey data to *_create functions
2014-11-01 21:41:17 +01:00
"ffmpeg_output", "adv_ffmpeg_output", nullptr, nullptr);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
if (!fileOutput)
throw "Failed to create recording FFmpeg output "
"(advanced output)";
} else {
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
bool useReplayBuffer =
config_get_bool(main->Config(), "AdvOut", "RecRB");
if (useReplayBuffer) {
UI: Fix hotkey JSON error for Advanced Replay Buffer This matches the Simple output Replay Buffer hotkey code.
2022-01-08 03:34:40 +01:00
OBSDataAutoRelease hotkey;
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
const char *str = config_get_string(
main->Config(), "Hotkeys", "ReplayBuffer");
UI: Fix hotkey JSON error for Advanced Replay Buffer This matches the Simple output Replay Buffer hotkey code.
2022-01-08 03:34:40 +01:00
if (str)
hotkey = obs_data_create_from_json(str);
else
hotkey = nullptr;
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
replayBuffer = obs_output_create("replay_buffer",
Str("ReplayBuffer"),
nullptr, hotkey);
if (!replayBuffer)
throw "Failed to create replay buffer output "
"(simple output)";
signal_handler_t *signal =
obs_output_get_signal_handler(replayBuffer);
startReplayBuffer.Connect(signal, "start",
OBSStartReplayBuffer, this);
stopReplayBuffer.Connect(signal, "stop",
OBSStopReplayBuffer, this);
replayBufferStopping.Connect(signal, "stopping",
OBSReplayBufferStopping,
this);
UI: Fix replay buffer saved event in advanced mode AdvancedOutput::AdvancedOutput(OBSBasic *main_) lacked a proper event handler connection
2020-10-18 17:57:52 +02:00
replayBufferSaved.Connect(signal, "saved",
OBSReplayBufferSaved, this);
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
}
UI: Use ffmpeg muxer instead of flv by default This allows the ability to save different container formats, such as mp4, mkv, and ts files.
2015-05-29 08:27:06 +02:00
fileOutput = obs_output_create(
"ffmpeg_muxer", "adv_file_output", nullptr, nullptr);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
if (!fileOutput)
throw "Failed to create recording output "
"(advanced output)";
if (!useStreamEncoder) {
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
videoRecording = obs_video_encoder_create(
recordEncoder, "advanced_video_recording",
(API Change) libobs: Add hotkey data to *_create functions
2014-11-01 21:41:17 +01:00
recordEncSettings, nullptr);
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
if (!videoRecording)
throw "Failed to create recording video "
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
"encoder (advanced output)";
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_encoder_release(videoRecording);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
}
}
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
videoStreaming = obs_video_encoder_create(streamEncoder,
"advanced_video_stream",
streamEncSettings, nullptr);
if (!videoStreaming)
throw "Failed to create streaming video encoder "
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
"(advanced output)";
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_encoder_release(videoStreaming);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
UI: Determine rate control after creating encoders If the user hasn't specifically set a rate control and left OBS at the default of CBR, the settings loaded by GetDataFromJsonFile will not have a rate_control parameter present. This causes the replay buffer to think the user is in VBR mode and use the wrong settings for determining maximum buffer size. Fixes #2516.
2020-12-12 02:41:00 +01:00
const char *rate_control = obs_data_get_string(
useStreamEncoder ? streamEncSettings : recordEncSettings,
"rate_control");
if (!rate_control)
rate_control = "";
usesBitrate = astrcmpi(rate_control, "CBR") == 0 ||
astrcmpi(rate_control, "VBR") == 0 ||
astrcmpi(rate_control, "ABR") == 0;
UI: Increase maximum audio tracks to 6
2016-12-22 02:14:24 +01:00
for (int i = 0; i < MAX_AUDIO_MIXES; i++) {
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
char name[9];
sprintf(name, "adv_aac%d", i);
UI: Create best matching audio encoder for given bitrate
2015-07-02 10:00:22 +02:00
if (!CreateAACEncoder(aacTrack[i], aacEncoderID[i],
GetAudioBitrate(i), name, i))
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
throw "Failed to create audio encoder "
"(advanced output)";
}
UI: Make adv. streaming audio encoder independent Allows the ability to pause when streaming and recording use the same tracks in advanced output mode.
2019-07-04 18:47:56 +02:00
std::string id;
int streamTrack =
config_get_int(main->Config(), "AdvOut", "TrackIndex") - 1;
UI: Fix bug where FTL was using AAC instead of opus When the streaming audio track was separated from the recording tracks in advanced output mode in be8c06334, it mistakenly removed the opus audio encoder code when FTL is used. This restores that code.
2019-08-23 00:08:24 +02:00
if (!CreateAACEncoder(streamAudioEnc, id, GetAudioBitrate(streamTrack),
UI: Fix aac encoder name Was meant to be "adv" meaning advanced rather than "avc"
2020-12-03 09:57:47 +01:00
"adv_stream_aac", streamTrack))
UI: Make adv. streaming audio encoder independent Allows the ability to pause when streaming and recording use the same tracks in advanced output mode.
2019-07-04 18:47:56 +02:00
throw "Failed to create streaming audio encoder "
"(advanced output)";
UI: Add VOD track support in advanced output Adds a VOD track option (specific to Twitch) that allows a user to specify which audio track to use for their Twitch VODs, which uses a separate encoder to encode the track. This allows users the ability to choose what audio goes on their VOD, separately from the live stream.
2020-11-01 10:54:27 +01:00
id = "";
int vodTrack =
config_get_int(main->Config(), "AdvOut", "VodTrackIndex") - 1;
if (!CreateAACEncoder(streamArchiveEnc, id, GetAudioBitrate(vodTrack),
UI: Fix vod track not working with twitch soundtrack The vod track in advanced output mode would be overwritten by twitch soundtrack's vod track. Additionally, simple output mode would overwrite twitch's soundtrack vod track even when vod track was turned off in settings. So instead, if vod track is off, don't clear the secondary encoder unless it's explicitly our encoder. Additionally, make sure that advanced output mode's vod track encoder behaves consistently with simple output mode's vod track so it doesn't get overwritten.
2020-12-03 09:59:43 +01:00
ADV_ARCHIVE_NAME, vodTrack))
UI: Add VOD track support in advanced output Adds a VOD track option (specific to Twitch) that allows a user to specify which audio track to use for their Twitch VODs, which uses a separate encoder to encode the track. This allows users the ability to choose what audio goes on their VOD, separately from the live stream.
2020-11-01 10:54:27 +01:00
throw "Failed to create archive audio encoder "
"(advanced output)";
UI: Release recording/streaming signals before outputs
2015-07-04 08:00:21 +02:00
startRecording.Connect(obs_output_get_signal_handler(fileOutput),
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
"start", OBSStartRecording, this);
UI: Release recording/streaming signals before outputs
2015-07-04 08:00:21 +02:00
stopRecording.Connect(obs_output_get_signal_handler(fileOutput), "stop",
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
OBSStopRecording, this);
UI: Show "stopping" text on buttons when waiting for stop The new cutoff timing fix means that streaming/recording has to remain active for bit until the stream/recording has reached the expecting stop timestamp. This means that the buttons would continue to say "Stop streaming/recording" while waiting for the output to stop itself at the appropriate timing. So instead of letting it do that and confusing the user, the buttons will now say "stopping" when the button is pressed to indicate to the user that the stream/recording is in the process of stopping.
2016-06-22 10:47:08 +02:00
recordStopping.Connect(obs_output_get_signal_handler(fileOutput),
"stopping", OBSRecordStopping, this);
UI: Add automatic file splitting This commit implements a new feature to split recordings in split files in Advanced output mode. These basic settings are implemented. - Enable/disable the feature. Default is disabled. - Select a type of the limit, time or size. - Specifies the limit in seconds or MiB.
2021-10-03 12:06:46 +02:00
recordFileChanged.Connect(obs_output_get_signal_handler(fileOutput),
"file_changed", OBSRecordFileChanged, this);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
}
void AdvancedOutput::UpdateStreamSettings()
{
(API Change) Fix "apply service settings" functions API changed from: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); void obs_service_info::apply_encoder_settings(void *data obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); To: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); void obs_service_info::apply_encoder_settings(void *data obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); These changes make it so that instead of an encoder potentially being updated more than once with different settings, that these functions will be called for the specific settings being used, and the settings will be updated according to what's required by the service. This fixes that design flaw and ensures that there's no case where obs_encoder_update is called where the settings might not have service-specific settings applied.
2015-03-08 01:32:00 +01:00
bool applyServiceSettings = config_get_bool(main->Config(), "AdvOut",
"ApplyServiceSettings");
UI: Move "enforce" setting to "ignore" stream section Moves the "Enforce streaming service bitrate" option from simple output mode to the stream section, renames it to "Ignore streaming service setting recommendations" (inverting it). When trying to check it, it will now also display a message box warning the user that it's generally a not-so-good idea. Also displays recommended settings for the service.
2020-11-11 18:48:39 +01:00
bool enforceBitrate = !config_get_bool(main->Config(), "Stream1",
"IgnoreRecommended");
UI: Disable NVENC lookahead if dynamic bitrate on Lookahead causes playback issues when bitrate changes mid-stream. Bitrate can suddenly drop to 0, and other issues such as audio stuttering on Twitch have been observed. Turning off lookahead fixed the issue. Lookahead is normally off by default anyway.
2019-09-10 21:01:10 +02:00
bool dynBitrate =
config_get_bool(main->Config(), "Output", "DynamicBitrate");
const char *streamEncoder =
config_get_string(main->Config(), "AdvOut", "Encoder");
(API Change) Fix "apply service settings" functions API changed from: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); void obs_service_info::apply_encoder_settings(void *data obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); To: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); void obs_service_info::apply_encoder_settings(void *data obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); These changes make it so that instead of an encoder potentially being updated more than once with different settings, that these functions will be called for the specific settings being used, and the settings will be updated according to what's required by the service. This fixes that design flaw and ensures that there's no case where obs_encoder_update is called where the settings might not have service-specific settings applied.
2015-03-08 01:32:00 +01:00
UI: Add Profiles Adds setting profiles to the basic user interface. For each profile, a subdirectory for the profile will be created in [config_dir]/obs-studio/basic/profiles which will contain the settings data for each profile.
2015-06-24 04:38:01 +02:00
OBSData settings = GetDataFromJsonFile("streamEncoder.json");
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
ApplyEncoderDefaults(settings, videoStreaming);
(API Change) Fix "apply service settings" functions API changed from: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); void obs_service_info::apply_encoder_settings(void *data obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); To: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); void obs_service_info::apply_encoder_settings(void *data obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); These changes make it so that instead of an encoder potentially being updated more than once with different settings, that these functions will be called for the specific settings being used, and the settings will be updated according to what's required by the service. This fixes that design flaw and ensures that there's no case where obs_encoder_update is called where the settings might not have service-specific settings applied.
2015-03-08 01:32:00 +01:00
UI: Move "enforce" setting to "ignore" stream section Moves the "Enforce streaming service bitrate" option from simple output mode to the stream section, renames it to "Ignore streaming service setting recommendations" (inverting it). When trying to check it, it will now also display a message box warning the user that it's generally a not-so-good idea. Also displays recommended settings for the service.
2020-11-11 18:48:39 +01:00
if (applyServiceSettings) {
int bitrate = (int)obs_data_get_int(settings, "bitrate");
UI: Allow overriding keyframe interval if smaller Allows the ability to override the default keyframe interval via advanced output mode as long as that interval is smaller than the recommended keyframe interval. Fixes an issue where it was impossible to set a lower keyframe interval than the recommended keyframe interval.
2021-08-25 04:41:43 +02:00
int keyint_sec = (int)obs_data_get_int(settings, "keyint_sec");
(API Change) Fix "apply service settings" functions API changed from: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); void obs_service_info::apply_encoder_settings(void *data obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); To: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); void obs_service_info::apply_encoder_settings(void *data obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); These changes make it so that instead of an encoder potentially being updated more than once with different settings, that these functions will be called for the specific settings being used, and the settings will be updated according to what's required by the service. This fixes that design flaw and ensures that there's no case where obs_encoder_update is called where the settings might not have service-specific settings applied.
2015-03-08 01:32:00 +01:00
obs_service_apply_encoder_settings(main->GetService(), settings,
nullptr);
UI: Move "enforce" setting to "ignore" stream section Moves the "Enforce streaming service bitrate" option from simple output mode to the stream section, renames it to "Ignore streaming service setting recommendations" (inverting it). When trying to check it, it will now also display a message box warning the user that it's generally a not-so-good idea. Also displays recommended settings for the service.
2020-11-11 18:48:39 +01:00
if (!enforceBitrate)
obs_data_set_int(settings, "bitrate", bitrate);
UI: Allow overriding keyframe interval if smaller Allows the ability to override the default keyframe interval via advanced output mode as long as that interval is smaller than the recommended keyframe interval. Fixes an issue where it was impossible to set a lower keyframe interval than the recommended keyframe interval.
2021-08-25 04:41:43 +02:00
int enforced_keyint_sec =
(int)obs_data_get_int(settings, "keyint_sec");
if (keyint_sec != 0 && keyint_sec < enforced_keyint_sec)
obs_data_set_int(settings, "keyint_sec", keyint_sec);
UI: Move "enforce" setting to "ignore" stream section Moves the "Enforce streaming service bitrate" option from simple output mode to the stream section, renames it to "Ignore streaming service setting recommendations" (inverting it). When trying to check it, it will now also display a message box warning the user that it's generally a not-so-good idea. Also displays recommended settings for the service.
2020-11-11 18:48:39 +01:00
}
(API Change) Fix "apply service settings" functions API changed from: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); void obs_service_info::apply_encoder_settings(void *data obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); To: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); void obs_service_info::apply_encoder_settings(void *data obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); These changes make it so that instead of an encoder potentially being updated more than once with different settings, that these functions will be called for the specific settings being used, and the settings will be updated according to what's required by the service. This fixes that design flaw and ensures that there's no case where obs_encoder_update is called where the settings might not have service-specific settings applied.
2015-03-08 01:32:00 +01:00
UI: Disable NVENC lookahead if dynamic bitrate on Lookahead causes playback issues when bitrate changes mid-stream. Bitrate can suddenly drop to 0, and other issues such as audio stuttering on Twitch have been observed. Turning off lookahead fixed the issue. Lookahead is normally off by default anyway.
2019-09-10 21:01:10 +02:00
if (dynBitrate && astrcmpi(streamEncoder, "jim_nvenc") == 0)
obs_data_set_bool(settings, "lookahead", false);
UI: Ensure NV12/I420 format for streaming encoder Due to the fact that flash cannot decode formats such as YUV 4:4:4, do not allow the streaming encoders to use formats other than NV12/I420.
2015-04-17 11:48:06 +02:00
video_t *video = obs_get_video();
enum video_format format = video_output_get_format(video);
UI: Do not prefer NV12 for I010/P010 Can cause videos to save as 8-bit.
2022-04-29 18:45:56 +02:00
switch (format) {
case VIDEO_FORMAT_I420:
case VIDEO_FORMAT_NV12:
case VIDEO_FORMAT_I010:
case VIDEO_FORMAT_P010:
break;
default:
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_encoder_set_preferred_video_format(videoStreaming,
UI: Ensure NV12/I420 format for streaming encoder Due to the fact that flash cannot decode formats such as YUV 4:4:4, do not allow the streaming encoders to use formats other than NV12/I420.
2015-04-17 11:48:06 +02:00
VIDEO_FORMAT_NV12);
UI: Do not prefer NV12 for I010/P010 Can cause videos to save as 8-bit.
2022-04-29 18:45:56 +02:00
}
UI: Ensure NV12/I420 format for streaming encoder Due to the fact that flash cannot decode formats such as YUV 4:4:4, do not allow the streaming encoders to use formats other than NV12/I420.
2015-04-17 11:48:06 +02:00
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_encoder_update(videoStreaming, settings);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
}
inline void AdvancedOutput::UpdateRecordingSettings()
{
UI: Add Profiles Adds setting profiles to the basic user interface. For each profile, a subdirectory for the profile will be created in [config_dir]/obs-studio/basic/profiles which will contain the settings data for each profile.
2015-06-24 04:38:01 +02:00
OBSData settings = GetDataFromJsonFile("recordEncoder.json");
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_encoder_update(videoRecording, settings);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
}
void AdvancedOutput::Update()
{
UpdateStreamSettings();
UI: Allow generated filenames for FFmpeg output This changes the way the advanced output section's FFmpeg output settings work by allowing the user to select whether they want to output to a file or output to a URL, and makes it so file names are automatically generated like other recording outputs. If they choose to output to a file, it'll only require an output directory similarly to how other recording outputs work. They can select a directory to output to rather than being required to type in a full path and filename; the filename is automatically generated. The extension is also automatically retrieved from libff depending on the format selected. Otherwise if they have Output to URL selected, it'll show a simple edit box where they can type in the target URL.
2015-08-19 05:58:24 +02:00
if (!useStreamEncoder && !ffmpegOutput)
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
UpdateRecordingSettings();
(API Change) Fix "apply service settings" functions API changed from: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); void obs_service_info::apply_encoder_settings(void *data obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); To: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); void obs_service_info::apply_encoder_settings(void *data obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); These changes make it so that instead of an encoder potentially being updated more than once with different settings, that these functions will be called for the specific settings being used, and the settings will be updated according to what's required by the service. This fixes that design flaw and ensures that there's no case where obs_encoder_update is called where the settings might not have service-specific settings applied.
2015-03-08 01:32:00 +01:00
UpdateAudioSettings();
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
}
UI: Add VOD track support in advanced output Adds a VOD track option (specific to Twitch) that allows a user to specify which audio track to use for their Twitch VODs, which uses a separate encoder to encode the track. This allows users the ability to choose what audio goes on their VOD, separately from the live stream.
2020-11-01 10:54:27 +01:00
static inline bool ServiceSupportsVodTrack(const char *service)
{
static const char *vodTrackServices[] = {"Twitch"};
for (const char *vodTrackService : vodTrackServices) {
if (astrcmpi(vodTrackService, service) == 0)
return true;
}
return false;
}
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
inline void AdvancedOutput::SetupStreaming()
{
bool rescale = config_get_bool(main->Config(), "AdvOut", "Rescale");
const char *rescaleRes =
config_get_string(main->Config(), "AdvOut", "RescaleRes");
unsigned int cx = 0;
unsigned int cy = 0;
UI: Ensure rescale res is non-null and length > 0
2015-03-31 22:48:06 +02:00
if (rescale && rescaleRes && *rescaleRes) {
if (sscanf(rescaleRes, "%ux%u", &cx, &cy) != 2) {
cx = 0;
cy = 0;
}
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
}
UI: Don't set audio encoder track index in Adv Output The audio track should always be 0 for RTMP output. The previous code accidentally used the audio track index to set the encoder track index. If the chosen audio track was track 2, this enabled the experimental multi-track RTMP output code. This then caused streams to fail as if there were network problems, as popular RTMP services like Twitch don't understand the multi-track RTMP stream and the connection hangs.
2020-02-23 00:17:55 +01:00
obs_output_set_audio_encoder(streamOutput, streamAudioEnc, 0);
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_encoder_set_scaled_size(videoStreaming, cx, cy);
obs_encoder_set_video(videoStreaming, obs_get_video());
UI: Apply custom_rtmp service settings to srt output
2020-04-16 23:57:37 +02:00
const char *id = obs_service_get_id(main->GetService());
if (strcmp(id, "rtmp_custom") == 0) {
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease settings = obs_data_create();
UI: Apply custom_rtmp service settings to srt output
2020-04-16 23:57:37 +02:00
obs_service_apply_encoder_settings(main->GetService(), settings,
nullptr);
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_encoder_update(videoStreaming, settings);
UI: Apply custom_rtmp service settings to srt output
2020-04-16 23:57:37 +02:00
}
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
}
inline void AdvancedOutput::SetupRecording()
{
const char *path =
config_get_string(main->Config(), "AdvOut", "RecFilePath");
UI: Add custom muxer settings for ffmpeg-mux
2015-11-23 15:36:06 +01:00
const char *mux =
config_get_string(main->Config(), "AdvOut", "RecMuxerCustom");
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
bool rescale = config_get_bool(main->Config(), "AdvOut", "RecRescale");
const char *rescaleRes =
config_get_string(main->Config(), "AdvOut", "RecRescaleRes");
UI: Use radio buttons for FLV track selection
2019-07-23 14:20:13 +02:00
int tracks;
const char *recFormat =
config_get_string(main->Config(), "AdvOut", "RecFormat");
bool flv = strcmp(recFormat, "flv") == 0;
if (flv)
tracks = config_get_int(main->Config(), "AdvOut", "FLVTrack");
else
tracks = config_get_int(main->Config(), "AdvOut", "RecTracks");
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease settings = obs_data_create();
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
unsigned int cx = 0;
unsigned int cy = 0;
UI: Allow multi-track recording in advanced output
2015-05-31 06:45:14 +02:00
int idx = 0;
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
UI: Use stream track if no tracks are selected
2019-06-18 00:52:30 +02:00
if (tracks == 0)
tracks = config_get_int(main->Config(), "AdvOut", "TrackIndex");
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
if (useStreamEncoder) {
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_output_set_video_encoder(fileOutput, videoStreaming);
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
if (replayBuffer)
obs_output_set_video_encoder(replayBuffer,
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
videoStreaming);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
} else {
UI: Ensure rescale res is non-null and length > 0
2015-03-31 22:48:06 +02:00
if (rescale && rescaleRes && *rescaleRes) {
if (sscanf(rescaleRes, "%ux%u", &cx, &cy) != 2) {
cx = 0;
cy = 0;
}
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
}
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_encoder_set_scaled_size(videoRecording, cx, cy);
obs_encoder_set_video(videoRecording, obs_get_video());
obs_output_set_video_encoder(fileOutput, videoRecording);
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
if (replayBuffer)
obs_output_set_video_encoder(replayBuffer,
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
videoRecording);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
}
UI: Use radio buttons for FLV track selection
2019-07-23 14:20:13 +02:00
if (!flv) {
for (int i = 0; i < MAX_AUDIO_MIXES; i++) {
if ((tracks & (1 << i)) != 0) {
obs_output_set_audio_encoder(fileOutput,
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
aacTrack[i], idx);
UI: Use radio buttons for FLV track selection
2019-07-23 14:20:13 +02:00
if (replayBuffer)
obs_output_set_audio_encoder(
replayBuffer, aacTrack[i], idx);
idx++;
}
UI: Allow multi-track recording in advanced output
2015-05-31 06:45:14 +02:00
}
UI: Use radio buttons for FLV track selection
2019-07-23 14:20:13 +02:00
} else if (flv && tracks != 0) {
obs_output_set_audio_encoder(fileOutput, aacTrack[tracks - 1],
idx);
if (replayBuffer)
obs_output_set_audio_encoder(replayBuffer,
aacTrack[tracks - 1], idx);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
}
obs_data_set_string(settings, "path", path);
UI: Add custom muxer settings for ffmpeg-mux
2015-11-23 15:36:06 +01:00
obs_data_set_string(settings, "muxer_settings", mux);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
obs_output_update(fileOutput, settings);
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
if (replayBuffer)
obs_output_update(replayBuffer, settings);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
}
inline void AdvancedOutput::SetupFFmpeg()
{
const char *url = config_get_string(main->Config(), "AdvOut", "FFURL");
int vBitrate = config_get_int(main->Config(), "AdvOut", "FFVBitrate");
UI: Add gop size option for custom ffmpeg output Closes jp9000/obs-studio#804
2017-02-17 17:25:21 +01:00
int gopSize = config_get_int(main->Config(), "AdvOut", "FFVGOPSize");
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
bool rescale = config_get_bool(main->Config(), "AdvOut", "FFRescale");
const char *rescaleRes =
config_get_string(main->Config(), "AdvOut", "FFRescaleRes");
UI: Add Format, Audio and Video ComboBoxes Adds ComboBoxes for selecting format and audio/video codecs. The ComboBoxes also show only valid codec combinations for a particular container format.
2015-03-28 08:21:16 +01:00
const char *formatName =
config_get_string(main->Config(), "AdvOut", "FFFormat");
const char *mimeType =
config_get_string(main->Config(), "AdvOut", "FFFormatMimeType");
UI: Add custom muxer settings to advanced FFmpeg output
2015-09-16 10:26:48 +02:00
const char *muxCustom =
config_get_string(main->Config(), "AdvOut", "FFMCustom");
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
const char *vEncoder =
config_get_string(main->Config(), "AdvOut", "FFVEncoder");
UI: Add Format, Audio and Video ComboBoxes Adds ComboBoxes for selecting format and audio/video codecs. The ComboBoxes also show only valid codec combinations for a particular container format.
2015-03-28 08:21:16 +01:00
int vEncoderId =
config_get_int(main->Config(), "AdvOut", "FFVEncoderId");
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
const char *vEncCustom =
config_get_string(main->Config(), "AdvOut", "FFVCustom");
int aBitrate = config_get_int(main->Config(), "AdvOut", "FFABitrate");
UI: Add multi-track FFmpeg output support
2018-10-05 05:06:54 +02:00
int aMixes = config_get_int(main->Config(), "AdvOut", "FFAudioMixes");
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
const char *aEncoder =
config_get_string(main->Config(), "AdvOut", "FFAEncoder");
UI: Add Format, Audio and Video ComboBoxes Adds ComboBoxes for selecting format and audio/video codecs. The ComboBoxes also show only valid codec combinations for a particular container format.
2015-03-28 08:21:16 +01:00
int aEncoderId =
config_get_int(main->Config(), "AdvOut", "FFAEncoderId");
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
const char *aEncCustom =
config_get_string(main->Config(), "AdvOut", "FFACustom");
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease settings = obs_data_create();
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
obs_data_set_string(settings, "url", url);
UI: Add Format, Audio and Video ComboBoxes Adds ComboBoxes for selecting format and audio/video codecs. The ComboBoxes also show only valid codec combinations for a particular container format.
2015-03-28 08:21:16 +01:00
obs_data_set_string(settings, "format_name", formatName);
obs_data_set_string(settings, "format_mime_type", mimeType);
UI: Add custom muxer settings to advanced FFmpeg output
2015-09-16 10:26:48 +02:00
obs_data_set_string(settings, "muxer_settings", muxCustom);
UI: Add gop size option for custom ffmpeg output Closes jp9000/obs-studio#804
2017-02-17 17:25:21 +01:00
obs_data_set_int(settings, "gop_size", gopSize);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
obs_data_set_int(settings, "video_bitrate", vBitrate);
obs_data_set_string(settings, "video_encoder", vEncoder);
UI: Add Format, Audio and Video ComboBoxes Adds ComboBoxes for selecting format and audio/video codecs. The ComboBoxes also show only valid codec combinations for a particular container format.
2015-03-28 08:21:16 +01:00
obs_data_set_int(settings, "video_encoder_id", vEncoderId);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
obs_data_set_string(settings, "video_settings", vEncCustom);
obs_data_set_int(settings, "audio_bitrate", aBitrate);
obs_data_set_string(settings, "audio_encoder", aEncoder);
UI: Add Format, Audio and Video ComboBoxes Adds ComboBoxes for selecting format and audio/video codecs. The ComboBoxes also show only valid codec combinations for a particular container format.
2015-03-28 08:21:16 +01:00
obs_data_set_int(settings, "audio_encoder_id", aEncoderId);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
obs_data_set_string(settings, "audio_settings", aEncCustom);
if (rescale && rescaleRes && *rescaleRes) {
int width;
int height;
int val = sscanf(rescaleRes, "%dx%d", &width, &height);
if (val == 2 && width && height) {
obs_data_set_int(settings, "scale_width", width);
obs_data_set_int(settings, "scale_height", height);
}
}
UI: Add multi-track FFmpeg output support
2018-10-05 05:06:54 +02:00
obs_output_set_mixers(fileOutput, aMixes);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
obs_output_set_media(fileOutput, obs_get_video(), obs_get_audio());
obs_output_update(fileOutput, settings);
}
static inline void SetEncoderName(obs_encoder_t *encoder, const char *name,
const char *defaultName)
{
obs_encoder_set_name(encoder, (name && *name) ? name : defaultName);
}
(API Change) Fix "apply service settings" functions API changed from: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); void obs_service_info::apply_encoder_settings(void *data obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); To: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); void obs_service_info::apply_encoder_settings(void *data obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); These changes make it so that instead of an encoder potentially being updated more than once with different settings, that these functions will be called for the specific settings being used, and the settings will be updated according to what's required by the service. This fixes that design flaw and ensures that there's no case where obs_encoder_update is called where the settings might not have service-specific settings applied.
2015-03-08 01:32:00 +01:00
inline void AdvancedOutput::UpdateAudioSettings()
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
{
(API Change) Fix "apply service settings" functions API changed from: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); void obs_service_info::apply_encoder_settings(void *data obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); To: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); void obs_service_info::apply_encoder_settings(void *data obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); These changes make it so that instead of an encoder potentially being updated more than once with different settings, that these functions will be called for the specific settings being used, and the settings will be updated according to what's required by the service. This fixes that design flaw and ensures that there's no case where obs_encoder_update is called where the settings might not have service-specific settings applied.
2015-03-08 01:32:00 +01:00
bool applyServiceSettings = config_get_bool(main->Config(), "AdvOut",
"ApplyServiceSettings");
UI: Move "enforce" setting to "ignore" stream section Moves the "Enforce streaming service bitrate" option from simple output mode to the stream section, renames it to "Ignore streaming service setting recommendations" (inverting it). When trying to check it, it will now also display a message box warning the user that it's generally a not-so-good idea. Also displays recommended settings for the service.
2020-11-11 18:48:39 +01:00
bool enforceBitrate = !config_get_bool(main->Config(), "Stream1",
"IgnoreRecommended");
UI: Only apply service settings to stream encoder All audio encoders are currently having the service-specific settings applied to them, so this makes it so that it checks which track the stream is set to and only applies it to that specific encoder.
2015-03-27 20:38:38 +01:00
int streamTrackIndex =
config_get_int(main->Config(), "AdvOut", "TrackIndex");
UI: Add VOD track support in advanced output Adds a VOD track option (specific to Twitch) that allows a user to specify which audio track to use for their Twitch VODs, which uses a separate encoder to encode the track. This allows users the ability to choose what audio goes on their VOD, separately from the live stream.
2020-11-01 10:54:27 +01:00
int vodTrackIndex =
config_get_int(main->Config(), "AdvOut", "VodTrackIndex");
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease settings[MAX_AUDIO_MIXES];
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
UI: Increase maximum audio tracks to 6
2016-12-22 02:14:24 +01:00
for (size_t i = 0; i < MAX_AUDIO_MIXES; i++) {
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
settings[i] = obs_data_create();
UI: Move output handler audio bitrate config access
2015-07-02 09:58:28 +02:00
obs_data_set_int(settings[i], "bitrate", GetAudioBitrate(i));
}
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
UI: Increase maximum audio tracks to 6
2016-12-22 02:14:24 +01:00
for (size_t i = 0; i < MAX_AUDIO_MIXES; i++) {
string cfg_name = "Track";
cfg_name += to_string((int)i + 1);
cfg_name += "Name";
const char *name = config_get_string(main->Config(), "AdvOut",
cfg_name.c_str());
string def_name = "Track";
def_name += to_string((int)i + 1);
SetEncoderName(aacTrack[i], name, def_name.c_str());
}
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
UI: Increase maximum audio tracks to 6
2016-12-22 02:14:24 +01:00
for (size_t i = 0; i < MAX_AUDIO_MIXES; i++) {
UI: Add VOD track support in advanced output Adds a VOD track option (specific to Twitch) that allows a user to specify which audio track to use for their Twitch VODs, which uses a separate encoder to encode the track. This allows users the ability to choose what audio goes on their VOD, separately from the live stream.
2020-11-01 10:54:27 +01:00
int track = (int)(i + 1);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
obs_encoder_update(aacTrack[i], settings[i]);
UI: Make adv. streaming audio encoder independent Allows the ability to pause when streaming and recording use the same tracks in advanced output mode.
2019-07-04 18:47:56 +02:00
UI: Add VOD track support in advanced output Adds a VOD track option (specific to Twitch) that allows a user to specify which audio track to use for their Twitch VODs, which uses a separate encoder to encode the track. This allows users the ability to choose what audio goes on their VOD, separately from the live stream.
2020-11-01 10:54:27 +01:00
if (track == streamTrackIndex || track == vodTrackIndex) {
UI: Make adv. streaming audio encoder independent Allows the ability to pause when streaming and recording use the same tracks in advanced output mode.
2019-07-04 18:47:56 +02:00
if (applyServiceSettings) {
UI: Move "enforce" setting to "ignore" stream section Moves the "Enforce streaming service bitrate" option from simple output mode to the stream section, renames it to "Ignore streaming service setting recommendations" (inverting it). When trying to check it, it will now also display a message box warning the user that it's generally a not-so-good idea. Also displays recommended settings for the service.
2020-11-11 18:48:39 +01:00
int bitrate = (int)obs_data_get_int(settings[i],
"bitrate");
UI: Make adv. streaming audio encoder independent Allows the ability to pause when streaming and recording use the same tracks in advanced output mode.
2019-07-04 18:47:56 +02:00
obs_service_apply_encoder_settings(
main->GetService(), nullptr,
settings[i]);
UI: Move "enforce" setting to "ignore" stream section Moves the "Enforce streaming service bitrate" option from simple output mode to the stream section, renames it to "Ignore streaming service setting recommendations" (inverting it). When trying to check it, it will now also display a message box warning the user that it's generally a not-so-good idea. Also displays recommended settings for the service.
2020-11-11 18:48:39 +01:00
if (!enforceBitrate)
obs_data_set_int(settings[i], "bitrate",
bitrate);
UI: Make adv. streaming audio encoder independent Allows the ability to pause when streaming and recording use the same tracks in advanced output mode.
2019-07-04 18:47:56 +02:00
}
UI: Add VOD track support in advanced output Adds a VOD track option (specific to Twitch) that allows a user to specify which audio track to use for their Twitch VODs, which uses a separate encoder to encode the track. This allows users the ability to choose what audio goes on their VOD, separately from the live stream.
2020-11-01 10:54:27 +01:00
}
UI: Make adv. streaming audio encoder independent Allows the ability to pause when streaming and recording use the same tracks in advanced output mode.
2019-07-04 18:47:56 +02:00
UI: Add VOD track support in advanced output Adds a VOD track option (specific to Twitch) that allows a user to specify which audio track to use for their Twitch VODs, which uses a separate encoder to encode the track. This allows users the ability to choose what audio goes on their VOD, separately from the live stream.
2020-11-01 10:54:27 +01:00
if (track == streamTrackIndex)
UI: Fix bug where FTL was using AAC instead of opus When the streaming audio track was separated from the recording tracks in advanced output mode in be8c06334, it mistakenly removed the opus audio encoder code when FTL is used. This restores that code.
2019-08-23 00:08:24 +02:00
obs_encoder_update(streamAudioEnc, settings[i]);
UI: Add VOD track support in advanced output Adds a VOD track option (specific to Twitch) that allows a user to specify which audio track to use for their Twitch VODs, which uses a separate encoder to encode the track. This allows users the ability to choose what audio goes on their VOD, separately from the live stream.
2020-11-01 10:54:27 +01:00
if (track == vodTrackIndex)
obs_encoder_update(streamArchiveEnc, settings[i]);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
}
}
void AdvancedOutput::SetupOutputs()
{
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_encoder_set_video(videoStreaming, obs_get_video());
if (videoRecording)
obs_encoder_set_video(videoRecording, obs_get_video());
UI: Increase maximum audio tracks to 6
2016-12-22 02:14:24 +01:00
for (size_t i = 0; i < MAX_AUDIO_MIXES; i++)
obs_encoder_set_audio(aacTrack[i], obs_get_audio());
UI: Fix bug where FTL was using AAC instead of opus When the streaming audio track was separated from the recording tracks in advanced output mode in be8c06334, it mistakenly removed the opus audio encoder code when FTL is used. This restores that code.
2019-08-23 00:08:24 +02:00
obs_encoder_set_audio(streamAudioEnc, obs_get_audio());
UI: Add VOD track support in advanced output Adds a VOD track option (specific to Twitch) that allows a user to specify which audio track to use for their Twitch VODs, which uses a separate encoder to encode the track. This allows users the ability to choose what audio goes on their VOD, separately from the live stream.
2020-11-01 10:54:27 +01:00
obs_encoder_set_audio(streamArchiveEnc, obs_get_audio());
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
SetupStreaming();
UI: Allow generated filenames for FFmpeg output This changes the way the advanced output section's FFmpeg output settings work by allowing the user to select whether they want to output to a file or output to a URL, and makes it so file names are automatically generated like other recording outputs. If they choose to output to a file, it'll only require an output directory similarly to how other recording outputs work. They can select a directory to output to rather than being required to type in a full path and filename; the filename is automatically generated. The extension is also automatically retrieved from libff depending on the format selected. Otherwise if they have Output to URL selected, it'll show a simple edit box where they can type in the target URL.
2015-08-19 05:58:24 +02:00
if (ffmpegOutput)
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
SetupFFmpeg();
else
SetupRecording();
}
UI: Move output handler audio bitrate config access
2015-07-02 09:58:28 +02:00
int AdvancedOutput::GetAudioBitrate(size_t i) const
{
UI: Increase maximum audio tracks to 6
2016-12-22 02:14:24 +01:00
static const char *names[] = {
UI: Move output handler audio bitrate config access
2015-07-02 09:58:28 +02:00
"Track1Bitrate", "Track2Bitrate", "Track3Bitrate",
UI: Increase maximum audio tracks to 6
2016-12-22 02:14:24 +01:00
"Track4Bitrate", "Track5Bitrate", "Track6Bitrate",
UI: Move output handler audio bitrate config access
2015-07-02 09:58:28 +02:00
};
UI: If audio bitrate not available, use closest When an encoder has been removed (such as CoreAudio) and the audio bitrates currently configured no longer are available to the current audio encoders anymore, it would cause GetAACEncoderForBitrate to return false with no encoder available. To fix the issue, instead just choose the closest bitrate relative to the current bitrate (rounded up).
2015-09-22 03:36:26 +02:00
int bitrate = (int)config_get_uint(main->Config(), "AdvOut", names[i]);
return FindClosestAvailableAACBitrate(bitrate);
UI: Move output handler audio bitrate config access
2015-07-02 09:58:28 +02:00
}
UI: Fix vod track not working with twitch soundtrack The vod track in advanced output mode would be overwritten by twitch soundtrack's vod track. Additionally, simple output mode would overwrite twitch's soundtrack vod track even when vod track was turned off in settings. So instead, if vod track is off, don't clear the secondary encoder unless it's explicitly our encoder. Additionally, make sure that advanced output mode's vod track encoder behaves consistently with simple output mode's vod track so it doesn't get overwritten.
2020-12-03 09:59:43 +01:00
inline void AdvancedOutput::SetupVodTrack(obs_service_t *service)
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
{
UI: Fix bug where FTL was using AAC instead of opus When the streaming audio track was separated from the recording tracks in advanced output mode in be8c06334, it mistakenly removed the opus audio encoder code when FTL is used. This restores that code.
2019-08-23 00:08:24 +02:00
int streamTrack =
UI: Add VOD track support in advanced output Adds a VOD track option (specific to Twitch) that allows a user to specify which audio track to use for their Twitch VODs, which uses a separate encoder to encode the track. This allows users the ability to choose what audio goes on their VOD, separately from the live stream.
2020-11-01 10:54:27 +01:00
config_get_int(main->Config(), "AdvOut", "TrackIndex");
bool vodTrackEnabled =
config_get_bool(main->Config(), "AdvOut", "VodTrackEnabled");
int vodTrackIndex =
config_get_int(main->Config(), "AdvOut", "VodTrackIndex");
UI: Allow enabling vod track on custom via ini
2020-12-03 10:31:32 +01:00
bool enableForCustomServer = config_get_bool(
GetGlobalConfig(), "General", "EnableCustomServerVodTrack");
UI: Fix bug where FTL was using AAC instead of opus When the streaming audio track was separated from the recording tracks in advanced output mode in be8c06334, it mistakenly removed the opus audio encoder code when FTL is used. This restores that code.
2019-08-23 00:08:24 +02:00
UI: Fix vod track not working with twitch soundtrack The vod track in advanced output mode would be overwritten by twitch soundtrack's vod track. Additionally, simple output mode would overwrite twitch's soundtrack vod track even when vod track was turned off in settings. So instead, if vod track is off, don't clear the secondary encoder unless it's explicitly our encoder. Additionally, make sure that advanced output mode's vod track encoder behaves consistently with simple output mode's vod track so it doesn't get overwritten.
2020-12-03 09:59:43 +01:00
const char *id = obs_service_get_id(service);
if (strcmp(id, "rtmp_custom") == 0) {
UI: Allow enabling vod track on custom via ini
2020-12-03 10:31:32 +01:00
vodTrackEnabled = enableForCustomServer ? vodTrackEnabled
: false;
UI: Fix vod track not working with twitch soundtrack The vod track in advanced output mode would be overwritten by twitch soundtrack's vod track. Additionally, simple output mode would overwrite twitch's soundtrack vod track even when vod track was turned off in settings. So instead, if vod track is off, don't clear the secondary encoder unless it's explicitly our encoder. Additionally, make sure that advanced output mode's vod track encoder behaves consistently with simple output mode's vod track so it doesn't get overwritten.
2020-12-03 09:59:43 +01:00
} else {
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease settings = obs_service_get_settings(service);
UI: Fix vod track not working with twitch soundtrack The vod track in advanced output mode would be overwritten by twitch soundtrack's vod track. Additionally, simple output mode would overwrite twitch's soundtrack vod track even when vod track was turned off in settings. So instead, if vod track is off, don't clear the secondary encoder unless it's explicitly our encoder. Additionally, make sure that advanced output mode's vod track encoder behaves consistently with simple output mode's vod track so it doesn't get overwritten.
2020-12-03 09:59:43 +01:00
const char *service = obs_data_get_string(settings, "service");
if (!ServiceSupportsVodTrack(service))
vodTrackEnabled = false;
}
if (vodTrackEnabled && streamTrack != vodTrackIndex)
obs_output_set_audio_encoder(streamOutput, streamArchiveEnc, 1);
else
clear_archive_encoder(streamOutput, ADV_ARCHIVE_NAME);
}
bool AdvancedOutput::SetupStreaming(obs_service_t *service)
{
int streamTrack =
config_get_int(main->Config(), "AdvOut", "TrackIndex");
UI: Prevent re-updating of the stream encoder Using advanced output mode, the stream encoder could be updated with the same settings, causing the encoder to output those changes unnecessarily.
2015-02-15 03:10:39 +01:00
if (!useStreamEncoder ||
UI: Allow generated filenames for FFmpeg output This changes the way the advanced output section's FFmpeg output settings work by allowing the user to select whether they want to output to a file or output to a URL, and makes it so file names are automatically generated like other recording outputs. If they choose to output to a file, it'll only require an output directory similarly to how other recording outputs work. They can select a directory to output to rather than being required to type in a full path and filename; the filename is automatically generated. The extension is also automatically retrieved from libff depending on the format selected. Otherwise if they have Output to URL selected, it'll show a simple edit box where they can type in the target URL.
2015-08-19 05:58:24 +02:00
(!ffmpegOutput && !obs_output_active(fileOutput))) {
UI: Prevent re-updating of the stream encoder Using advanced output mode, the stream encoder could be updated with the same settings, causing the encoder to output those changes unnecessarily.
2015-02-15 03:10:39 +01:00
UpdateStreamSettings();
}
(API Change) Fix "apply service settings" functions API changed from: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); void obs_service_info::apply_encoder_settings(void *data obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); To: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); void obs_service_info::apply_encoder_settings(void *data obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); These changes make it so that instead of an encoder potentially being updated more than once with different settings, that these functions will be called for the specific settings being used, and the settings will be updated according to what's required by the service. This fixes that design flaw and ensures that there's no case where obs_encoder_update is called where the settings might not have service-specific settings applied.
2015-03-08 01:32:00 +01:00
UpdateAudioSettings();
UI: Make SetupOutputs virtual instead of ignoring vcam In 218b936b1dae, the virtual camera was ignored when checking the active state, which is kind of a lackluster solution. Instead, this makes SetupOutputs() a virtual function, and calls it before starting the virtual camera to be more consistent with the rest of the outputs.
2020-09-03 15:56:03 +02:00
if (!Active())
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
SetupOutputs();
UI: Add Auth and OAuth classes Allows the ability to authenticate to a specific service. Typically via OAuth.
2019-02-07 07:24:25 +01:00
Auth *auth = main->GetAuth();
if (auth)
auth->OnStreamConfig();
UI: Allow services to use different outputs Allows a service to specify the output it needs in order to function as configured. NOTE: This functionality should be considered temporary as a seamless means of implementing support for different output types within the same service. Ideally, different services should be used for this functionality.
2017-07-13 12:57:42 +02:00
/* --------------------- */
const char *type = obs_service_get_output_type(service);
UI: Use new ffmpeg-encoded-output for non-RTMP urls
2019-04-19 20:58:31 +02:00
if (!type) {
UI: Allow services to use different outputs Allows a service to specify the output it needs in order to function as configured. NOTE: This functionality should be considered temporary as a seamless means of implementing support for different output types within the same service. Ideally, different services should be used for this functionality.
2017-07-13 12:57:42 +02:00
type = "rtmp_output";
UI: Use new ffmpeg-encoded-output for non-RTMP urls
2019-04-19 20:58:31 +02:00
const char *url = obs_service_get_url(service);
if (url != NULL &&
UI: Support FTL URLs for custom streaming service Custom streaming service URLs beginning with `ftl` are handled by the `ftl_output` plugin.
2020-12-06 10:54:29 +01:00
strncmp(url, FTL_PROTOCOL, strlen(FTL_PROTOCOL)) == 0) {
type = "ftl_output";
} else if (url != NULL && strncmp(url, RTMP_PROTOCOL,
strlen(RTMP_PROTOCOL)) != 0) {
UI: Swap to new srt output Redirect non rtmp streaming to ffmpeg-mux instead of previous ffmpeg-encoded-output which has been removed.
2020-03-25 16:21:31 +01:00
type = "ffmpeg_mpegts_muxer";
UI: Use new ffmpeg-encoded-output for non-RTMP urls
2019-04-19 20:58:31 +02:00
}
}
UI: Allow services to use different outputs Allows a service to specify the output it needs in order to function as configured. NOTE: This functionality should be considered temporary as a seamless means of implementing support for different output types within the same service. Ideally, different services should be used for this functionality.
2017-07-13 12:57:42 +02:00
/* XXX: this is messy and disgusting and should be refactored */
if (outputType != type) {
UI: Fix potential crash when outputs change If the service settings change and the output type changes, the previous signals would attempt to disconnect after the output has been destroyed, and subsequently that would cause a crash.
2017-07-26 04:01:29 +02:00
streamDelayStarting.Disconnect();
streamStopping.Disconnect();
startStreaming.Disconnect();
stopStreaming.Disconnect();
UI: Allow services to use different outputs Allows a service to specify the output it needs in order to function as configured. NOTE: This functionality should be considered temporary as a seamless means of implementing support for different output types within the same service. Ideally, different services should be used for this functionality.
2017-07-13 12:57:42 +02:00
streamOutput =
obs_output_create(type, "adv_stream", nullptr, nullptr);
UI: Log generic stream startup failures These code paths had no logging on failure, resulting in a log file that would confuse people attempting to perform support for users.
2017-10-06 13:48:24 +02:00
if (!streamOutput) {
blog(LOG_WARNING,
"Creation of stream output type '%s' "
"failed!",
type);
UI: Allow services to use different outputs Allows a service to specify the output it needs in order to function as configured. NOTE: This functionality should be considered temporary as a seamless means of implementing support for different output types within the same service. Ideally, different services should be used for this functionality.
2017-07-13 12:57:42 +02:00
return false;
UI: Log generic stream startup failures These code paths had no logging on failure, resulting in a log file that would confuse people attempting to perform support for users.
2017-10-06 13:48:24 +02:00
}
UI: Allow services to use different outputs Allows a service to specify the output it needs in order to function as configured. NOTE: This functionality should be considered temporary as a seamless means of implementing support for different output types within the same service. Ideally, different services should be used for this functionality.
2017-07-13 12:57:42 +02:00
streamDelayStarting.Connect(
obs_output_get_signal_handler(streamOutput), "starting",
OBSStreamStarting, this);
streamStopping.Connect(
obs_output_get_signal_handler(streamOutput), "stopping",
OBSStreamStopping, this);
startStreaming.Connect(
obs_output_get_signal_handler(streamOutput), "start",
OBSStartStreaming, this);
stopStreaming.Connect(
obs_output_get_signal_handler(streamOutput), "stop",
OBSStopStreaming, this);
UI: Fix unencoded stream failure A stream will fail to start if the output_info does not have an encoded_audio_codecs string, even if the output is not flagged as encoded. This allows unencoded outputs to omit that string.
2018-09-26 20:39:34 +02:00
bool isEncoded = obs_output_get_flags(streamOutput) &
OBS_OUTPUT_ENCODED;
UI: Allow outputs to use different audio codecs Allows an output to automatically specify which audio codec it requires and use it instead of AAC. This change is intended to be behind-the-scenes and seamless to the user.
2017-07-13 13:04:17 +02:00
UI: Fix unencoded stream failure A stream will fail to start if the output_info does not have an encoded_audio_codecs string, even if the output is not flagged as encoded. This allows unencoded outputs to omit that string.
2018-09-26 20:39:34 +02:00
if (isEncoded) {
const char *codec =
obs_output_get_supported_audio_codecs(
streamOutput);
if (!codec) {
blog(LOG_WARNING, "Failed to load audio codec");
UI: Allow outputs to use different audio codecs Allows an output to automatically specify which audio codec it requires and use it instead of AAC. This change is intended to be behind-the-scenes and seamless to the user.
2017-07-13 13:04:17 +02:00
return false;
UI: Fix unencoded stream failure A stream will fail to start if the output_info does not have an encoded_audio_codecs string, even if the output is not flagged as encoded. This allows unencoded outputs to omit that string.
2018-09-26 20:39:34 +02:00
}
UI: Fix bug where FTL was using AAC instead of opus When the streaming audio track was separated from the recording tracks in advanced output mode in be8c06334, it mistakenly removed the opus audio encoder code when FTL is used. This restores that code.
2019-08-23 00:08:24 +02:00
if (strcmp(codec, "aac") != 0) {
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease settings =
obs_encoder_get_settings(
streamAudioEnc);
UI: Fix bug where FTL was using AAC instead of opus When the streaming audio track was separated from the recording tracks in advanced output mode in be8c06334, it mistakenly removed the opus audio encoder code when FTL is used. This restores that code.
2019-08-23 00:08:24 +02:00
const char *id =
FindAudioEncoderFromCodec(codec);
streamAudioEnc = obs_audio_encoder_create(
id, "alt_audio_enc", nullptr,
UI: Add VOD track support in advanced output Adds a VOD track option (specific to Twitch) that allows a user to specify which audio track to use for their Twitch VODs, which uses a separate encoder to encode the track. This allows users the ability to choose what audio goes on their VOD, separately from the live stream.
2020-11-01 10:54:27 +01:00
streamTrack - 1, nullptr);
UI: Fix bug where FTL was using AAC instead of opus When the streaming audio track was separated from the recording tracks in advanced output mode in be8c06334, it mistakenly removed the opus audio encoder code when FTL is used. This restores that code.
2019-08-23 00:08:24 +02:00
if (!streamAudioEnc)
return false;
obs_encoder_release(streamAudioEnc);
obs_encoder_update(streamAudioEnc, settings);
obs_encoder_set_audio(streamAudioEnc,
obs_get_audio());
}
UI: Allow outputs to use different audio codecs Allows an output to automatically specify which audio codec it requires and use it instead of AAC. This change is intended to be behind-the-scenes and seamless to the user.
2017-07-13 13:04:17 +02:00
}
UI: Allow services to use different outputs Allows a service to specify the output it needs in order to function as configured. NOTE: This functionality should be considered temporary as a seamless means of implementing support for different output types within the same service. Ideally, different services should be used for this functionality.
2017-07-13 12:57:42 +02:00
outputType = type;
}
UI: Redo encoder names now that H.264 isn't alone The old names were simple_h264_recording, simple_h264_stream, recording_h264, and streaming_h264. The new names are simple_video_recording, simple_video_stream, advanced_video_recording, and advanced_video_stream.
2022-05-07 05:17:55 +02:00
obs_output_set_video_encoder(streamOutput, videoStreaming);
UI: Fix bug where FTL was using AAC instead of opus When the streaming audio track was separated from the recording tracks in advanced output mode in be8c06334, it mistakenly removed the opus audio encoder code when FTL is used. This restores that code.
2019-08-23 00:08:24 +02:00
obs_output_set_audio_encoder(streamOutput, streamAudioEnc, 0);
UI: Add VOD track support in advanced output Adds a VOD track option (specific to Twitch) that allows a user to specify which audio track to use for their Twitch VODs, which uses a separate encoder to encode the track. This allows users the ability to choose what audio goes on their VOD, separately from the live stream.
2020-11-01 10:54:27 +01:00
UI: Create output before calling start stream event Allows modifying the output OBS_FRONTEND_EVENT_STREAMING_STARTING.
2020-09-17 07:20:02 +02:00
return true;
}
UI: Allow services to use different outputs Allows a service to specify the output it needs in order to function as configured. NOTE: This functionality should be considered temporary as a seamless means of implementing support for different output types within the same service. Ideally, different services should be used for this functionality.
2017-07-13 12:57:42 +02:00
UI: Create output before calling start stream event Allows modifying the output OBS_FRONTEND_EVENT_STREAMING_STARTING.
2020-09-17 07:20:02 +02:00
bool AdvancedOutput::StartStreaming(obs_service_t *service)
{
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
obs_output_set_service(streamOutput, service);
UI: Move reconnect options to advanced settings This is mostly just to remove the unnecessary clutter from the output sections. The reconnect settings are generally rarely modified by users as it is.
2015-09-11 04:10:40 +02:00
bool reconnect = config_get_bool(main->Config(), "Output", "Reconnect");
int retryDelay = config_get_int(main->Config(), "Output", "RetryDelay");
int maxRetries = config_get_int(main->Config(), "Output", "MaxRetries");
UI: Implement stream delay When stream delay is active, the "Start/Stop Streaming" button is changed in to a menu button, which allows the user to select either the option to stop the stream (which causes it to count down), or forcibly stop the stream (which immediately stops the stream and cuts off all delayed data). If the user decides they want to start the stream again while in the process of counting down, they can safely do so without having to wait for it to stop, and it will schedule it to start up again with the same delay after the stop. On the status bar, it will now show whether delay is active, and its duration. If the stream is in the process of stopping/starting, it will count down to the stop/start. If the option to preserve stream cutoff point on unexpected disconnections/reconnections is enabled, it will update the current delay duration accordingly.
2015-09-07 01:19:53 +02:00
bool useDelay =
config_get_bool(main->Config(), "Output", "DelayEnable");
int delaySec = config_get_int(main->Config(), "Output", "DelaySec");
bool preserveDelay =
config_get_bool(main->Config(), "Output", "DelayPreserve");
UI: Add "Bind to IP" setting to advanced settings
2016-07-29 17:30:54 +02:00
const char *bindIP =
config_get_string(main->Config(), "Output", "BindIP");
UI: Add options for new socket loop
2017-02-22 02:05:45 +01:00
bool enableNewSocketLoop = config_get_bool(main->Config(), "Output",
"NewSocketLoopEnable");
bool enableLowLatencyMode =
config_get_bool(main->Config(), "Output", "LowLatencyEnable");
UI: Add dynamic bitrate support to the UI Adds dynamic bitrate support (marked as beta) to the advanced settings for now.
2019-08-15 17:50:09 +02:00
bool enableDynBitrate =
config_get_bool(main->Config(), "Output", "DynamicBitrate");
UI: Add "Bind to IP" setting to advanced settings
2016-07-29 17:30:54 +02:00
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease settings = obs_data_create();
UI: Add "Bind to IP" setting to advanced settings
2016-07-29 17:30:54 +02:00
obs_data_set_string(settings, "bind_ip", bindIP);
UI: Add options for new socket loop
2017-02-22 02:05:45 +01:00
obs_data_set_bool(settings, "new_socket_loop_enabled",
enableNewSocketLoop);
obs_data_set_bool(settings, "low_latency_mode_enabled",
enableLowLatencyMode);
UI: Add dynamic bitrate support to the UI Adds dynamic bitrate support (marked as beta) to the advanced settings for now.
2019-08-15 17:50:09 +02:00
obs_data_set_bool(settings, "dyn_bitrate", enableDynBitrate);
UI: Add "Bind to IP" setting to advanced settings
2016-07-29 17:30:54 +02:00
obs_output_update(streamOutput, settings);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
if (!reconnect)
maxRetries = 0;
UI: Implement stream delay When stream delay is active, the "Start/Stop Streaming" button is changed in to a menu button, which allows the user to select either the option to stop the stream (which causes it to count down), or forcibly stop the stream (which immediately stops the stream and cuts off all delayed data). If the user decides they want to start the stream again while in the process of counting down, they can safely do so without having to wait for it to stop, and it will schedule it to start up again with the same delay after the stop. On the status bar, it will now show whether delay is active, and its duration. If the stream is in the process of stopping/starting, it will count down to the stop/start. If the option to preserve stream cutoff point on unexpected disconnections/reconnections is enabled, it will update the current delay duration accordingly.
2015-09-07 01:19:53 +02:00
obs_output_set_delay(streamOutput, useDelay ? delaySec : 0,
preserveDelay ? OBS_OUTPUT_DELAY_PRESERVE : 0);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
obs_output_set_reconnect_settings(streamOutput, maxRetries, retryDelay);
UI: Fix vod track not working with twitch soundtrack The vod track in advanced output mode would be overwritten by twitch soundtrack's vod track. Additionally, simple output mode would overwrite twitch's soundtrack vod track even when vod track was turned off in settings. So instead, if vod track is off, don't clear the secondary encoder unless it's explicitly our encoder. Additionally, make sure that advanced output mode's vod track encoder behaves consistently with simple output mode's vod track so it doesn't get overwritten.
2020-12-03 09:59:43 +01:00
SetupVodTrack(service);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
if (obs_output_start(streamOutput)) {
return true;
}
UI: Log generic stream startup failures These code paths had no logging on failure, resulting in a log file that would confuse people attempting to perform support for users.
2017-10-06 13:48:24 +02:00
const char *error = obs_output_get_last_error(streamOutput);
UI: Show output's last error in failure dialog Logs the last output error if given.
2018-12-13 00:20:48 +01:00
bool hasLastError = error && *error;
if (hasLastError)
lastError = error;
else
lastError = string();
UI: Log generic stream startup failures These code paths had no logging on failure, resulting in a log file that would confuse people attempting to perform support for users.
2017-10-06 13:48:24 +02:00
UI: Create output before calling start stream event Allows modifying the output OBS_FRONTEND_EVENT_STREAMING_STARTING.
2020-09-17 07:20:02 +02:00
const char *type = obs_service_get_output_type(service);
UI: Show output's last error in failure dialog Logs the last output error if given.
2018-12-13 00:20:48 +01:00
blog(LOG_WARNING, "Stream output type '%s' failed to start!%s%s", type,
hasLastError ? " Last Error: " : "", hasLastError ? error : "");
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
return false;
}
bool AdvancedOutput::StartRecording()
{
UI: Allow generated filenames for FFmpeg output This changes the way the advanced output section's FFmpeg output settings work by allowing the user to select whether they want to output to a file or output to a URL, and makes it so file names are automatically generated like other recording outputs. If they choose to output to a file, it'll only require an output directory similarly to how other recording outputs work. They can select a directory to output to rather than being required to type in a full path and filename; the filename is automatically generated. The extension is also automatically retrieved from libff depending on the format selected. Otherwise if they have Output to URL selected, it'll show a simple edit box where they can type in the target URL.
2015-08-19 05:58:24 +02:00
const char *path;
UI: Add file formatting options for recording Allows the user to specify custom formatting for their recording file names with many formatting options, viewed via tooltip. The options have been added to the advanced settings section. Closes jp9000/obs-studio#507
2016-03-25 10:43:38 +01:00
const char *recFormat;
const char *filenameFormat;
UI: Allow file name generation without spaces This will probably go away once proper file name formatting is implemented (https://obsproject.com/mantis/view.php?id=361)
2015-11-27 12:14:18 +01:00
bool noSpace = false;
UI: Add file formatting options for recording Allows the user to specify custom formatting for their recording file names with many formatting options, viewed via tooltip. The options have been added to the advanced settings section. Closes jp9000/obs-studio#507
2016-03-25 10:43:38 +01:00
bool overwriteIfExists = false;
UI: Add automatic file splitting This commit implements a new feature to split recordings in split files in Advanced output mode. These basic settings are implemented. - Enable/disable the feature. Default is disabled. - Select a type of the limit, time or size. - Specifies the limit in seconds or MiB.
2021-10-03 12:06:46 +02:00
bool splitFile;
const char *splitFileType;
int splitFileTime;
int splitFileSize;
UI: Allow generated filenames for FFmpeg output This changes the way the advanced output section's FFmpeg output settings work by allowing the user to select whether they want to output to a file or output to a URL, and makes it so file names are automatically generated like other recording outputs. If they choose to output to a file, it'll only require an output directory similarly to how other recording outputs work. They can select a directory to output to rather than being required to type in a full path and filename; the filename is automatically generated. The extension is also automatically retrieved from libff depending on the format selected. Otherwise if they have Output to URL selected, it'll show a simple edit box where they can type in the target URL.
2015-08-19 05:58:24 +02:00
UI: Prevent re-updating of the stream encoder Using advanced output mode, the stream encoder could be updated with the same settings, causing the encoder to output those changes unnecessarily.
2015-02-15 03:10:39 +01:00
if (!useStreamEncoder) {
UI: Allow generated filenames for FFmpeg output This changes the way the advanced output section's FFmpeg output settings work by allowing the user to select whether they want to output to a file or output to a URL, and makes it so file names are automatically generated like other recording outputs. If they choose to output to a file, it'll only require an output directory similarly to how other recording outputs work. They can select a directory to output to rather than being required to type in a full path and filename; the filename is automatically generated. The extension is also automatically retrieved from libff depending on the format selected. Otherwise if they have Output to URL selected, it'll show a simple edit box where they can type in the target URL.
2015-08-19 05:58:24 +02:00
if (!ffmpegOutput) {
UI: Prevent re-updating of the stream encoder Using advanced output mode, the stream encoder could be updated with the same settings, causing the encoder to output those changes unnecessarily.
2015-02-15 03:10:39 +01:00
UpdateRecordingSettings();
}
} else if (!obs_output_active(streamOutput)) {
UpdateStreamSettings();
}
(API Change) Fix "apply service settings" functions API changed from: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); void obs_service_info::apply_encoder_settings(void *data obs_encoder_t *video_encoder, obs_encoder_t *audio_encoder); To: ------------------------ EXPORT void obs_service_apply_encoder_settings(obs_service_t *service, obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); void obs_service_info::apply_encoder_settings(void *data obs_data_t *video_encoder_settings, obs_data_t *audio_encoder_settings); These changes make it so that instead of an encoder potentially being updated more than once with different settings, that these functions will be called for the specific settings being used, and the settings will be updated according to what's required by the service. This fixes that design flaw and ensures that there's no case where obs_encoder_update is called where the settings might not have service-specific settings applied.
2015-03-08 01:32:00 +01:00
UpdateAudioSettings();
UI: Make SetupOutputs virtual instead of ignoring vcam In 218b936b1dae, the virtual camera was ignored when checking the active state, which is kind of a lackluster solution. Instead, this makes SetupOutputs() a virtual function, and calls it before starting the virtual camera to be more consistent with the rest of the outputs.
2020-09-03 15:56:03 +02:00
if (!Active())
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
SetupOutputs();
UI: Allow generated filenames for FFmpeg output This changes the way the advanced output section's FFmpeg output settings work by allowing the user to select whether they want to output to a file or output to a URL, and makes it so file names are automatically generated like other recording outputs. If they choose to output to a file, it'll only require an output directory similarly to how other recording outputs work. They can select a directory to output to rather than being required to type in a full path and filename; the filename is automatically generated. The extension is also automatically retrieved from libff depending on the format selected. Otherwise if they have Output to URL selected, it'll show a simple edit box where they can type in the target URL.
2015-08-19 05:58:24 +02:00
if (!ffmpegOutput || ffmpegRecording) {
path = config_get_string(main->Config(), "AdvOut",
ffmpegRecording ? "FFFilePath"
: "RecFilePath");
UI: Add file formatting options for recording Allows the user to specify custom formatting for their recording file names with many formatting options, viewed via tooltip. The options have been added to the advanced settings section. Closes jp9000/obs-studio#507
2016-03-25 10:43:38 +01:00
recFormat = config_get_string(main->Config(), "AdvOut",
UI: Allow generated filenames for FFmpeg output This changes the way the advanced output section's FFmpeg output settings work by allowing the user to select whether they want to output to a file or output to a URL, and makes it so file names are automatically generated like other recording outputs. If they choose to output to a file, it'll only require an output directory similarly to how other recording outputs work. They can select a directory to output to rather than being required to type in a full path and filename; the filename is automatically generated. The extension is also automatically retrieved from libff depending on the format selected. Otherwise if they have Output to URL selected, it'll show a simple edit box where they can type in the target URL.
2015-08-19 05:58:24 +02:00
ffmpegRecording ? "FFExtension"
: "RecFormat");
UI: Add file formatting options for recording Allows the user to specify custom formatting for their recording file names with many formatting options, viewed via tooltip. The options have been added to the advanced settings section. Closes jp9000/obs-studio#507
2016-03-25 10:43:38 +01:00
filenameFormat = config_get_string(main->Config(), "Output",
"FilenameFormatting");
overwriteIfExists = config_get_bool(main->Config(), "Output",
"OverwriteIfExists");
UI: Allow file name generation without spaces This will probably go away once proper file name formatting is implemented (https://obsproject.com/mantis/view.php?id=361)
2015-11-27 12:14:18 +01:00
noSpace = config_get_bool(main->Config(), "AdvOut",
ffmpegRecording
? "FFFileNameWithoutSpace"
: "RecFileNameWithoutSpace");
UI: Add automatic file splitting This commit implements a new feature to split recordings in split files in Advanced output mode. These basic settings are implemented. - Enable/disable the feature. Default is disabled. - Select a type of the limit, time or size. - Specifies the limit in seconds or MiB.
2021-10-03 12:06:46 +02:00
splitFile = config_get_bool(main->Config(), "AdvOut",
"RecSplitFile");
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
UI: Fix screenshots preventing auto-remux Due to the fact that a global was used on GenerateSpecifiedFilename to save the remux file name, when a screenshot was made, it would overwrite the filename being remuxed, because screenshots use the same function to generate filenames as well. This solves that problem by removing the global and the changes to GeneratedSpecifiedFilename, and isolating that to the output handler. Coincidentally, this bug probably also happened with replay buffers under certain circumstances. Fixes obsproject/obs-studio#3497 Closes obsproject/obs-studio#3498
2020-09-26 17:19:27 +02:00
string strPath = GetRecordingFilename(path, recFormat, noSpace,
overwriteIfExists,
filenameFormat,
ffmpegRecording);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
UI: Cleanup libobs C++ type use
2021-11-26 10:25:39 +01:00
OBSDataAutoRelease settings = obs_data_create();
UI: Allow generated filenames for FFmpeg output This changes the way the advanced output section's FFmpeg output settings work by allowing the user to select whether they want to output to a file or output to a URL, and makes it so file names are automatically generated like other recording outputs. If they choose to output to a file, it'll only require an output directory similarly to how other recording outputs work. They can select a directory to output to rather than being required to type in a full path and filename; the filename is automatically generated. The extension is also automatically retrieved from libff depending on the format selected. Otherwise if they have Output to URL selected, it'll show a simple edit box where they can type in the target URL.
2015-08-19 05:58:24 +02:00
obs_data_set_string(settings, ffmpegRecording ? "url" : "path",
strPath.c_str());
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
UI: Add automatic file splitting This commit implements a new feature to split recordings in split files in Advanced output mode. These basic settings are implemented. - Enable/disable the feature. Default is disabled. - Select a type of the limit, time or size. - Specifies the limit in seconds or MiB.
2021-10-03 12:06:46 +02:00
if (splitFile) {
splitFileType = config_get_string(
main->Config(), "AdvOut", "RecSplitFileType");
splitFileTime =
(astrcmpi(splitFileType, "Time") == 0)
? config_get_int(main->Config(),
"AdvOut",
"RecSplitFileTime")
: 0;
splitFileSize =
(astrcmpi(splitFileType, "Size") == 0)
? config_get_int(main->Config(),
"AdvOut",
"RecSplitFileSize")
: 0;
obs_data_set_string(settings, "directory", path);
obs_data_set_string(settings, "format", filenameFormat);
obs_data_set_string(settings, "extension", recFormat);
obs_data_set_bool(settings, "allow_spaces", !noSpace);
obs_data_set_bool(settings, "allow_overwrite",
overwriteIfExists);
obs-ffmpeg: Enable file splitting with obs_data directly Also modifies UI accordingly. This can enable file splitting even if no time or storage limit is set.
2022-07-21 14:04:57 +02:00
obs_data_set_bool(settings, "split_file", true);
UI: Add automatic file splitting This commit implements a new feature to split recordings in split files in Advanced output mode. These basic settings are implemented. - Enable/disable the feature. Default is disabled. - Select a type of the limit, time or size. - Specifies the limit in seconds or MiB.
2021-10-03 12:06:46 +02:00
obs_data_set_int(settings, "max_time_sec",
UI: Set automatic file splitting time in minutes The original PR was made with time specified in seconds because it was useful to debug the behavior. For production, assuming most users want to specify 10 minutes or more, the time should be specified in minutes.
2022-04-11 15:21:03 +02:00
splitFileTime * 60);
UI: Add automatic file splitting This commit implements a new feature to split recordings in split files in Advanced output mode. These basic settings are implemented. - Enable/disable the feature. Default is disabled. - Select a type of the limit, time or size. - Specifies the limit in seconds or MiB.
2021-10-03 12:06:46 +02:00
obs_data_set_int(settings, "max_size_mb",
splitFileSize);
}
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
obs_output_update(fileOutput, settings);
}
UI: Add warning if starting the output fails This is mainly to give visual feedback to those affected by NVENC not working with older driver versions. Currenlty obs fails silently which could go unnoticed for users who are using hotkeys as well as confuse users who are not trained to read their logs when issues occur. Closes jp9000/obs-studio#788
2017-02-04 05:29:09 +01:00
if (!obs_output_start(fileOutput)) {
UI: Report more detailed output errors if available
2017-08-07 00:24:44 +02:00
QString error_reason;
const char *error = obs_output_get_last_error(fileOutput);
if (error)
error_reason = QT_UTF8(error);
else
error_reason = QTStr("Output.StartFailedGeneric");
UI: Add warning if starting the output fails This is mainly to give visual feedback to those affected by NVENC not working with older driver versions. Currenlty obs fails silently which could go unnoticed for users who are using hotkeys as well as confuse users who are not trained to read their logs when issues occur. Closes jp9000/obs-studio#788
2017-02-04 05:29:09 +01:00
QMessageBox::critical(main,
QTStr("Output.StartRecordingFailed"),
UI: Report more detailed output errors if available
2017-08-07 00:24:44 +02:00
error_reason);
UI: Add warning if starting the output fails This is mainly to give visual feedback to those affected by NVENC not working with older driver versions. Currenlty obs fails silently which could go unnoticed for users who are using hotkeys as well as confuse users who are not trained to read their logs when issues occur. Closes jp9000/obs-studio#788
2017-02-04 05:29:09 +01:00
return false;
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
}
UI: Add warning if starting the output fails This is mainly to give visual feedback to those affected by NVENC not working with older driver versions. Currenlty obs fails silently which could go unnoticed for users who are using hotkeys as well as confuse users who are not trained to read their logs when issues occur. Closes jp9000/obs-studio#788
2017-02-04 05:29:09 +01:00
return true;
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
}
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
bool AdvancedOutput::StartReplayBuffer()
{
Revert "UI: Add checks for overwrite setting to replay buffer" This reverts commit 02f3495b72b716439d7e9f8c61c136a05ee10837. Multiple issues have come up with this commit. One issue is that suddenly replays are overwriting themselves despite the option being disabled. Second issue is that slashes to separate files into subdirectories no longer work properly with replay buffers. I'm just reverting it. I do not care enough about this feature to try to fix it or wait on a fix. If someone wants to fix it they can create a new PR for it.
2022-01-05 05:42:58 +01:00
const char *path;
const char *recFormat;
const char *filenameFormat;
bool noSpace = false;
bool overwriteIfExists = false;
const char *rbPrefix;
const char *rbSuffix;
int rbTime;
int rbSize;
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
if (!useStreamEncoder) {
if (!ffmpegOutput)
UpdateRecordingSettings();
} else if (!obs_output_active(streamOutput)) {
UpdateStreamSettings();
}
UpdateAudioSettings();
UI: Make SetupOutputs virtual instead of ignoring vcam In 218b936b1dae, the virtual camera was ignored when checking the active state, which is kind of a lackluster solution. Instead, this makes SetupOutputs() a virtual function, and calls it before starting the virtual camera to be more consistent with the rest of the outputs.
2020-09-03 15:56:03 +02:00
if (!Active())
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
SetupOutputs();
Revert "UI: Add checks for overwrite setting to replay buffer" This reverts commit 02f3495b72b716439d7e9f8c61c136a05ee10837. Multiple issues have come up with this commit. One issue is that suddenly replays are overwriting themselves despite the option being disabled. Second issue is that slashes to separate files into subdirectories no longer work properly with replay buffers. I'm just reverting it. I do not care enough about this feature to try to fix it or wait on a fix. If someone wants to fix it they can create a new PR for it.
2022-01-05 05:42:58 +01:00
if (!ffmpegOutput || ffmpegRecording) {
path = config_get_string(main->Config(), "AdvOut",
ffmpegRecording ? "FFFilePath"
: "RecFilePath");
recFormat = config_get_string(main->Config(), "AdvOut",
ffmpegRecording ? "FFExtension"
: "RecFormat");
filenameFormat = config_get_string(main->Config(), "Output",
"FilenameFormatting");
overwriteIfExists = config_get_bool(main->Config(), "Output",
"OverwriteIfExists");
noSpace = config_get_bool(main->Config(), "AdvOut",
ffmpegRecording
? "FFFileNameWithoutSpace"
: "RecFileNameWithoutSpace");
rbPrefix = config_get_string(main->Config(), "SimpleOutput",
"RecRBPrefix");
rbSuffix = config_get_string(main->Config(), "SimpleOutput",
"RecRBSuffix");
rbTime = config_get_int(main->Config(), "AdvOut", "RecRBTime");
rbSize = config_get_int(main->Config(), "AdvOut", "RecRBSize");
string f = GetFormatString(filenameFormat, rbPrefix, rbSuffix);
string strPath = GetOutputFilename(
path, recFormat, noSpace, overwriteIfExists, f.c_str());
OBSDataAutoRelease settings = obs_data_create();
obs_data_set_string(settings, "directory", path);
obs_data_set_string(settings, "format", f.c_str());
obs_data_set_string(settings, "extension", recFormat);
obs_data_set_bool(settings, "allow_spaces", !noSpace);
obs_data_set_int(settings, "max_time_sec", rbTime);
obs_data_set_int(settings, "max_size_mb",
usesBitrate ? 0 : rbSize);
obs_output_update(replayBuffer, settings);
}
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
if (!obs_output_start(replayBuffer)) {
UI: Report detailed output errors for Replay Buffer Same changes as 0c0ffb341cfb521473479cdcd391c3507b05cf46
2020-09-04 10:23:06 +02:00
QString error_reason;
const char *error = obs_output_get_last_error(replayBuffer);
if (error)
error_reason = QT_UTF8(error);
else
error_reason = QTStr("Output.StartFailedGeneric");
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
QMessageBox::critical(main,
QTStr("Output.StartRecordingFailed"),
UI: Report detailed output errors for Replay Buffer Same changes as 0c0ffb341cfb521473479cdcd391c3507b05cf46
2020-09-04 10:23:06 +02:00
error_reason);
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
return false;
}
return true;
}
UI: Add ability to forcibly stop streams/recordings If the user hits the "stop stream" button it'll transition in to "stopping stream..." and will continue to output until the stream reaches the timing in which "stop" was pressed. However, if there is significant congestion, stopping the stream can take far longer than the user may like. So there needs to be an option to forcibly stop the stream in that case; pushing the "stop" button a second time should allow the user to tell the stream/recording to stop right away instead of waiting for the precise stop timing.
2016-09-09 16:37:54 +02:00
void AdvancedOutput::StopStreaming(bool force)
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
{
UI: Add ability to forcibly stop streams/recordings If the user hits the "stop stream" button it'll transition in to "stopping stream..." and will continue to output until the stream reaches the timing in which "stop" was pressed. However, if there is significant congestion, stopping the stream can take far longer than the user may like. So there needs to be an option to forcibly stop the stream in that case; pushing the "stop" button a second time should allow the user to tell the stream/recording to stop right away instead of waiting for the precise stop timing.
2016-09-09 16:37:54 +02:00
if (force)
obs_output_force_stop(streamOutput);
else
obs_output_stop(streamOutput);
UI: Implement stream delay When stream delay is active, the "Start/Stop Streaming" button is changed in to a menu button, which allows the user to select either the option to stop the stream (which causes it to count down), or forcibly stop the stream (which immediately stops the stream and cuts off all delayed data). If the user decides they want to start the stream again while in the process of counting down, they can safely do so without having to wait for it to stop, and it will schedule it to start up again with the same delay after the stop. On the status bar, it will now show whether delay is active, and its duration. If the stream is in the process of stopping/starting, it will count down to the stop/start. If the option to preserve stream cutoff point on unexpected disconnections/reconnections is enabled, it will update the current delay duration accordingly.
2015-09-07 01:19:53 +02:00
}
UI: Add ability to forcibly stop streams/recordings If the user hits the "stop stream" button it'll transition in to "stopping stream..." and will continue to output until the stream reaches the timing in which "stop" was pressed. However, if there is significant congestion, stopping the stream can take far longer than the user may like. So there needs to be an option to forcibly stop the stream in that case; pushing the "stop" button a second time should allow the user to tell the stream/recording to stop right away instead of waiting for the precise stop timing.
2016-09-09 16:37:54 +02:00
void AdvancedOutput::StopRecording(bool force)
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
{
UI: Add ability to forcibly stop streams/recordings If the user hits the "stop stream" button it'll transition in to "stopping stream..." and will continue to output until the stream reaches the timing in which "stop" was pressed. However, if there is significant congestion, stopping the stream can take far longer than the user may like. So there needs to be an option to forcibly stop the stream in that case; pushing the "stop" button a second time should allow the user to tell the stream/recording to stop right away instead of waiting for the precise stop timing.
2016-09-09 16:37:54 +02:00
if (force)
obs_output_force_stop(fileOutput);
else
obs_output_stop(fileOutput);
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
}
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
void AdvancedOutput::StopReplayBuffer(bool force)
{
if (force)
obs_output_force_stop(replayBuffer);
else
obs_output_stop(replayBuffer);
}
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
bool AdvancedOutput::StreamingActive() const
{
return obs_output_active(streamOutput);
}
bool AdvancedOutput::RecordingActive() const
{
return obs_output_active(fileOutput);
}
UI: Enable Replay Buffer in Advanced Mode Replay buffer is currently only supported in simple mode. This change adds support to advanced mode and is, for the most part, a mirror of the addition of replay buffer to simple mode. Mantis-bug: https://obsproject.com/mantis/view.php?id=792 Closes jp9000/obs-studio#1019
2017-09-06 02:01:49 +02:00
bool AdvancedOutput::ReplayBufferActive() const
{
return obs_output_active(replayBuffer);
}
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
/* ------------------------------------------------------------------------ */
UI: Add save notifications to status bar This shows notifications in the status bar with the following: - When screenshot is saved - When replay buffer is saved - When recording is saved - When recording is auto remuxed
2021-02-04 13:01:35 +01:00
void BasicOutputHandler::SetupAutoRemux(const char *&ext)
UI: Fix screenshots preventing auto-remux Due to the fact that a global was used on GenerateSpecifiedFilename to save the remux file name, when a screenshot was made, it would overwrite the filename being remuxed, because screenshots use the same function to generate filenames as well. This solves that problem by removing the global and the changes to GeneratedSpecifiedFilename, and isolating that to the output handler. Coincidentally, this bug probably also happened with replay buffers under certain circumstances. Fixes obsproject/obs-studio#3497 Closes obsproject/obs-studio#3498
2020-09-26 17:19:27 +02:00
{
bool autoRemux = config_get_bool(main->Config(), "Video", "AutoRemux");
if (autoRemux && strcmp(ext, "mp4") == 0)
ext = "mkv";
}
std::string
BasicOutputHandler::GetRecordingFilename(const char *path, const char *ext,
bool noSpace, bool overwrite,
const char *format, bool ffmpeg)
{
UI: Add save notifications to status bar This shows notifications in the status bar with the following: - When screenshot is saved - When replay buffer is saved - When recording is saved - When recording is auto remuxed
2021-02-04 13:01:35 +01:00
if (!ffmpeg)
SetupAutoRemux(ext);
UI: Fix screenshots preventing auto-remux Due to the fact that a global was used on GenerateSpecifiedFilename to save the remux file name, when a screenshot was made, it would overwrite the filename being remuxed, because screenshots use the same function to generate filenames as well. This solves that problem by removing the global and the changes to GeneratedSpecifiedFilename, and isolating that to the output handler. Coincidentally, this bug probably also happened with replay buffers under certain circumstances. Fixes obsproject/obs-studio#3497 Closes obsproject/obs-studio#3498
2020-09-26 17:19:27 +02:00
string dst = GetOutputFilename(path, ext, noSpace, overwrite, format);
UI: Add save notifications to status bar This shows notifications in the status bar with the following: - When screenshot is saved - When replay buffer is saved - When recording is saved - When recording is auto remuxed
2021-02-04 13:01:35 +01:00
lastRecordingPath = dst;
UI: Fix screenshots preventing auto-remux Due to the fact that a global was used on GenerateSpecifiedFilename to save the remux file name, when a screenshot was made, it would overwrite the filename being remuxed, because screenshots use the same function to generate filenames as well. This solves that problem by removing the global and the changes to GeneratedSpecifiedFilename, and isolating that to the output handler. Coincidentally, this bug probably also happened with replay buffers under certain circumstances. Fixes obsproject/obs-studio#3497 Closes obsproject/obs-studio#3498
2020-09-26 17:19:27 +02:00
return dst;
}
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 12:17:33 +01:00
BasicOutputHandler *CreateSimpleOutputHandler(OBSBasic *main)
{
return new SimpleOutput(main);
}
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 22:41:22 +01:00
BasicOutputHandler *CreateAdvancedOutputHandler(OBSBasic *main)
{
return new AdvancedOutput(main);
}
Copy Permalink