mirror/obs-studio
0
0
Fork 0
mirror of https://github.com/obsproject/obs-studio.git synced 2024-09-20 13:08:50 +02:00
Code
234ed9512d
obs-studio/UI/window-basic-main-outputs.cpp

1789 lines
49 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"
using namespace std;
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: 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: 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,
UI: Add support for showing output error messages
2017-05-15 12:03:00 +02:00
"StreamingStop", 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: 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: 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: 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", Q_ARG(int, code));
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
UNUSED_PARAMETER(params);
}
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: 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;
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;
QMetaObject::invokeMethod(output->main,
"ReplayBufferStop", Q_ARG(int, code));
UNUSED_PARAMETER(params);
}
static void OBSReplayBufferStopping(void *data, calldata_t *params)
{
BasicOutputHandler *output = static_cast<BasicOutputHandler*>(data);
QMetaObject::invokeMethod(output->main, "ReplayBufferStopping");
UNUSED_PARAMETER(params);
}
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
static void FindBestFilename(string &strPath, bool noSpace)
{
int num = 2;
if (!os_file_exists(strPath.c_str()))
return;
const char *ext = strrchr(strPath.c_str(), '.');
if (!ext)
return;
int extStart = int(ext - strPath.c_str());
for (;;) {
string testPath = strPath;
string numStr;
numStr = noSpace ? "_" : " (";
numStr += to_string(num++);
if (!noSpace)
numStr += ")";
testPath.insert(extStart, numStr);
if (!os_file_exists(testPath.c_str())) {
strPath = testPath;
break;
}
}
}
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: 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;
OBSEncoder h264Streaming;
OBSEncoder aacRecording;
OBSEncoder h264Recording;
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;
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);
UI: Implement simple output mode presets for AMD Closes jp9000/obs-studio#630
2016-09-27 01:29:33 +02:00
void UpdateStreamingSettings_amd(obs_data_t *settings, int bitrate);
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_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: 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 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;
void SetupOutputs();
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: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
void LoadRecordingPreset_h264(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: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
void LoadStreamingPreset_h264(const char *encoder);
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: 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)";
obs_output_release(fileOutput);
obs_data_t *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
obs_output_update(fileOutput, settings);
obs_data_release(settings);
}
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
void SimpleOutput::LoadRecordingPreset_h264(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: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
h264Recording = obs_video_encoder_create(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
"simple_h264_recording", nullptr, nullptr);
if (!h264Recording)
throw "Failed to create h264 recording encoder (simple output)";
obs_encoder_release(h264Recording);
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: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
void SimpleOutput::LoadStreamingPreset_h264(const char *encoderId)
{
h264Streaming = obs_video_encoder_create(encoderId,
"simple_h264_stream", nullptr, nullptr);
if (!h264Streaming)
throw "Failed to create h264 streaming encoder (simple output)";
obs_encoder_release(h264Streaming);
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) {
h264Recording = h264Streaming;
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;
if (strcmp(encoder, SIMPLE_ENCODER_X264) == 0) {
LoadRecordingPreset_h264("obs_x264");
} else if (strcmp(encoder, SIMPLE_ENCODER_X264_LOWCPU) == 0) {
LoadRecordingPreset_h264("obs_x264");
lowCPUx264 = true;
} else if (strcmp(encoder, SIMPLE_ENCODER_QSV) == 0) {
LoadRecordingPreset_h264("obs_qsv11");
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) {
LoadRecordingPreset_h264("amd_amf_h264");
UI: Add NVENC support to simple output
2016-04-19 01:12:59 +02:00
} else if (strcmp(encoder, SIMPLE_ENCODER_NVENC) == 0) {
LoadRecordingPreset_h264("ffmpeg_nvenc");
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
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: 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");
if (strcmp(encoder, SIMPLE_ENCODER_QSV) == 0)
LoadStreamingPreset_h264("obs_qsv11");
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)
LoadStreamingPreset_h264("amd_amf_h264");
UI: Add NVENC support to simple output
2016-04-19 01:12:59 +02:00
else if (strcmp(encoder, SIMPLE_ENCODER_NVENC) == 0)
LoadStreamingPreset_h264("ffmpeg_nvenc");
UI: Add support for QSV encoder to simple output
2016-04-18 09:56:51 +02:00
else
LoadStreamingPreset_h264("obs_x264");
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: 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: 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");
obs_data_t *hotkey = obs_data_create_from_json(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
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);
obs_data_release(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)";
obs_output_release(replayBuffer);
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: 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)";
obs_output_release(fileOutput);
}
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),
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
"stop", 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()
{
obs_data_t *h264Settings = obs_data_create();
obs_data_t *aacSettings = obs_data_create();
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: 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
bool enforceBitrate = config_get_bool(main->Config(), "SimpleOutput",
"EnforceBitrate");
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";
UpdateStreamingSettings_amd(h264Settings, videoBitrate);
} 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
} 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: 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: Set simple output mode to always use CBR for stream
2016-05-26 16:54:29 +02:00
obs_data_set_string(h264Settings, "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(h264Settings, "bitrate", videoBitrate);
if (advanced) {
obs_data_set_string(h264Settings, "preset", preset);
obs_data_set_string(h264Settings, "x264opts", custom);
}
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);
(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(),
h264Settings, aacSettings);
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
if (advanced && !enforceBitrate) {
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
obs_data_set_int(h264Settings, "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);
if (format != VIDEO_FORMAT_NV12 && format != VIDEO_FORMAT_I420)
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_preferred_video_format(h264Streaming,
VIDEO_FORMAT_NV12);
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: 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(h264Streaming, h264Settings);
obs_encoder_update(aacStreaming, 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
obs_data_release(h264Settings);
obs_data_release(aacSettings);
}
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()
{
obs_data_t *settings = obs_data_create();
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);
obs_data_release(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)
{
obs_data_t *settings = obs_data_create();
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");
obs_encoder_update(h264Recording, settings);
obs_data_release(settings);
}
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)
{
bool icq = icq_available(h264Recording);
obs_data_t *settings = obs_data_create();
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);
}
obs_encoder_update(h264Recording, settings);
obs_data_release(settings);
}
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
{
obs_data_t *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");
obs_data_set_string(settings, "preset", "hq");
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
obs_encoder_update(h264Recording, settings);
obs_data_release(settings);
}
UI: Implement simple output mode presets for AMD Closes jp9000/obs-studio#630
2016-09-27 01:29:33 +02:00
void SimpleOutput::UpdateStreamingSettings_amd(obs_data_t *settings,
int bitrate)
{
UI: Add AMD presets and update settings
2016-11-03 20:34:57 +01:00
// Static Properties
enc-amf: Version 2.1.3
2017-05-11 13:11:05 +02:00
obs_data_set_int(settings, "Usage", 0);
obs_data_set_int(settings, "Profile", 100); // High
UI: Remove trailing whitespace
2017-08-01 03:35:54 +02:00
UI: Add AMD presets and update settings
2016-11-03 20:34:57 +01:00
// Rate Control Properties
UI: Fix incorrect properties set for Hardware (AMD) Due to an oversight in enc-amf with strcmp, the code currently causes certain weirdness to appear. This fixes it so it will use "High" Profile instead of attempting to use "Constrained Baseline" and also changes it to actually set things up for "Constant Bitrate" instead of "Variable Bitrate (Latency Constrained)". Finally I've added a slight change that always makes it set the B-Frame Pattern to 0 in order to work better with VCE2.0 and VCE3.0 cards. Closes jp9000/obs-studio#978
2017-07-29 04:10:50 +02:00
obs_data_set_int(settings, "RateControlMethod", 3);
enc-amf: Version 2.1.3
2017-05-11 13:11:05 +02:00
obs_data_set_int(settings, "Bitrate.Target", bitrate);
obs_data_set_int(settings, "FillerData", 1);
obs_data_set_int(settings, "VBVBuffer", 1);
obs_data_set_int(settings, "VBVBuffer.Size", bitrate);
UI: Remove trailing whitespace
2017-08-01 03:35:54 +02:00
UI: Add AMD presets and update settings
2016-11-03 20:34:57 +01:00
// Picture Control Properties
enc-amf: Version 2.1.3
2017-05-11 13:11:05 +02:00
obs_data_set_double(settings, "KeyframeInterval", 2.0);
UI: Fix incorrect properties set for Hardware (AMD) Due to an oversight in enc-amf with strcmp, the code currently causes certain weirdness to appear. This fixes it so it will use "High" Profile instead of attempting to use "Constrained Baseline" and also changes it to actually set things up for "Constant Bitrate" instead of "Variable Bitrate (Latency Constrained)". Finally I've added a slight change that always makes it set the B-Frame Pattern to 0 in order to work better with VCE2.0 and VCE3.0 cards. Closes jp9000/obs-studio#978
2017-07-29 04:10:50 +02:00
obs_data_set_int(settings, "BFrame.Pattern", 0);
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)
{
obs_data_t *settings = obs_data_create();
UI: Add AMD presets and update settings
2016-11-03 20:34:57 +01:00
// Static Properties
enc-amf: Version 2.1.3
2017-05-11 13:11:05 +02:00
obs_data_set_int(settings, "Usage", 0);
obs_data_set_int(settings, "Profile", 100); // High
UI: Add AMD presets and update settings
2016-11-03 20:34:57 +01:00
UI: Update settings and fix presets for simple AMD encoder
2016-11-17 04:40:49 +01:00
// Rate Control Properties
enc-amf: Version 2.1.3
2017-05-11 13:11:05 +02:00
obs_data_set_int(settings, "RateControlMethod", 0);
obs_data_set_int(settings, "QP.IFrame", cqp);
obs_data_set_int(settings, "QP.PFrame", cqp);
obs_data_set_int(settings, "QP.BFrame", cqp);
obs_data_set_int(settings, "VBVBuffer", 1);
obs_data_set_int(settings, "VBVBuffer.Size", 100000);
UI: Implement simple output mode presets for AMD Closes jp9000/obs-studio#630
2016-09-27 01:29:33 +02:00
UI: Add AMD presets and update settings
2016-11-03 20:34:57 +01:00
// Picture Control Properties
enc-amf: Version 2.1.3
2017-05-11 13:11:05 +02:00
obs_data_set_double(settings, "KeyframeInterval", 2.0);
UI: Fix incorrect properties set for Hardware (AMD) Due to an oversight in enc-amf with strcmp, the code currently causes certain weirdness to appear. This fixes it so it will use "High" Profile instead of attempting to use "Constrained Baseline" and also changes it to actually set things up for "Constant Bitrate" instead of "Variable Bitrate (Latency Constrained)". Finally I've added a slight change that always makes it set the B-Frame Pattern to 0 in order to work better with VCE2.0 and VCE3.0 cards. Closes jp9000/obs-studio#978
2017-07-29 04:10:50 +02:00
obs_data_set_int(settings, "BFrame.Pattern", 0);
UI: Implement simple output mode presets for AMD Closes jp9000/obs-studio#630
2016-09-27 01:29:33 +02:00
UI: Add AMD presets and update settings
2016-11-03 20:34:57 +01:00
// Update and release
obs_encoder_update(h264Recording, settings);
UI: Implement simple output mode presets for AMD Closes jp9000/obs-studio#630
2016-09-27 01:29:33 +02:00
obs_data_release(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
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: 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: 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: 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_video(h264Streaming, obs_get_video());
obs_encoder_set_audio(aacStreaming, obs_get_audio());
if (usingRecordingPreset) {
if (ffmpegOutput) {
obs_output_set_media(fileOutput, obs_get_video(),
obs_get_audio());
} else {
obs_encoder_set_video(h264Recording, obs_get_video());
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: 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::StartStreaming(obs_service_t *service)
{
if (!Active())
SetupOutputs();
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);
if (!type)
type = "rtmp_output";
/* 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
obs_output_release(streamOutput);
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: 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
const char *codec =
obs_output_get_supported_audio_codecs(streamOutput);
UI: Return false if audio encoder creation fails
2017-08-01 03:36:12 +02:00
if (!codec) {
return false;
}
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
if (strcmp(codec, "aac") != 0) {
const char *id = FindAudioEncoderFromCodec(codec);
int audioBitrate = GetAudioBitrate();
obs_data_t *settings = obs_data_create();
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());
obs_data_release(settings);
}
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: 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_video_encoder(streamOutput, h264Streaming);
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: 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: 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",
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
"Reconnect");
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
int retryDelay = config_get_uint(main->Config(), "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
"RetryDelay");
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
int maxRetries = config_get_uint(main->Config(), "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
"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 "Bind to IP" setting to advanced settings
2016-07-29 17:30:54 +02:00
obs_data_t *settings = obs_data_create();
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 "Bind to IP" setting to advanced settings
2016-07-29 17:30:54 +02:00
obs_output_update(streamOutput, settings);
obs_data_release(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);
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);
bool has_last_error = error && *error;
blog(LOG_WARNING, "Stream output type '%s' failed to start!%s%s",
type,
has_last_error ? " Last Error: " : "",
has_last_error ? 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: 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
static void remove_reserved_file_characters(string &s)
{
replace(s.begin(), s.end(), '/', '_');
replace(s.begin(), s.end(), '\\', '_');
replace(s.begin(), s.end(), '*', '_');
replace(s.begin(), s.end(), '?', '_');
replace(s.begin(), s.end(), '"', '_');
replace(s.begin(), s.end(), '|', '_');
replace(s.begin(), s.end(), ':', '_');
replace(s.begin(), s.end(), '>', '_');
replace(s.begin(), s.end(), '<', '_');
}
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
static void ensure_directory_exists(string &path)
{
replace(path.begin(), path.end(), '\\', '/');
size_t last = path.rfind('/');
if (last == string::npos)
return;
string directory = path.substr(0, last);
os_mkdirs(directory.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
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: 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 (!Active())
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) {
obs_output_set_video_encoder(fileOutput, h264Recording);
obs_output_set_audio_encoder(fileOutput, aacRecording, 0);
}
if (replayBuffer) {
obs_output_set_video_encoder(replayBuffer, h264Recording);
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: Show error if empty recording path specified
2017-08-06 23:59:03 +02:00
os_dir_t *dir = path && path[0] ? os_opendir(path) : nullptr;
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 (!dir) {
UI: Add system tray capability This adds a system tray when enabled. There is also a option to minimize to the system tray when the app is started. Closes jp9000/obs-studio#595
2016-08-13 16:36:17 +02:00
if (main->isVisible())
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
OBSMessageBox::information(main,
UI: Add system tray capability This adds a system tray when enabled. There is also a option to minimize to the system tray when the app is started. Closes jp9000/obs-studio#595
2016-08-13 16:36:17 +02:00
QTStr("Output.BadPath.Title"),
QTStr("Output.BadPath.Text"));
else
main->SysTrayNotify(QTStr("Output.BadPath.Text"),
QSystemTrayIcon::Warning);
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;
}
os_closedir(dir);
string strPath;
strPath += path;
char lastChar = strPath.back();
if (lastChar != '/' && lastChar != '\\')
strPath += "/";
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
strPath += GenerateSpecifiedFilename(ffmpegOutput ? "avi" : format,
noSpace, filenameFormat);
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
ensure_directory_exists(strPath);
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
if (!overwriteIfExists)
FindBestFilename(strPath, noSpace);
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_t *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: 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
string f;
if (rbPrefix && *rbPrefix) {
f += rbPrefix;
if (f.back() != ' ')
f += " ";
}
f += filenameFormat;
if (rbSuffix && *rbSuffix) {
if (*rbSuffix != ' ')
f += " ";
f += rbSuffix;
}
remove_reserved_file_characters(f);
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);
obs_data_set_int(settings, "max_time_sec", rbTime);
obs_data_set_int(settings, "max_size_mb",
usingRecordingPreset ? rbSize : 0);
} else {
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
obs_data_release(settings);
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: Increase maximum audio tracks to 6
2016-12-22 02:14:24 +01:00
OBSEncoder aacTrack[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
OBSEncoder h264Streaming;
OBSEncoder h264Recording;
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
OBSEncoder streamAudioEnc;
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;
inline void SetupStreaming();
inline void SetupRecording();
inline void SetupFFmpeg();
void SetupOutputs();
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
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: 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) {
obs_data_t *data = obs_data_create_from_json(jsonData);
OBSData dataRet(data);
obs_data_release(data);
return dataRet;
}
}
return nullptr;
}
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: 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: 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 *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: 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("ffmpeg_output",
(API Change) libobs: Add hotkey data to *_create functions
2014-11-01 21:41:17 +01:00
"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)";
(API Change) libobs: Make obs_output refcounted
2015-05-04 01:55:43 +02:00
obs_output_release(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
} 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) {
const char *str = config_get_string(main->Config(),
"Hotkeys", "ReplayBuffer");
obs_data_t *hotkey = obs_data_create_from_json(str);
replayBuffer = obs_output_create("replay_buffer",
Str("ReplayBuffer"), nullptr, hotkey);
obs_data_release(hotkey);
if (!replayBuffer)
throw "Failed to create replay buffer output "
"(simple output)";
obs_output_release(replayBuffer);
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: 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)";
(API Change) libobs: Make obs_output refcounted
2015-05-04 01:55:43 +02:00
obs_output_release(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
if (!useStreamEncoder) {
h264Recording = obs_video_encoder_create(recordEncoder,
(API Change) libobs: Add hotkey data to *_create functions
2014-11-01 21:41:17 +01:00
"recording_h264", recordEncSettings,
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 (!h264Recording)
throw "Failed to create recording h264 "
"encoder (advanced output)";
(API Change) libobs: Make obs_encoder refcounted
2015-05-04 02:01:38 +02:00
obs_encoder_release(h264Recording);
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
}
}
h264Streaming = obs_video_encoder_create(streamEncoder,
(API Change) libobs: Add hotkey data to *_create functions
2014-11-01 21:41:17 +01:00
"streaming_h264", streamEncSettings, 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 (!h264Streaming)
throw "Failed to create streaming h264 encoder "
"(advanced output)";
(API Change) libobs: Make obs_encoder refcounted
2015-05-04 02:01:38 +02:00
obs_encoder_release(h264Streaming);
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 (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: 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),
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
"stop", 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 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: 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");
(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
if (applyServiceSettings)
obs_service_apply_encoder_settings(main->GetService(),
settings, nullptr);
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);
if (format != VIDEO_FORMAT_NV12 && format != VIDEO_FORMAT_I420)
obs_encoder_set_preferred_video_format(h264Streaming,
VIDEO_FORMAT_NV12);
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(h264Streaming, settings);
}
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: 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(h264Recording, settings);
}
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
}
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
}
obs_encoder_set_scaled_size(h264Streaming, cx, cy);
obs_encoder_set_video(h264Streaming, obs_get_video());
}
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: Allow multi-track recording in advanced output
2015-05-31 06:45:14 +02:00
int tracks = config_get_int(main->Config(), "AdvOut", "RecTracks");
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_t *settings = obs_data_create();
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
if (useStreamEncoder) {
obs_output_set_video_encoder(fileOutput, h264Streaming);
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,
h264Streaming);
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
}
obs_encoder_set_scaled_size(h264Recording, cx, cy);
obs_encoder_set_video(h264Recording, obs_get_video());
obs_output_set_video_encoder(fileOutput, h264Recording);
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,
h264Recording);
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 multi-track recording in advanced output
2015-05-31 06:45:14 +02:00
for (int i = 0; i < MAX_AUDIO_MIXES; i++) {
if ((tracks & (1<<i)) != 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_audio_encoder(fileOutput, aacTrack[i],
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
idx);
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: 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
obs_data_release(settings);
}
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");
int aTrack = config_get_int(main->Config(), "AdvOut",
"FFAudioTrack");
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");
obs_data_t *settings = obs_data_create();
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);
}
}
obs_output_set_mixer(fileOutput, aTrack - 1);
obs_output_set_media(fileOutput, obs_get_video(), obs_get_audio());
obs_output_update(fileOutput, settings);
obs_data_release(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: 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: Increase maximum audio tracks to 6
2016-12-22 02:14:24 +01:00
obs_data_t *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: Fix bug with enforced audio encoder settings I forgot that the track index is 1-based, not 0-bsaed.
2015-03-27 21:35:43 +01:00
if (applyServiceSettings && (int)(i + 1) == streamTrackIndex)
(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(),
nullptr, 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
obs_encoder_update(aacTrack[i], settings[i]);
obs_data_release(settings[i]);
}
}
void AdvancedOutput::SetupOutputs()
{
obs_encoder_set_video(h264Streaming, obs_get_video());
if (h264Recording)
obs_encoder_set_video(h264Recording, 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: 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", "Track4Bitrate",
UI: Increase maximum audio tracks to 6
2016-12-22 02:14:24 +01:00
"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: 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::StartStreaming(obs_service_t *service)
{
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: 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 (!Active())
SetupOutputs();
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
/* --------------------- */
int trackIndex = config_get_int(main->Config(), "AdvOut",
"TrackIndex");
const char *type = obs_service_get_output_type(service);
if (!type)
type = "rtmp_output";
/* 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
obs_output_release(streamOutput);
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: 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
const char *codec =
obs_output_get_supported_audio_codecs(streamOutput);
UI: Return false if audio encoder creation fails
2017-08-01 03:36:12 +02:00
if (!codec) {
return false;
}
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
if (strcmp(codec, "aac") == 0) {
streamAudioEnc = aacTrack[trackIndex - 1];
} else {
const char *id = FindAudioEncoderFromCodec(codec);
int audioBitrate = GetAudioBitrate(trackIndex - 1);
obs_data_t *settings = obs_data_create();
obs_data_set_int(settings, "bitrate", audioBitrate);
streamAudioEnc = obs_audio_encoder_create(id,
"alt_audio_enc", nullptr,
trackIndex - 1, nullptr);
if (!streamAudioEnc)
return false;
obs_encoder_update(streamAudioEnc, settings);
obs_encoder_set_audio(streamAudioEnc, obs_get_audio());
obs_data_release(settings);
}
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;
}
obs_output_set_video_encoder(streamOutput, h264Streaming);
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
obs_output_set_audio_encoder(streamOutput, streamAudioEnc, 0);
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: 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 "Bind to IP" setting to advanced settings
2016-07-29 17:30:54 +02:00
obs_data_t *settings = obs_data_create();
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 "Bind to IP" setting to advanced settings
2016-07-29 17:30:54 +02:00
obs_output_update(streamOutput, settings);
obs_data_release(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);
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);
bool has_last_error = error && *error;
blog(LOG_WARNING, "Stream output type '%s' failed to start!%s%s",
type,
has_last_error ? " Last Error: " : "",
has_last_error ? 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: 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: 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 (!Active())
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 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: Show error if empty recording path specified Same as 937ec4d but for advanced output.
2017-08-07 00:40:20 +02:00
os_dir_t *dir = path && path[0] ? os_opendir(path) : 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 (!dir) {
UI: Add system tray capability This adds a system tray when enabled. There is also a option to minimize to the system tray when the app is started. Closes jp9000/obs-studio#595
2016-08-13 16:36:17 +02:00
if (main->isVisible())
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
OBSMessageBox::information(main,
UI: Add system tray capability This adds a system tray when enabled. There is also a option to minimize to the system tray when the app is started. Closes jp9000/obs-studio#595
2016-08-13 16:36:17 +02:00
QTStr("Output.BadPath.Title"),
QTStr("Output.BadPath.Text"));
else
main->SysTrayNotify(QTStr("Output.BadPath.Text"),
QSystemTrayIcon::Warning);
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;
}
os_closedir(dir);
string strPath;
strPath += path;
char lastChar = strPath.back();
if (lastChar != '/' && lastChar != '\\')
strPath += "/";
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
strPath += GenerateSpecifiedFilename(recFormat, noSpace,
filenameFormat);
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
ensure_directory_exists(strPath);
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
if (!overwriteIfExists)
FindBestFilename(strPath, noSpace);
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_t *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
obs_output_update(fileOutput, settings);
obs_data_release(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()
{
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;
if (!useStreamEncoder) {
if (!ffmpegOutput)
UpdateRecordingSettings();
} else if (!obs_output_active(streamOutput)) {
UpdateStreamSettings();
}
UpdateAudioSettings();
if (!Active())
SetupOutputs();
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");
os_dir_t *dir = path && path[0] ? os_opendir(path) : nullptr;
if (!dir) {
if (main->isVisible())
OBSMessageBox::information(main,
QTStr("Output.BadPath.Title"),
QTStr("Output.BadPath.Text"));
else
main->SysTrayNotify(QTStr("Output.BadPath.Text"),
QSystemTrayIcon::Warning);
return false;
}
os_closedir(dir);
string strPath;
strPath += path;
char lastChar = strPath.back();
if (lastChar != '/' && lastChar != '\\')
strPath += "/";
strPath += GenerateSpecifiedFilename(recFormat, noSpace,
filenameFormat);
ensure_directory_exists(strPath);
if (!overwriteIfExists)
FindBestFilename(strPath, noSpace);
obs_data_t *settings = obs_data_create();
string f;
if (rbPrefix && *rbPrefix) {
f += rbPrefix;
if (f.back() != ' ')
f += " ";
}
f += filenameFormat;
if (rbSuffix && *rbSuffix) {
if (*rbSuffix != ' ')
f += " ";
f += rbSuffix;
}
remove_reserved_file_characters(f);
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_int(settings, "max_time_sec", rbTime);
obs_data_set_int(settings, "max_size_mb",
usesBitrate ? 0 : rbSize);
obs_output_update(replayBuffer, settings);
obs_data_release(settings);
}
if (!obs_output_start(replayBuffer)) {
QMessageBox::critical(main,
QTStr("Output.StartRecordingFailed"),
QTStr("Output.StartFailedGeneric"));
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: 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