jp9000
/
obs-studio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
obs-studio/UI/window-basic-main-outputs.cpp

1232 lines
34 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 03:17:33 -08: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-04 23:11:24 -07: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 03:17:33 -08:00
#include <QMessageBox>
UI: Create best matching audio encoder for given bitrate
2015-07-02 01:00:22 -07: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 03:17:33 -08: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-06 16:19:53 -07: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 01:47:08 -07: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-06 16:19:53 -07: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 03:17:33 -08: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-06 16:07:45 -07: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 03:17:33 -08: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: 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-06 16:07:45 -07: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-06 16:19:53 -07: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 03:17:33 -08:00
QMetaObject::invokeMethod(output->main,
"StreamingStop", Q_ARG(int, code));
}
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-06 16:07:45 -07: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 03:17:33 -08: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-09 21:00:22 -07: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 03:17:33 -08: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-06 16:07:45 -07: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-09 21:00:22 -07: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 03:17:33 -08: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 01:47:08 -07:00
static void OBSRecordStopping(void *data, calldata_t *params)
{
BasicOutputHandler *output = static_cast<BasicOutputHandler*>(data);
QMetaObject::invokeMethod(output->main, "RecordStopping");
UNUSED_PARAMETER(params);
}
UI: Add 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 02:43:38 -07: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 03:17:33 -08:00
/* ------------------------------------------------------------------------ */
UI: Create best matching audio encoder for given bitrate
2015-07-02 01:00:22 -07:00
static bool CreateAACEncoder(OBSEncoder &res, string &id, int bitrate,
const char *name, size_t idx)
UI: Move AAC encoder creation
2015-06-05 16:52:22 -07:00
{
UI: Create best matching audio encoder for given bitrate
2015-07-02 01:00:22 -07:00
const char *id_ = GetAACEncoderForBitrate(bitrate);
if (!id_) {
id.clear();
res = nullptr;
return false;
UI: Move AAC encoder creation
2015-06-05 16:52:22 -07:00
}
UI: Create best matching audio encoder for given bitrate
2015-07-02 01:00:22 -07: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-05 16:52:22 -07: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 03:17:33 -08: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-18 22:29:36 -07: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 03:17:33 -08: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-18 22:29:36 -07:00
string aacRecEncID;
string aacStreamEncID;
string videoEncoder;
string videoQuality;
bool usingRecordingPreset = false;
bool ffmpegOutput = false;
bool lowCPUx264 = false;
UI: Create best matching audio encoder for given bitrate
2015-07-02 01:00:22 -07: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 03:17:33 -08: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-18 22:29:36 -07:00
int CalcCRF(int crf);
void UpdateRecordingSettings_x264_crf(int crf);
UI: Add support for QSV encoder to simple output
2016-04-18 00:56:51 -07: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 11:21:37 -07:00
void UpdateRecordingSettings_nvenc(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-18 22:29:36 -07: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 03:17:33 -08:00
virtual void Update() override;
void SetupOutputs();
UI: Move output handler audio bitrate config access
2015-07-02 00:58:28 -07: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 03:17:33 -08:00
UI: Add support for QSV encoder to simple output
2016-04-18 00:56:51 -07: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-18 22:29:36 -07:00
void LoadRecordingPreset_Lossless();
void LoadRecordingPreset();
UI: Add support for QSV encoder to simple output
2016-04-18 00:56:51 -07:00
void LoadStreamingPreset_h264(const char *encoder);
UI: Refactor output handling To accommodate multiple types of outputs, there has to be some level of abstraction. The BasicOutputHandler structure will give us a way that we can switch between different output configurations.
2015-02-06 03:17:33 -08:00
virtual bool StartStreaming(obs_service_t *service) override;
virtual bool StartRecording() 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 07:37:54 -07:00
virtual void StopStreaming(bool force) override;
virtual void StopRecording(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 03:17:33 -08:00
virtual bool StreamingActive() const override;
virtual bool RecordingActive() const override;
};
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-18 22:29:36 -07: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-09 18:46:15 -08: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-19 21:21:34 -07: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-09 19:24:44 -08: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-18 22:29:36 -07:00
obs_output_update(fileOutput, settings);
obs_data_release(settings);
}
UI: Add support for QSV encoder to simple output
2016-04-18 00:56:51 -07: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-18 22:29:36 -07:00
{
UI: Add support for QSV encoder to simple output
2016-04-18 00:56:51 -07: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-18 22:29:36 -07: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 00:56:51 -07: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-18 22:29:36 -07:00
UI: Add support for QSV encoder to simple output
2016-04-18 00:56:51 -07: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-18 22:29:36 -07: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 00:56:51 -07: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: Add NVENC support to simple output
2016-04-18 16:12:59 -07: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 00:56:51 -07: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-18 22:29:36 -07:00
usingRecordingPreset = true;
UI: Add support for QSV encoder to simple output
2016-04-18 00:56:51 -07: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-18 22:29:36 -07: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 03:17:33 -08:00
SimpleOutput::SimpleOutput(OBSBasic *main_) : BasicOutputHandler(main_)
{
streamOutput = obs_output_create("rtmp_output", "simple_stream",
(API Change) libobs: Add hotkey data to *_create functions
2014-11-01 13:41:17 -07:00
nullptr, 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 03:17:33 -08:00
if (!streamOutput)
throw "Failed to create stream output (simple output)";
(API Change) libobs: Make obs_output refcounted
2015-05-03 16:55:43 -07:00
obs_output_release(streamOutput);
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 03:17:33 -08:00
UI: Add support for QSV encoder to simple output
2016-04-18 00:56:51 -07:00
const char *encoder = config_get_string(main->Config(), "SimpleOutput",
"StreamEncoder");
if (strcmp(encoder, SIMPLE_ENCODER_QSV) == 0)
LoadStreamingPreset_h264("obs_qsv11");
UI: Add NVENC support to simple output
2016-04-18 16:12:59 -07: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 00:56:51 -07: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 03:17:33 -08: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-18 22:29:36 -07:00
if (!CreateAACEncoder(aacStreaming, aacStreamEncID, GetAudioBitrate(),
UI: Create best matching audio encoder for given bitrate
2015-07-02 01:00:22 -07: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-18 22:29:36 -07: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 03:17:33 -08:00
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-06 16:19:53 -07:00
streamDelayStarting.Connect(obs_output_get_signal_handler(streamOutput),
"starting", OBSStreamStarting, 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 01:47:08 -07:00
streamStopping.Connect(obs_output_get_signal_handler(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-06 16:19:53 -07:00
"stopping", OBSStreamStopping, this);
UI: Release recording/streaming signals before outputs
2015-07-03 23:00:21 -07:00
startStreaming.Connect(obs_output_get_signal_handler(streamOutput),
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 03:17:33 -08:00
"start", OBSStartStreaming, this);
UI: Release recording/streaming signals before outputs
2015-07-03 23:00:21 -07:00
stopStreaming.Connect(obs_output_get_signal_handler(streamOutput),
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 03:17:33 -08:00
"stop", OBSStopStreaming, this);
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-18 22:29:36 -07:00
LoadRecordingPreset();
if (!ffmpegOutput) {
fileOutput = obs_output_create("ffmpeg_muxer",
"simple_file_output", nullptr, nullptr);
if (!fileOutput)
throw "Failed to create recording output "
"(simple output)";
obs_output_release(fileOutput);
}
UI: Release recording/streaming signals before outputs
2015-07-03 23:00:21 -07: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 03:17:33 -08:00
"start", OBSStartRecording, this);
UI: Release recording/streaming signals before outputs
2015-07-03 23:00:21 -07: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 03:17:33 -08: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 01:47:08 -07: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 03:17:33 -08:00
}
UI: Move output handler audio bitrate config access
2015-07-02 00:58:28 -07: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-21 18:36:26 -07: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 00:58:28 -07: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 03:17:33 -08: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 00:58:28 -07: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 03:17:33 -08: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 03:10:36 -07: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 03:17:33 -08:00
const char *custom = config_get_string(main->Config(),
"SimpleOutput", "x264Settings");
UI: Add support for QSV encoder to simple output
2016-04-18 00:56:51 -07:00
const char *encoder = config_get_string(main->Config(), "SimpleOutput",
"StreamEncoder");
const char *presetType;
const char *preset;
if (strcmp(encoder, SIMPLE_ENCODER_QSV) == 0)
presetType = "QSVPreset";
UI: Add NVENC support to simple output
2016-04-18 16:12:59 -07:00
else if (strcmp(encoder, SIMPLE_ENCODER_NVENC) == 0)
presetType = "NVENCPreset";
UI: Add support for QSV encoder to simple output
2016-04-18 00:56:51 -07:00
else
presetType = "Preset";
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 03:17:33 -08:00
UI: Set simple output mode to always use CBR for stream
2016-05-26 07:54:29 -07: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 03:17:33 -08: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 11:20:51 -07: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 03:17:33 -08: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-07 16:32:00 -08: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-10 22:53:42 -07: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 03:10:36 -07: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-10 22:53:42 -07: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 03:10:36 -07: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 02:48:06 -07: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-18 22:29:36 -07: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 02:48:06 -07: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-18 22:29:36 -07: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 03:17:33 -08: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-18 22:29:36 -07: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 11:20:51 -07: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-18 22:29:36 -07: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 11:20:51 -07: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-18 22:29:36 -07: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 00:56:51 -07: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 13:19:38 -07:00
if (strcmp(val, "ICQ") == 0) {
UI: Add support for QSV encoder to simple output
2016-04-18 00:56:51 -07: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 13:19:38 -07:00
obs_data_set_string(settings, "rate_control", "ICQ");
UI: Add support for QSV encoder to simple output
2016-04-18 00:56:51 -07: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 11:21:37 -07:00
void SimpleOutput::UpdateRecordingSettings_nvenc(int cqp)
UI: Add NVENC support to simple output
2016-04-18 16:12:59 -07: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 11:21:37 -07:00
obs_data_set_string(settings, "rate_control", "CQP");
UI: Add NVENC support to simple output
2016-04-18 16:12:59 -07: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 11:21:37 -07:00
obs_data_set_int(settings, "cqp", cqp);
UI: Add NVENC support to simple output
2016-04-18 16:12:59 -07:00
obs_encoder_update(h264Recording, settings);
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-18 22:29:36 -07:00
void SimpleOutput::UpdateRecordingSettings()
{
UI: Add NVENC support to simple output
2016-04-18 16:12:59 -07: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 00:56:51 -07: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-18 22:29:36 -07:00
if (astrcmp_n(videoEncoder.c_str(), "x264", 4) == 0) {
UI: Add support for QSV encoder to simple output
2016-04-18 00:56:51 -07:00
UpdateRecordingSettings_x264_crf(crf);
} else if (videoEncoder == SIMPLE_ENCODER_QSV) {
UpdateRecordingSettings_qsv11(crf);
UI: Add NVENC support to simple output
2016-04-18 16:12:59 -07: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 11:21:37 -07: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-18 22:29:36 -07: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 03:17:33 -08: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-18 22:29:36 -07: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 03:17:33 -08:00
}
bool SimpleOutput::StartStreaming(obs_service_t *service)
{
if (!Active())
SetupOutputs();
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-18 22:29:36 -07: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 03:17:33 -08: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-10 19:10:40 -07: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 03:17:33 -08: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-10 19:10:40 -07: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 03:17:33 -08: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-10 19:10:40 -07: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 03:17:33 -08: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-06 16:19:53 -07: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 08:30:54 -07:00
const char *bindIP = config_get_string(main->Config(), "Output",
"BindIP");
obs_data_t *settings = obs_data_create();
obs_data_set_string(settings, "bind_ip", bindIP);
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 03:17:33 -08: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-06 16:19:53 -07: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 03:17:33 -08:00
obs_output_set_reconnect_settings(streamOutput, maxRetries,
retryDelay);
if (obs_output_start(streamOutput)) {
return true;
}
return false;
}
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-04 23:11:24 -07: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: 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 03:17:33 -08:00
bool SimpleOutput::StartRecording()
{
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-18 22:29:36 -07: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 03:17:33 -08:00
if (!Active())
SetupOutputs();
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 09:45:54 -07:00
const char *format = config_get_string(main->Config(),
"SimpleOutput", "RecFormat");
UI: Add custom muxer settings for ffmpeg-mux
2015-11-23 06:36:06 -08: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 03:14:18 -08: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 02:43:38 -07:00
const char *filenameFormat = config_get_string(main->Config(), "Output",
"FilenameFormatting");
bool overwriteIfExists = config_get_bool(main->Config(), "Output",
"OverwriteIfExists");
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 03:17:33 -08:00
os_dir_t *dir = path ? os_opendir(path) : nullptr;
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 07:36:17 -07:00
if (main->isVisible())
QMessageBox::information(main,
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 03:17:33 -08: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 02:43:38 -07: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-04 23:11:24 -07: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 02:43:38 -07: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 03:17:33 -08: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-18 22:29:36 -07:00
if (!ffmpegOutput) {
obs_output_set_video_encoder(fileOutput, h264Recording);
obs_output_set_audio_encoder(fileOutput, aacRecording, 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 03:17:33 -08:00
obs_data_t *settings = obs_data_create();
UI: Add recording presets to simple output So certain high-profile individuals were complaining that it was difficult to configure recording settings for quality in OBS. So, I decided to add a very easy-to-use auto-configuration for high quality encoding -- including lossless encoding. This feature will automatically configure ideal recording settings based upon a specified quality level. Recording quality presets added to simple output: - Same as stream: Copies the encoded streaming data with no extra usage hit. - High quality: uses a higher CRF value (starting at 23) if using x264. - Indistinguishable quality: uses a low CRF value (starting at 16) if using x264. - Lossless will spawn an FFmpeg output that uses huffyuv encoding. If a user tries to select lossless, they will be warned both via a dialog prompt and a warning message in the settings window to ensure they understand that it requires tremendous amounts of free space. It will always use the AVI file format. Extra Notes: - When High/Indistinguishable quality is set, it will allow you to select the recording encoder. Currently, it just allows you to select x264 (at either veryfast or ultrafast). Later on, it'll be useful to be able to set up pre-configured presets for hardware encoders once more are implemented and tested. - I decided to allow the use of x264 at both veryfast or ultrafast presets. The reasoning is two-fold: 1.) ultrafast is perfectly viable even for near indistinguishable quality as long as it has the appropriate CRF value. It's nice if you want to record but would like to or need to reduce the impact of encoding on the CPU. It will automatically compensate for the preset at the cost of larger file size. 2.) It was suggested to just always use ultrafast, but ultrafast requires 2-4x as much disk space for the same CRF (most likely due to x264 compensating for the preset). Providing veryfast is important if you really want to reduce file size and/or reduce blocking at lower quality levels. - When a recording preset is used, a secondary audio encoder is also spawned at 192 bitrate to ensure high quality audio. I chose 192 because that's the limit of the media foundation aac encoder on windows, which I want to make sure is used if available due to its high performance. - The CRF calculation is based upon resolution, quality, and whether it's set to ultrafast. First, quality sets the base CRF, 23 for "good" quality, 16 for "very high" quality. If set to ultrafast, it'll subtract 2 points from the CRF value to help compensate. Lower resolutions will also lower the CRF value to help improve higher details with a smaller pixel ratio.
2015-09-18 22:29:36 -07:00
obs_data_set_string(settings, ffmpegOutput ? "url" : "path",
strPath.c_str());
UI: Add custom muxer settings for ffmpeg-mux
2015-11-23 06:36:06 -08: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 03:17:33 -08:00
obs_output_update(fileOutput, settings);
obs_data_release(settings);
if (obs_output_start(fileOutput)) {
return true;
}
return false;
}
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 07:37:54 -07: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 03:17:33 -08: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 07:37:54 -07: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-06 16:19:53 -07: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 07:37:54 -07: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 03:17:33 -08: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 07:37:54 -07: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 03:17:33 -08:00
}
bool SimpleOutput::StreamingActive() const
{
return obs_output_active(streamOutput);
}
bool SimpleOutput::RecordingActive() const
{
return obs_output_active(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 13:41:22 -08:00
struct AdvancedOutput : BasicOutputHandler {
OBSEncoder aacTrack[4];
OBSEncoder h264Streaming;
OBSEncoder h264Recording;
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-18 20:58:24 -07: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 13:41:22 -08:00
bool ffmpegRecording;
bool useStreamEncoder;
UI: Create best matching audio encoder for given bitrate
2015-07-02 01:00:22 -07:00
string aacEncoderID[4];
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 13:41:22 -08: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-07 16:32:00 -08: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 13:41:22 -08: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 00:58:28 -07: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 13:41:22 -08:00
virtual bool StartStreaming(obs_service_t *service) override;
virtual bool StartRecording() 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 07:37:54 -07:00
virtual void StopStreaming(bool force) override;
virtual void StopRecording(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 13:41:22 -08:00
virtual bool StreamingActive() const override;
virtual bool RecordingActive() const override;
};
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-23 19:38:01 -07: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 13:41:22 -08: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-18 20:58:24 -07: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 13:41:22 -08: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-23 19:38:01 -07: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 13:41:22 -08:00
streamOutput = obs_output_create("rtmp_output", "adv_stream",
(API Change) libobs: Add hotkey data to *_create functions
2014-11-01 13:41:17 -07:00
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 13:41:22 -08:00
if (!streamOutput)
throw "Failed to create stream output (advanced output)";
(API Change) libobs: Make obs_output refcounted
2015-05-03 16:55:43 -07:00
obs_output_release(streamOutput);
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 13:41:22 -08:00
UI: Allow generated filenames for FFmpeg output This changes the way the advanced output section's FFmpeg output settings work by allowing the user to select whether they want to output to a file or output to a URL, and makes it so file names are automatically generated like other recording outputs. If they choose to output to a file, it'll only require an output directory similarly to how other recording outputs work. They can select a directory to output to rather than being required to type in a full path and filename; the filename is automatically generated. The extension is also automatically retrieved from libff depending on the format selected. Otherwise if they have Output to URL selected, it'll show a simple edit box where they can type in the target URL.
2015-08-18 20:58:24 -07: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 13:41:22 -08:00
fileOutput = obs_output_create("ffmpeg_output",
(API Change) libobs: Add hotkey data to *_create functions
2014-11-01 13:41:17 -07: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 13:41:22 -08:00
if (!fileOutput)
throw "Failed to create recording FFmpeg output "
"(advanced output)";
(API Change) libobs: Make obs_output refcounted
2015-05-03 16:55:43 -07: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 13:41:22 -08:00
} else {
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-28 23:27:06 -07: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 13:41:22 -08:00
if (!fileOutput)
throw "Failed to create recording output "
"(advanced output)";
(API Change) libobs: Make obs_output refcounted
2015-05-03 16:55:43 -07: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 13:41:22 -08:00
if (!useStreamEncoder) {
h264Recording = obs_video_encoder_create(recordEncoder,
(API Change) libobs: Add hotkey data to *_create functions
2014-11-01 13:41:17 -07: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 13:41:22 -08:00
if (!h264Recording)
throw "Failed to create recording h264 "
"encoder (advanced output)";
(API Change) libobs: Make obs_encoder refcounted
2015-05-03 17:01:38 -07: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 13:41:22 -08:00
}
}
h264Streaming = obs_video_encoder_create(streamEncoder,
(API Change) libobs: Add hotkey data to *_create functions
2014-11-01 13:41:17 -07: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 13:41:22 -08:00
if (!h264Streaming)
throw "Failed to create streaming h264 encoder "
"(advanced output)";
(API Change) libobs: Make obs_encoder refcounted
2015-05-03 17:01:38 -07: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 13:41:22 -08:00
for (int i = 0; i < 4; i++) {
char name[9];
sprintf(name, "adv_aac%d", i);
UI: Create best matching audio encoder for given bitrate
2015-07-02 01:00:22 -07: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 13:41:22 -08:00
throw "Failed to create audio encoder "
"(advanced output)";
}
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-06 16:19:53 -07:00
streamDelayStarting.Connect(obs_output_get_signal_handler(streamOutput),
"starting", OBSStreamStarting, 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 01:47:08 -07:00
streamStopping.Connect(obs_output_get_signal_handler(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-06 16:19:53 -07:00
"stopping", OBSStreamStopping, this);
UI: Release recording/streaming signals before outputs
2015-07-03 23:00:21 -07:00
startStreaming.Connect(obs_output_get_signal_handler(streamOutput),
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 13:41:22 -08:00
"start", OBSStartStreaming, this);
UI: Release recording/streaming signals before outputs
2015-07-03 23:00:21 -07:00
stopStreaming.Connect(obs_output_get_signal_handler(streamOutput),
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 13:41:22 -08:00
"stop", OBSStopStreaming, this);
UI: Release recording/streaming signals before outputs
2015-07-03 23:00:21 -07: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 13:41:22 -08:00
"start", OBSStartRecording, this);
UI: Release recording/streaming signals before outputs
2015-07-03 23:00:21 -07: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 13:41:22 -08: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 01:47:08 -07: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 13:41:22 -08: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-07 16:32:00 -08: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-23 19:38:01 -07: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-07 16:32:00 -08: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 02:48:06 -07: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 13:41:22 -08: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-23 19:38:01 -07: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 13:41:22 -08: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-18 20:58:24 -07: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 13:41:22 -08: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-07 16:32:00 -08: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 13:41:22 -08:00
}
inline void AdvancedOutput::SetupStreaming()
{
bool rescale = config_get_bool(main->Config(), "AdvOut",
"Rescale");
const char *rescaleRes = config_get_string(main->Config(), "AdvOut",
"RescaleRes");
bool multitrack = config_get_bool(main->Config(), "AdvOut",
"Multitrack");
int trackIndex = config_get_int(main->Config(), "AdvOut",
"TrackIndex");
int trackCount = config_get_int(main->Config(), "AdvOut",
"TrackCount");
unsigned int cx = 0;
unsigned int cy = 0;
UI: Ensure rescale res is non-null and length > 0
2015-03-31 13:48:06 -07: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 13:41:22 -08:00
}
obs_encoder_set_scaled_size(h264Streaming, cx, cy);
obs_encoder_set_video(h264Streaming, obs_get_video());
obs_output_set_video_encoder(streamOutput, h264Streaming);
if (multitrack) {
int i = 0;
(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-07 16:32:00 -08:00
for (; i < trackCount; 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 13:41:22 -08:00
obs_output_set_audio_encoder(streamOutput, aacTrack[i],
i);
for (; i < 4; i++)
obs_output_set_audio_encoder(streamOutput, nullptr, i);
UI: Add "enforce streaming service settings" Add a checkbox named "Enforce streaming service encoder settings" checkbox to advanced output. Disabling this checkbox allows the user to optionally disable the enforcement of streaming service encoder settings. I had a user complain that they didn't want to always have the service's preferred encoder settings forced on them.
2015-02-10 20:06:00 -08: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 13:41:22 -08:00
} else {
obs_output_set_audio_encoder(streamOutput,
aacTrack[trackIndex - 1], 0);
}
}
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 06:36:06 -08: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 13:41:22 -08: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-30 21:45:14 -07: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 13:41:22 -08: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-30 21:45:14 -07: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 13:41:22 -08:00
if (useStreamEncoder) {
obs_output_set_video_encoder(fileOutput, h264Streaming);
} else {
UI: Ensure rescale res is non-null and length > 0
2015-03-31 13:48:06 -07: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 13:41:22 -08: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: Allow multi-track recording in advanced output
2015-05-30 21:45:14 -07: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 13:41:22 -08:00
obs_output_set_audio_encoder(fileOutput, aacTrack[i],
UI: Allow multi-track recording in advanced output
2015-05-30 21:45:14 -07:00
idx++);
}
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 13:41:22 -08:00
}
obs_data_set_string(settings, "path", path);
UI: Add custom muxer settings for ffmpeg-mux
2015-11-23 06:36:06 -08: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 13:41:22 -08:00
obs_output_update(fileOutput, settings);
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");
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 00:21:16 -07: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 01:26:48 -07: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 13:41:22 -08: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 00:21:16 -07: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 13:41:22 -08: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 00:21:16 -07: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 13:41:22 -08: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 00:21:16 -07: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 01:26:48 -07:00
obs_data_set_string(settings, "muxer_settings", muxCustom);
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 13:41:22 -08: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 00:21:16 -07: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 13:41:22 -08: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 00:21:16 -07: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 13:41:22 -08: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-07 16:32:00 -08: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 13:41:22 -08:00
{
const char *name1 = config_get_string(main->Config(), "AdvOut",
"Track1Name");
const char *name2 = config_get_string(main->Config(), "AdvOut",
"Track2Name");
const char *name3 = config_get_string(main->Config(), "AdvOut",
"Track3Name");
const char *name4 = config_get_string(main->Config(), "AdvOut",
"Track4Name");
(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-07 16:32:00 -08: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 12:38:38 -07:00
int streamTrackIndex = config_get_int(main->Config(), "AdvOut",
"TrackIndex");
UI: Add advanced output settings Adds an 'advanced' mode to the output settings to allow more powerful and complex streaming and recording options: - Optionally use a different encoder for recording than for streaming to allow the recording to use a different encoder or encoder settings if desired (though at the cost if increased CPU usage depending on the encoders being used) - Use encoders other than x264 - Rescale the recording or streaming encoders in case the user wishes to stream and record at different resolutions - Select the specific mixer to use for recording and for streaming, allowing the stream and recording to use separate mixers (to for example allow a user to stream the game/mic audio but only record the game audio) - Use FFmpeg output for the recording button instead of only recording h264/aac to FLV, allowing the user to output to various different types of file formats or remote URLs, as well as allowing the user to select and use different encoders and encoder settings that are available in the FFmpeg library - Optionally allow the use of multiple audio tracks in a single output if the file formats or stream services support it
2015-01-26 13:41:22 -08:00
obs_data_t *settings[4];
UI: Move output handler audio bitrate config access
2015-07-02 00:58:28 -07:00
for (size_t i = 0; i < 4; 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 13:41:22 -08:00
settings[i] = obs_data_create();
UI: Move output handler audio bitrate config access
2015-07-02 00:58:28 -07: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 13:41:22 -08:00
SetEncoderName(aacTrack[0], name1, "Track1");
SetEncoderName(aacTrack[1], name2, "Track2");
SetEncoderName(aacTrack[2], name3, "Track3");
SetEncoderName(aacTrack[3], name4, "Track4");
for (size_t i = 0; i < 4; i++) {
UI: Fix bug with enforced audio encoder settings I forgot that the track index is 1-based, not 0-bsaed.
2015-03-27 13:35:43 -07: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-07 16:32:00 -08: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 13:41:22 -08: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());
obs_encoder_set_audio(aacTrack[0], obs_get_audio());
obs_encoder_set_audio(aacTrack[1], obs_get_audio());
obs_encoder_set_audio(aacTrack[2], obs_get_audio());
obs_encoder_set_audio(aacTrack[3], obs_get_audio());
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-18 20:58:24 -07: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 13:41:22 -08:00
SetupFFmpeg();
else
SetupRecording();
}
UI: Move output handler audio bitrate config access
2015-07-02 00:58:28 -07:00
int AdvancedOutput::GetAudioBitrate(size_t i) const
{
const char *names[] = {
"Track1Bitrate", "Track2Bitrate",
"Track3Bitrate", "Track4Bitrate",
};
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-21 18:36:26 -07: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 00:58:28 -07: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 13:41:22 -08: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-14 18:10:39 -08: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-18 20:58:24 -07: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-14 18:10:39 -08: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-07 16:32:00 -08: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 13:41:22 -08:00
if (!Active())
SetupOutputs();
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-10 19:10:40 -07: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-06 16:19:53 -07: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 08:30:54 -07:00
const char *bindIP = config_get_string(main->Config(), "Output",
"BindIP");
obs_data_t *settings = obs_data_create();
obs_data_set_string(settings, "bind_ip", bindIP);
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 13:41:22 -08: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-06 16:19:53 -07: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 13:41:22 -08:00
obs_output_set_reconnect_settings(streamOutput, maxRetries,
retryDelay);
if (obs_output_start(streamOutput)) {
return true;
}
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-18 20:58:24 -07: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 02:43:38 -07: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 03:14:18 -08: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 02:43:38 -07: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-18 20:58:24 -07: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-14 18:10:39 -08: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-18 20:58:24 -07: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-14 18:10:39 -08: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-07 16:32:00 -08: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 13:41:22 -08: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-18 20:58:24 -07: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 02:43:38 -07: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-18 20:58:24 -07: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 02:43:38 -07: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 03:14:18 -08: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 13:41:22 -08:00
os_dir_t *dir = path ? os_opendir(path) : nullptr;
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 07:36:17 -07:00
if (main->isVisible())
QMessageBox::information(main,
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 13:41:22 -08: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 02:43:38 -07: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-04 23:11:24 -07: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 02:43:38 -07: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 13:41:22 -08: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-18 20:58:24 -07: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 13:41:22 -08:00
obs_output_update(fileOutput, settings);
obs_data_release(settings);
}
if (obs_output_start(fileOutput)) {
return true;
}
return false;
}
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 07:37:54 -07: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 13:41:22 -08: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 07:37:54 -07: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-06 16:19:53 -07: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 07:37:54 -07: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 13:41:22 -08: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 07:37:54 -07: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 13:41:22 -08:00
}
bool AdvancedOutput::StreamingActive() const
{
return obs_output_active(streamOutput);
}
bool AdvancedOutput::RecordingActive() const
{
return obs_output_active(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 03:17:33 -08: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 13:41:22 -08:00
BasicOutputHandler *CreateAdvancedOutputHandler(OBSBasic *main)
{
return new AdvancedOutput(main);
}