mirror of
https://github.com/obsproject/obs-studio.git
synced 2024-09-20 04:42:18 +02:00
7cd7ca80f8
This change allows the virtual camera to really output what is in the program view, some plugin interract with this view but their changes does not appear on the virtual camera.
2440 lines
70 KiB
C++
2440 lines
70 KiB
C++
#include <string>
|
|
#include <algorithm>
|
|
#include <QMessageBox>
|
|
#include "qt-wrappers.hpp"
|
|
#include "audio-encoders.hpp"
|
|
#include "window-basic-main.hpp"
|
|
#include "window-basic-main-outputs.hpp"
|
|
#include "window-basic-vcam-config.hpp"
|
|
|
|
using namespace std;
|
|
|
|
extern bool EncoderAvailable(const char *encoder);
|
|
|
|
volatile bool streaming_active = false;
|
|
volatile bool recording_active = false;
|
|
volatile bool recording_paused = false;
|
|
volatile bool replaybuf_active = false;
|
|
volatile bool virtualcam_active = false;
|
|
|
|
#define FTL_PROTOCOL "ftl"
|
|
#define RTMP_PROTOCOL "rtmp"
|
|
|
|
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)
|
|
QMetaObject::invokeMethod(output->main, "StreamStopping");
|
|
else
|
|
QMetaObject::invokeMethod(output->main, "StreamDelayStopping",
|
|
Q_ARG(int, sec));
|
|
}
|
|
|
|
static void OBSStartStreaming(void *data, calldata_t * /* params */)
|
|
{
|
|
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
|
|
output->streamingActive = true;
|
|
os_atomic_set_bool(&streaming_active, true);
|
|
QMetaObject::invokeMethod(output->main, "StreamingStart");
|
|
}
|
|
|
|
static void OBSStopStreaming(void *data, calldata_t *params)
|
|
{
|
|
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
|
|
int code = (int)calldata_int(params, "code");
|
|
const char *last_error = calldata_string(params, "last_error");
|
|
|
|
QString arg_last_error = QString::fromUtf8(last_error);
|
|
|
|
output->streamingActive = false;
|
|
output->delayActive = false;
|
|
os_atomic_set_bool(&streaming_active, false);
|
|
QMetaObject::invokeMethod(output->main, "StreamingStop",
|
|
Q_ARG(int, code),
|
|
Q_ARG(QString, arg_last_error));
|
|
}
|
|
|
|
static void OBSStartRecording(void *data, calldata_t * /* params */)
|
|
{
|
|
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
|
|
|
|
output->recordingActive = true;
|
|
os_atomic_set_bool(&recording_active, true);
|
|
QMetaObject::invokeMethod(output->main, "RecordingStart");
|
|
}
|
|
|
|
static void OBSStopRecording(void *data, calldata_t *params)
|
|
{
|
|
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
|
|
int code = (int)calldata_int(params, "code");
|
|
const char *last_error = calldata_string(params, "last_error");
|
|
|
|
QString arg_last_error = QString::fromUtf8(last_error);
|
|
|
|
output->recordingActive = false;
|
|
os_atomic_set_bool(&recording_active, false);
|
|
os_atomic_set_bool(&recording_paused, false);
|
|
QMetaObject::invokeMethod(output->main, "RecordingStop",
|
|
Q_ARG(int, code),
|
|
Q_ARG(QString, arg_last_error));
|
|
}
|
|
|
|
static void OBSRecordStopping(void *data, calldata_t * /* params */)
|
|
{
|
|
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
|
|
QMetaObject::invokeMethod(output->main, "RecordStopping");
|
|
}
|
|
|
|
static void OBSRecordFileChanged(void *data, calldata_t *params)
|
|
{
|
|
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
|
|
const char *next_file = calldata_string(params, "next_file");
|
|
|
|
QString arg_last_file =
|
|
QString::fromUtf8(output->lastRecordingPath.c_str());
|
|
|
|
QMetaObject::invokeMethod(output->main, "RecordingFileChanged",
|
|
Q_ARG(QString, arg_last_file));
|
|
|
|
output->lastRecordingPath = next_file;
|
|
}
|
|
|
|
static void OBSStartReplayBuffer(void *data, calldata_t * /* params */)
|
|
{
|
|
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
|
|
|
|
output->replayBufferActive = true;
|
|
os_atomic_set_bool(&replaybuf_active, true);
|
|
QMetaObject::invokeMethod(output->main, "ReplayBufferStart");
|
|
}
|
|
|
|
static void OBSStopReplayBuffer(void *data, calldata_t *params)
|
|
{
|
|
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
|
|
int code = (int)calldata_int(params, "code");
|
|
|
|
output->replayBufferActive = false;
|
|
os_atomic_set_bool(&replaybuf_active, false);
|
|
QMetaObject::invokeMethod(output->main, "ReplayBufferStop",
|
|
Q_ARG(int, code));
|
|
}
|
|
|
|
static void OBSReplayBufferStopping(void *data, calldata_t * /* params */)
|
|
{
|
|
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
|
|
QMetaObject::invokeMethod(output->main, "ReplayBufferStopping");
|
|
}
|
|
|
|
static void OBSReplayBufferSaved(void *data, calldata_t * /* params */)
|
|
{
|
|
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
|
|
QMetaObject::invokeMethod(output->main, "ReplayBufferSaved",
|
|
Qt::QueuedConnection);
|
|
}
|
|
|
|
static void OBSStartVirtualCam(void *data, calldata_t * /* params */)
|
|
{
|
|
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
|
|
|
|
output->virtualCamActive = true;
|
|
os_atomic_set_bool(&virtualcam_active, true);
|
|
QMetaObject::invokeMethod(output->main, "OnVirtualCamStart");
|
|
}
|
|
|
|
static void OBSStopVirtualCam(void *data, calldata_t *params)
|
|
{
|
|
BasicOutputHandler *output = static_cast<BasicOutputHandler *>(data);
|
|
int code = (int)calldata_int(params, "code");
|
|
|
|
output->virtualCamActive = false;
|
|
os_atomic_set_bool(&virtualcam_active, false);
|
|
QMetaObject::invokeMethod(output->main, "OnVirtualCamStop",
|
|
Q_ARG(int, code));
|
|
|
|
obs_output_set_media(output->virtualCam, nullptr, nullptr);
|
|
output->DestroyVirtualCamView();
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
static bool CreateSimpleAACEncoder(OBSEncoder &res, int bitrate,
|
|
const char *name, size_t idx)
|
|
{
|
|
const char *id_ = GetSimpleAACEncoderForBitrate(bitrate);
|
|
if (!id_) {
|
|
res = nullptr;
|
|
return false;
|
|
}
|
|
|
|
res = obs_audio_encoder_create(id_, name, nullptr, idx, nullptr);
|
|
|
|
if (res) {
|
|
obs_encoder_release(res);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static bool CreateSimpleOpusEncoder(OBSEncoder &res, int bitrate,
|
|
const char *name, size_t idx)
|
|
{
|
|
const char *id_ = GetSimpleOpusEncoderForBitrate(bitrate);
|
|
if (!id_) {
|
|
res = nullptr;
|
|
return false;
|
|
}
|
|
|
|
res = obs_audio_encoder_create(id_, name, nullptr, idx, nullptr);
|
|
|
|
if (res) {
|
|
obs_encoder_release(res);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static inline bool can_use_output(const char *prot, const char *output,
|
|
const char *prot_test1,
|
|
const char *prot_test2 = nullptr)
|
|
{
|
|
return (strcmp(prot, prot_test1) == 0 ||
|
|
(prot_test2 && strcmp(prot, prot_test2) == 0)) &&
|
|
(obs_get_output_flags(output) & OBS_OUTPUT_SERVICE) != 0;
|
|
}
|
|
|
|
static bool return_first_id(void *data, const char *id)
|
|
{
|
|
const char **output = (const char **)data;
|
|
|
|
*output = id;
|
|
return false;
|
|
}
|
|
|
|
static const char *GetStreamOutputType(const obs_service_t *service)
|
|
{
|
|
const char *protocol = obs_service_get_protocol(service);
|
|
const char *output = nullptr;
|
|
|
|
if (!protocol) {
|
|
blog(LOG_WARNING, "The service '%s' has no protocol set",
|
|
obs_service_get_id(service));
|
|
return nullptr;
|
|
}
|
|
|
|
if (!obs_is_output_protocol_registered(protocol)) {
|
|
blog(LOG_WARNING, "The protocol '%s' is not registered",
|
|
protocol);
|
|
return nullptr;
|
|
}
|
|
|
|
/* Check if the service has a preferred output type */
|
|
output = obs_service_get_preferred_output_type(service);
|
|
if (output) {
|
|
if ((obs_get_output_flags(output) & OBS_OUTPUT_SERVICE) != 0)
|
|
return output;
|
|
|
|
blog(LOG_WARNING,
|
|
"The output '%s' is not registered, fallback to another one",
|
|
output);
|
|
}
|
|
|
|
/* Otherwise, prefer first-party output types */
|
|
if (can_use_output(protocol, "rtmp_output", "RTMP", "RTMPS")) {
|
|
return "rtmp_output";
|
|
} else if (can_use_output(protocol, "ffmpeg_hls_muxer", "HLS")) {
|
|
return "ffmpeg_hls_muxer";
|
|
} else if (can_use_output(protocol, "ffmpeg_mpegts_muxer", "SRT",
|
|
"RIST")) {
|
|
return "ffmpeg_mpegts_muxer";
|
|
}
|
|
|
|
/* If third-party protocol, use the first enumerated type */
|
|
obs_enum_output_types_with_protocol(protocol, &output, return_first_id);
|
|
if (output)
|
|
return output;
|
|
|
|
blog(LOG_WARNING,
|
|
"No output compatible with the service '%s' is registered",
|
|
obs_service_get_id(service));
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
inline BasicOutputHandler::BasicOutputHandler(OBSBasic *main_) : main(main_)
|
|
{
|
|
if (main->vcamEnabled) {
|
|
virtualCam = obs_output_create("virtualcam_output",
|
|
"virtualcam_output", nullptr,
|
|
nullptr);
|
|
|
|
signal_handler_t *signal =
|
|
obs_output_get_signal_handler(virtualCam);
|
|
startVirtualCam.Connect(signal, "start", OBSStartVirtualCam,
|
|
this);
|
|
stopVirtualCam.Connect(signal, "stop", OBSStopVirtualCam, this);
|
|
}
|
|
}
|
|
|
|
bool BasicOutputHandler::StartVirtualCam()
|
|
{
|
|
if (!main->vcamEnabled)
|
|
return false;
|
|
|
|
bool typeIsProgram = main->vcamConfig.type ==
|
|
VCamOutputType::ProgramView;
|
|
|
|
if (!virtualCamView && !typeIsProgram)
|
|
virtualCamView = obs_view_create();
|
|
|
|
UpdateVirtualCamOutputSource();
|
|
|
|
if (!virtualCamVideo) {
|
|
virtualCamVideo = typeIsProgram ? obs_get_video()
|
|
: obs_view_add(virtualCamView);
|
|
|
|
if (!virtualCamVideo)
|
|
return false;
|
|
}
|
|
|
|
obs_output_set_media(virtualCam, virtualCamVideo, obs_get_audio());
|
|
if (!Active())
|
|
SetupOutputs();
|
|
|
|
bool success = obs_output_start(virtualCam);
|
|
if (!success) {
|
|
QString errorReason;
|
|
|
|
const char *error = obs_output_get_last_error(virtualCam);
|
|
if (error) {
|
|
errorReason = QT_UTF8(error);
|
|
} else {
|
|
errorReason = QTStr("Output.StartFailedGeneric");
|
|
}
|
|
|
|
QMessageBox::critical(main,
|
|
QTStr("Output.StartVirtualCamFailed"),
|
|
errorReason);
|
|
|
|
DestroyVirtualCamView();
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
void BasicOutputHandler::StopVirtualCam()
|
|
{
|
|
if (main->vcamEnabled) {
|
|
obs_output_stop(virtualCam);
|
|
}
|
|
}
|
|
|
|
bool BasicOutputHandler::VirtualCamActive() const
|
|
{
|
|
if (main->vcamEnabled) {
|
|
return obs_output_active(virtualCam);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void BasicOutputHandler::UpdateVirtualCamOutputSource()
|
|
{
|
|
if (!main->vcamEnabled || !virtualCamView)
|
|
return;
|
|
|
|
OBSSourceAutoRelease source;
|
|
|
|
switch (main->vcamConfig.type) {
|
|
case VCamOutputType::Invalid:
|
|
case VCamOutputType::ProgramView:
|
|
DestroyVirtualCameraScene();
|
|
return;
|
|
case VCamOutputType::PreviewOutput: {
|
|
DestroyVirtualCameraScene();
|
|
OBSSource s = main->GetCurrentSceneSource();
|
|
obs_source_get_ref(s);
|
|
source = s.Get();
|
|
break;
|
|
}
|
|
case VCamOutputType::SceneOutput:
|
|
DestroyVirtualCameraScene();
|
|
source = obs_get_source_by_name(main->vcamConfig.scene.c_str());
|
|
break;
|
|
case VCamOutputType::SourceOutput:
|
|
OBSSourceAutoRelease s =
|
|
obs_get_source_by_name(main->vcamConfig.source.c_str());
|
|
|
|
if (!vCamSourceScene)
|
|
vCamSourceScene =
|
|
obs_scene_create_private("vcam_source");
|
|
source = obs_source_get_ref(
|
|
obs_scene_get_source(vCamSourceScene));
|
|
|
|
if (vCamSourceSceneItem &&
|
|
(obs_sceneitem_get_source(vCamSourceSceneItem) != s)) {
|
|
obs_sceneitem_remove(vCamSourceSceneItem);
|
|
vCamSourceSceneItem = nullptr;
|
|
}
|
|
|
|
if (!vCamSourceSceneItem) {
|
|
vCamSourceSceneItem = obs_scene_add(vCamSourceScene, s);
|
|
|
|
obs_sceneitem_set_bounds_type(vCamSourceSceneItem,
|
|
OBS_BOUNDS_SCALE_INNER);
|
|
obs_sceneitem_set_bounds_alignment(vCamSourceSceneItem,
|
|
OBS_ALIGN_CENTER);
|
|
|
|
const struct vec2 size = {
|
|
(float)obs_source_get_width(source),
|
|
(float)obs_source_get_height(source),
|
|
};
|
|
obs_sceneitem_set_bounds(vCamSourceSceneItem, &size);
|
|
}
|
|
break;
|
|
}
|
|
|
|
OBSSourceAutoRelease current = obs_view_get_source(virtualCamView, 0);
|
|
if (source != current)
|
|
obs_view_set_source(virtualCamView, 0, source);
|
|
}
|
|
|
|
void BasicOutputHandler::DestroyVirtualCamView()
|
|
{
|
|
if (main->vcamConfig.type == VCamOutputType::ProgramView) {
|
|
virtualCamVideo = nullptr;
|
|
return;
|
|
}
|
|
|
|
obs_view_remove(virtualCamView);
|
|
obs_view_set_source(virtualCamView, 0, nullptr);
|
|
virtualCamVideo = nullptr;
|
|
|
|
obs_view_destroy(virtualCamView);
|
|
virtualCamView = nullptr;
|
|
|
|
DestroyVirtualCameraScene();
|
|
}
|
|
|
|
void BasicOutputHandler::DestroyVirtualCameraScene()
|
|
{
|
|
if (!vCamSourceScene)
|
|
return;
|
|
|
|
obs_scene_release(vCamSourceScene);
|
|
vCamSourceScene = nullptr;
|
|
vCamSourceSceneItem = nullptr;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
struct SimpleOutput : BasicOutputHandler {
|
|
OBSEncoder audioStreaming;
|
|
OBSEncoder videoStreaming;
|
|
OBSEncoder audioRecording;
|
|
OBSEncoder audioArchive;
|
|
OBSEncoder videoRecording;
|
|
OBSEncoder audioTrack[MAX_AUDIO_MIXES];
|
|
|
|
string videoEncoder;
|
|
string videoQuality;
|
|
bool usingRecordingPreset = false;
|
|
bool recordingConfigured = false;
|
|
bool ffmpegOutput = false;
|
|
bool lowCPUx264 = false;
|
|
|
|
SimpleOutput(OBSBasic *main_);
|
|
|
|
int CalcCRF(int crf);
|
|
|
|
void UpdateRecordingSettings_x264_crf(int crf);
|
|
void UpdateRecordingSettings_qsv11(int crf, bool av1);
|
|
void UpdateRecordingSettings_nvenc(int cqp);
|
|
void UpdateRecordingSettings_nvenc_hevc_av1(int cqp);
|
|
void UpdateRecordingSettings_amd_cqp(int cqp);
|
|
void UpdateRecordingSettings_apple(int quality);
|
|
#ifdef ENABLE_HEVC
|
|
void UpdateRecordingSettings_apple_hevc(int quality);
|
|
#endif
|
|
void UpdateRecordingSettings();
|
|
void UpdateRecordingAudioSettings();
|
|
virtual void Update() override;
|
|
|
|
void SetupOutputs() override;
|
|
int GetAudioBitrate() const;
|
|
|
|
void LoadRecordingPreset_Lossy(const char *encoder);
|
|
void LoadRecordingPreset_Lossless();
|
|
void LoadRecordingPreset();
|
|
|
|
void LoadStreamingPreset_Lossy(const char *encoder);
|
|
|
|
void UpdateRecording();
|
|
bool ConfigureRecording(bool useReplayBuffer);
|
|
|
|
void SetupVodTrack(obs_service_t *service);
|
|
|
|
virtual bool SetupStreaming(obs_service_t *service) override;
|
|
virtual bool StartStreaming(obs_service_t *service) override;
|
|
virtual bool StartRecording() override;
|
|
virtual bool StartReplayBuffer() override;
|
|
virtual void StopStreaming(bool force) override;
|
|
virtual void StopRecording(bool force) override;
|
|
virtual void StopReplayBuffer(bool force) override;
|
|
virtual bool StreamingActive() const override;
|
|
virtual bool RecordingActive() const override;
|
|
virtual bool ReplayBufferActive() const override;
|
|
};
|
|
|
|
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)";
|
|
|
|
OBSDataAutoRelease settings = obs_data_create();
|
|
obs_data_set_string(settings, "format_name", "avi");
|
|
obs_data_set_string(settings, "video_encoder", "utvideo");
|
|
obs_data_set_string(settings, "audio_encoder", "pcm_s16le");
|
|
|
|
obs_output_update(fileOutput, settings);
|
|
}
|
|
|
|
void SimpleOutput::LoadRecordingPreset_Lossy(const char *encoderId)
|
|
{
|
|
videoRecording = obs_video_encoder_create(
|
|
encoderId, "simple_video_recording", nullptr, nullptr);
|
|
if (!videoRecording)
|
|
throw "Failed to create video recording encoder (simple output)";
|
|
obs_encoder_release(videoRecording);
|
|
}
|
|
|
|
void SimpleOutput::LoadStreamingPreset_Lossy(const char *encoderId)
|
|
{
|
|
videoStreaming = obs_video_encoder_create(
|
|
encoderId, "simple_video_stream", nullptr, nullptr);
|
|
if (!videoStreaming)
|
|
throw "Failed to create video streaming encoder (simple output)";
|
|
obs_encoder_release(videoStreaming);
|
|
}
|
|
|
|
/* mistakes have been made to lead us to this. */
|
|
const char *get_simple_output_encoder(const char *encoder)
|
|
{
|
|
if (strcmp(encoder, SIMPLE_ENCODER_X264) == 0) {
|
|
return "obs_x264";
|
|
} else if (strcmp(encoder, SIMPLE_ENCODER_X264_LOWCPU) == 0) {
|
|
return "obs_x264";
|
|
} else if (strcmp(encoder, SIMPLE_ENCODER_QSV) == 0) {
|
|
return "obs_qsv11_v2";
|
|
} else if (strcmp(encoder, SIMPLE_ENCODER_QSV_AV1) == 0) {
|
|
return "obs_qsv11_av1";
|
|
} else if (strcmp(encoder, SIMPLE_ENCODER_AMD) == 0) {
|
|
return "h264_texture_amf";
|
|
#ifdef ENABLE_HEVC
|
|
} else if (strcmp(encoder, SIMPLE_ENCODER_AMD_HEVC) == 0) {
|
|
return "h265_texture_amf";
|
|
#endif
|
|
} else if (strcmp(encoder, SIMPLE_ENCODER_AMD_AV1) == 0) {
|
|
return "av1_texture_amf";
|
|
} else if (strcmp(encoder, SIMPLE_ENCODER_NVENC) == 0) {
|
|
return EncoderAvailable("jim_nvenc") ? "jim_nvenc"
|
|
: "ffmpeg_nvenc";
|
|
#ifdef ENABLE_HEVC
|
|
} else if (strcmp(encoder, SIMPLE_ENCODER_NVENC_HEVC) == 0) {
|
|
return EncoderAvailable("jim_hevc_nvenc") ? "jim_hevc_nvenc"
|
|
: "ffmpeg_hevc_nvenc";
|
|
#endif
|
|
} else if (strcmp(encoder, SIMPLE_ENCODER_NVENC_AV1) == 0) {
|
|
return "jim_av1_nvenc";
|
|
} else if (strcmp(encoder, SIMPLE_ENCODER_APPLE_H264) == 0) {
|
|
return "com.apple.videotoolbox.videoencoder.ave.avc";
|
|
#ifdef ENABLE_HEVC
|
|
} else if (strcmp(encoder, SIMPLE_ENCODER_APPLE_HEVC) == 0) {
|
|
return "com.apple.videotoolbox.videoencoder.ave.hevc";
|
|
#endif
|
|
}
|
|
|
|
return "obs_x264";
|
|
}
|
|
|
|
void SimpleOutput::LoadRecordingPreset()
|
|
{
|
|
const char *quality =
|
|
config_get_string(main->Config(), "SimpleOutput", "RecQuality");
|
|
const char *encoder =
|
|
config_get_string(main->Config(), "SimpleOutput", "RecEncoder");
|
|
const char *audio_encoder = config_get_string(
|
|
main->Config(), "SimpleOutput", "RecAudioEncoder");
|
|
|
|
videoEncoder = encoder;
|
|
videoQuality = quality;
|
|
ffmpegOutput = false;
|
|
|
|
if (strcmp(quality, "Stream") == 0) {
|
|
videoRecording = videoStreaming;
|
|
audioRecording = audioStreaming;
|
|
usingRecordingPreset = false;
|
|
return;
|
|
|
|
} else if (strcmp(quality, "Lossless") == 0) {
|
|
LoadRecordingPreset_Lossless();
|
|
usingRecordingPreset = true;
|
|
ffmpegOutput = true;
|
|
return;
|
|
|
|
} else {
|
|
lowCPUx264 = false;
|
|
|
|
if (strcmp(encoder, SIMPLE_ENCODER_X264_LOWCPU) == 0)
|
|
lowCPUx264 = true;
|
|
LoadRecordingPreset_Lossy(get_simple_output_encoder(encoder));
|
|
usingRecordingPreset = true;
|
|
|
|
bool success = false;
|
|
|
|
if (strcmp(audio_encoder, "opus") == 0)
|
|
success = CreateSimpleOpusEncoder(
|
|
audioRecording, 192, "simple_opus_recording",
|
|
0);
|
|
else
|
|
success = CreateSimpleAACEncoder(
|
|
audioRecording, 192, "simple_aac_recording", 0);
|
|
|
|
if (!success)
|
|
throw "Failed to create audio recording encoder "
|
|
"(simple output)";
|
|
for (int i = 0; i < MAX_AUDIO_MIXES; i++) {
|
|
char name[23];
|
|
if (strcmp(audio_encoder, "opus") == 0) {
|
|
snprintf(name, sizeof name,
|
|
"simple_opus_recording%d", i);
|
|
success = CreateSimpleOpusEncoder(
|
|
audioTrack[i], GetAudioBitrate(), name,
|
|
i);
|
|
} else {
|
|
snprintf(name, sizeof name,
|
|
"simple_aac_recording%d", i);
|
|
success = CreateSimpleAACEncoder(
|
|
audioTrack[i], GetAudioBitrate(), name,
|
|
i);
|
|
}
|
|
if (!success)
|
|
throw "Failed to create multi-track audio recording encoder "
|
|
"(simple output)";
|
|
}
|
|
}
|
|
}
|
|
|
|
#define SIMPLE_ARCHIVE_NAME "simple_archive_audio"
|
|
|
|
SimpleOutput::SimpleOutput(OBSBasic *main_) : BasicOutputHandler(main_)
|
|
{
|
|
const char *encoder = config_get_string(main->Config(), "SimpleOutput",
|
|
"StreamEncoder");
|
|
const char *audio_encoder = config_get_string(
|
|
main->Config(), "SimpleOutput", "StreamAudioEncoder");
|
|
|
|
LoadStreamingPreset_Lossy(get_simple_output_encoder(encoder));
|
|
|
|
bool success = false;
|
|
|
|
if (strcmp(audio_encoder, "opus") == 0)
|
|
success = CreateSimpleOpusEncoder(
|
|
audioStreaming, GetAudioBitrate(), "simple_opus", 0);
|
|
else
|
|
success = CreateSimpleAACEncoder(
|
|
audioStreaming, GetAudioBitrate(), "simple_aac", 0);
|
|
|
|
if (!success)
|
|
throw "Failed to create audio streaming encoder (simple output)";
|
|
|
|
if (strcmp(audio_encoder, "opus") == 0)
|
|
success = CreateSimpleOpusEncoder(audioArchive,
|
|
GetAudioBitrate(),
|
|
SIMPLE_ARCHIVE_NAME, 1);
|
|
else
|
|
success = CreateSimpleAACEncoder(audioArchive,
|
|
GetAudioBitrate(),
|
|
SIMPLE_ARCHIVE_NAME, 1);
|
|
|
|
if (!success)
|
|
throw "Failed to create audio archive encoder (simple output)";
|
|
|
|
LoadRecordingPreset();
|
|
|
|
if (!ffmpegOutput) {
|
|
bool useReplayBuffer = config_get_bool(main->Config(),
|
|
"SimpleOutput", "RecRB");
|
|
if (useReplayBuffer) {
|
|
OBSDataAutoRelease hotkey;
|
|
const char *str = config_get_string(
|
|
main->Config(), "Hotkeys", "ReplayBuffer");
|
|
if (str)
|
|
hotkey = obs_data_create_from_json(str);
|
|
else
|
|
hotkey = nullptr;
|
|
|
|
replayBuffer = obs_output_create("replay_buffer",
|
|
Str("ReplayBuffer"),
|
|
nullptr, hotkey);
|
|
|
|
if (!replayBuffer)
|
|
throw "Failed to create replay buffer output "
|
|
"(simple output)";
|
|
|
|
signal_handler_t *signal =
|
|
obs_output_get_signal_handler(replayBuffer);
|
|
|
|
startReplayBuffer.Connect(signal, "start",
|
|
OBSStartReplayBuffer, this);
|
|
stopReplayBuffer.Connect(signal, "stop",
|
|
OBSStopReplayBuffer, this);
|
|
replayBufferStopping.Connect(signal, "stopping",
|
|
OBSReplayBufferStopping,
|
|
this);
|
|
replayBufferSaved.Connect(signal, "saved",
|
|
OBSReplayBufferSaved, this);
|
|
}
|
|
|
|
fileOutput = obs_output_create(
|
|
"ffmpeg_muxer", "simple_file_output", nullptr, nullptr);
|
|
if (!fileOutput)
|
|
throw "Failed to create recording output "
|
|
"(simple output)";
|
|
}
|
|
|
|
startRecording.Connect(obs_output_get_signal_handler(fileOutput),
|
|
"start", OBSStartRecording, this);
|
|
stopRecording.Connect(obs_output_get_signal_handler(fileOutput), "stop",
|
|
OBSStopRecording, this);
|
|
recordStopping.Connect(obs_output_get_signal_handler(fileOutput),
|
|
"stopping", OBSRecordStopping, this);
|
|
}
|
|
|
|
int SimpleOutput::GetAudioBitrate() const
|
|
{
|
|
const char *audio_encoder = config_get_string(
|
|
main->Config(), "SimpleOutput", "StreamAudioEncoder");
|
|
int bitrate = (int)config_get_uint(main->Config(), "SimpleOutput",
|
|
"ABitrate");
|
|
|
|
if (strcmp(audio_encoder, "opus") == 0)
|
|
return FindClosestAvailableSimpleOpusBitrate(bitrate);
|
|
|
|
return FindClosestAvailableSimpleAACBitrate(bitrate);
|
|
}
|
|
|
|
void SimpleOutput::Update()
|
|
{
|
|
OBSDataAutoRelease videoSettings = obs_data_create();
|
|
OBSDataAutoRelease audioSettings = obs_data_create();
|
|
|
|
int videoBitrate =
|
|
config_get_uint(main->Config(), "SimpleOutput", "VBitrate");
|
|
int audioBitrate = GetAudioBitrate();
|
|
bool advanced =
|
|
config_get_bool(main->Config(), "SimpleOutput", "UseAdvanced");
|
|
bool enforceBitrate = !config_get_bool(main->Config(), "Stream1",
|
|
"IgnoreRecommended");
|
|
const char *custom = config_get_string(main->Config(), "SimpleOutput",
|
|
"x264Settings");
|
|
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";
|
|
|
|
} else if (strcmp(encoder, SIMPLE_ENCODER_QSV_AV1) == 0) {
|
|
presetType = "QSVPreset";
|
|
|
|
} else if (strcmp(encoder, SIMPLE_ENCODER_AMD) == 0) {
|
|
presetType = "AMDPreset";
|
|
|
|
#ifdef ENABLE_HEVC
|
|
} else if (strcmp(encoder, SIMPLE_ENCODER_AMD_HEVC) == 0) {
|
|
presetType = "AMDPreset";
|
|
#endif
|
|
|
|
} else if (strcmp(encoder, SIMPLE_ENCODER_NVENC) == 0) {
|
|
presetType = "NVENCPreset2";
|
|
|
|
#ifdef ENABLE_HEVC
|
|
} else if (strcmp(encoder, SIMPLE_ENCODER_NVENC_HEVC) == 0) {
|
|
presetType = "NVENCPreset2";
|
|
#endif
|
|
|
|
} else if (strcmp(encoder, SIMPLE_ENCODER_AMD_AV1) == 0) {
|
|
presetType = "AMDAV1Preset";
|
|
|
|
} else if (strcmp(encoder, SIMPLE_ENCODER_NVENC_AV1) == 0) {
|
|
presetType = "NVENCPreset2";
|
|
|
|
} else {
|
|
presetType = "Preset";
|
|
}
|
|
|
|
preset = config_get_string(main->Config(), "SimpleOutput", presetType);
|
|
obs_data_set_string(videoSettings,
|
|
(strcmp(presetType, "NVENCPreset2") == 0)
|
|
? "preset2"
|
|
: "preset",
|
|
preset);
|
|
|
|
obs_data_set_string(videoSettings, "rate_control", "CBR");
|
|
obs_data_set_int(videoSettings, "bitrate", videoBitrate);
|
|
|
|
if (advanced)
|
|
obs_data_set_string(videoSettings, "x264opts", custom);
|
|
|
|
obs_data_set_string(audioSettings, "rate_control", "CBR");
|
|
obs_data_set_int(audioSettings, "bitrate", audioBitrate);
|
|
|
|
obs_service_apply_encoder_settings(main->GetService(), videoSettings,
|
|
audioSettings);
|
|
|
|
if (!enforceBitrate) {
|
|
obs_data_set_int(videoSettings, "bitrate", videoBitrate);
|
|
obs_data_set_int(audioSettings, "bitrate", audioBitrate);
|
|
}
|
|
|
|
video_t *video = obs_get_video();
|
|
enum video_format format = video_output_get_format(video);
|
|
|
|
switch (format) {
|
|
case VIDEO_FORMAT_I420:
|
|
case VIDEO_FORMAT_NV12:
|
|
case VIDEO_FORMAT_I010:
|
|
case VIDEO_FORMAT_P010:
|
|
break;
|
|
default:
|
|
obs_encoder_set_preferred_video_format(videoStreaming,
|
|
VIDEO_FORMAT_NV12);
|
|
}
|
|
|
|
obs_encoder_update(videoStreaming, videoSettings);
|
|
obs_encoder_update(audioStreaming, audioSettings);
|
|
obs_encoder_update(audioArchive, audioSettings);
|
|
}
|
|
|
|
void SimpleOutput::UpdateRecordingAudioSettings()
|
|
{
|
|
OBSDataAutoRelease settings = obs_data_create();
|
|
obs_data_set_int(settings, "bitrate", 192);
|
|
obs_data_set_string(settings, "rate_control", "CBR");
|
|
|
|
int tracks =
|
|
config_get_int(main->Config(), "SimpleOutput", "RecTracks");
|
|
const char *recFormat =
|
|
config_get_string(main->Config(), "SimpleOutput", "RecFormat2");
|
|
const char *quality =
|
|
config_get_string(main->Config(), "SimpleOutput", "RecQuality");
|
|
bool flv = strcmp(recFormat, "flv") == 0;
|
|
|
|
if (flv || strcmp(quality, "Stream") == 0) {
|
|
obs_encoder_update(audioRecording, settings);
|
|
} else {
|
|
for (int i = 0; i < MAX_AUDIO_MIXES; i++) {
|
|
if ((tracks & (1 << i)) != 0) {
|
|
obs_encoder_update(audioTrack[i], 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)
|
|
{
|
|
OBSDataAutoRelease settings = obs_data_create();
|
|
obs_data_set_int(settings, "crf", crf);
|
|
obs_data_set_bool(settings, "use_bufsize", true);
|
|
obs_data_set_string(settings, "rate_control", "CRF");
|
|
obs_data_set_string(settings, "profile", "high");
|
|
obs_data_set_string(settings, "preset",
|
|
lowCPUx264 ? "ultrafast" : "veryfast");
|
|
|
|
obs_encoder_update(videoRecording, settings);
|
|
}
|
|
|
|
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);
|
|
if (strcmp(val, "ICQ") == 0) {
|
|
icq_found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
obs_properties_destroy(props);
|
|
return icq_found;
|
|
}
|
|
|
|
void SimpleOutput::UpdateRecordingSettings_qsv11(int crf, bool av1)
|
|
{
|
|
bool icq = icq_available(videoRecording);
|
|
|
|
OBSDataAutoRelease settings = obs_data_create();
|
|
obs_data_set_string(settings, "profile", "high");
|
|
|
|
if (icq && !av1) {
|
|
obs_data_set_string(settings, "rate_control", "ICQ");
|
|
obs_data_set_int(settings, "icq_quality", crf);
|
|
} else {
|
|
obs_data_set_string(settings, "rate_control", "CQP");
|
|
obs_data_set_int(settings, "cqp", crf);
|
|
}
|
|
|
|
obs_encoder_update(videoRecording, settings);
|
|
}
|
|
|
|
void SimpleOutput::UpdateRecordingSettings_nvenc(int cqp)
|
|
{
|
|
OBSDataAutoRelease settings = obs_data_create();
|
|
obs_data_set_string(settings, "rate_control", "CQP");
|
|
obs_data_set_string(settings, "profile", "high");
|
|
obs_data_set_int(settings, "cqp", cqp);
|
|
|
|
obs_encoder_update(videoRecording, settings);
|
|
}
|
|
|
|
void SimpleOutput::UpdateRecordingSettings_nvenc_hevc_av1(int cqp)
|
|
{
|
|
OBSDataAutoRelease settings = obs_data_create();
|
|
obs_data_set_string(settings, "rate_control", "CQP");
|
|
obs_data_set_string(settings, "profile", "main");
|
|
obs_data_set_int(settings, "cqp", cqp);
|
|
|
|
obs_encoder_update(videoRecording, settings);
|
|
}
|
|
|
|
void SimpleOutput::UpdateRecordingSettings_apple(int quality)
|
|
{
|
|
OBSDataAutoRelease settings = obs_data_create();
|
|
obs_data_set_string(settings, "rate_control", "CRF");
|
|
obs_data_set_string(settings, "profile", "high");
|
|
obs_data_set_int(settings, "quality", quality);
|
|
|
|
obs_encoder_update(videoRecording, settings);
|
|
}
|
|
|
|
#ifdef ENABLE_HEVC
|
|
void SimpleOutput::UpdateRecordingSettings_apple_hevc(int quality)
|
|
{
|
|
OBSDataAutoRelease settings = obs_data_create();
|
|
obs_data_set_string(settings, "rate_control", "CRF");
|
|
obs_data_set_string(settings, "profile", "main");
|
|
obs_data_set_int(settings, "quality", quality);
|
|
|
|
obs_encoder_update(videoRecording, settings);
|
|
}
|
|
#endif
|
|
|
|
void SimpleOutput::UpdateRecordingSettings_amd_cqp(int cqp)
|
|
{
|
|
OBSDataAutoRelease settings = obs_data_create();
|
|
obs_data_set_string(settings, "rate_control", "CQP");
|
|
obs_data_set_string(settings, "profile", "high");
|
|
obs_data_set_string(settings, "preset", "quality");
|
|
obs_data_set_int(settings, "cqp", cqp);
|
|
obs_encoder_update(videoRecording, settings);
|
|
}
|
|
|
|
void SimpleOutput::UpdateRecordingSettings()
|
|
{
|
|
bool ultra_hq = (videoQuality == "HQ");
|
|
int crf = CalcCRF(ultra_hq ? 16 : 23);
|
|
|
|
if (astrcmp_n(videoEncoder.c_str(), "x264", 4) == 0) {
|
|
UpdateRecordingSettings_x264_crf(crf);
|
|
|
|
} else if (videoEncoder == SIMPLE_ENCODER_QSV) {
|
|
UpdateRecordingSettings_qsv11(crf, false);
|
|
|
|
} else if (videoEncoder == SIMPLE_ENCODER_QSV_AV1) {
|
|
UpdateRecordingSettings_qsv11(crf, true);
|
|
|
|
} else if (videoEncoder == SIMPLE_ENCODER_AMD) {
|
|
UpdateRecordingSettings_amd_cqp(crf);
|
|
|
|
#ifdef ENABLE_HEVC
|
|
} else if (videoEncoder == SIMPLE_ENCODER_AMD_HEVC) {
|
|
UpdateRecordingSettings_amd_cqp(crf);
|
|
#endif
|
|
|
|
} else if (videoEncoder == SIMPLE_ENCODER_NVENC) {
|
|
UpdateRecordingSettings_nvenc(crf);
|
|
|
|
#ifdef ENABLE_HEVC
|
|
} else if (videoEncoder == SIMPLE_ENCODER_NVENC_HEVC) {
|
|
UpdateRecordingSettings_nvenc_hevc_av1(crf);
|
|
#endif
|
|
} else if (videoEncoder == SIMPLE_ENCODER_NVENC_AV1) {
|
|
UpdateRecordingSettings_nvenc_hevc_av1(crf);
|
|
|
|
} else if (videoEncoder == SIMPLE_ENCODER_APPLE_H264) {
|
|
/* These are magic numbers. 0 - 100, more is better. */
|
|
UpdateRecordingSettings_apple(ultra_hq ? 70 : 50);
|
|
#ifdef ENABLE_HEVC
|
|
} else if (videoEncoder == SIMPLE_ENCODER_APPLE_HEVC) {
|
|
UpdateRecordingSettings_apple_hevc(ultra_hq ? 70 : 50);
|
|
#endif
|
|
}
|
|
UpdateRecordingAudioSettings();
|
|
}
|
|
|
|
inline void SimpleOutput::SetupOutputs()
|
|
{
|
|
SimpleOutput::Update();
|
|
obs_encoder_set_video(videoStreaming, obs_get_video());
|
|
obs_encoder_set_audio(audioStreaming, obs_get_audio());
|
|
obs_encoder_set_audio(audioArchive, obs_get_audio());
|
|
int tracks =
|
|
config_get_int(main->Config(), "SimpleOutput", "RecTracks");
|
|
const char *recFormat =
|
|
config_get_string(main->Config(), "SimpleOutput", "RecFormat2");
|
|
bool flv = strcmp(recFormat, "flv") == 0;
|
|
|
|
if (usingRecordingPreset) {
|
|
if (ffmpegOutput) {
|
|
obs_output_set_media(fileOutput, obs_get_video(),
|
|
obs_get_audio());
|
|
} else {
|
|
obs_encoder_set_video(videoRecording, obs_get_video());
|
|
if (flv) {
|
|
obs_encoder_set_audio(audioRecording,
|
|
obs_get_audio());
|
|
} else {
|
|
for (int i = 0; i < MAX_AUDIO_MIXES; i++) {
|
|
if ((tracks & (1 << i)) != 0) {
|
|
obs_encoder_set_audio(
|
|
audioTrack[i],
|
|
obs_get_audio());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
obs_encoder_set_audio(audioRecording, obs_get_audio());
|
|
}
|
|
}
|
|
|
|
const char *FindAudioEncoderFromCodec(const char *type)
|
|
{
|
|
const char *alt_enc_id = nullptr;
|
|
size_t i = 0;
|
|
|
|
while (obs_enum_encoder_types(i++, &alt_enc_id)) {
|
|
const char *codec = obs_get_encoder_codec(alt_enc_id);
|
|
if (strcmp(type, codec) == 0) {
|
|
return alt_enc_id;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
bool SimpleOutput::SetupStreaming(obs_service_t *service)
|
|
{
|
|
if (!Active())
|
|
SetupOutputs();
|
|
|
|
Auth *auth = main->GetAuth();
|
|
if (auth)
|
|
auth->OnStreamConfig();
|
|
|
|
/* --------------------- */
|
|
|
|
const char *type = GetStreamOutputType(service);
|
|
if (!type)
|
|
return false;
|
|
|
|
/* XXX: this is messy and disgusting and should be refactored */
|
|
if (outputType != type) {
|
|
streamDelayStarting.Disconnect();
|
|
streamStopping.Disconnect();
|
|
startStreaming.Disconnect();
|
|
stopStreaming.Disconnect();
|
|
|
|
streamOutput = obs_output_create(type, "simple_stream", nullptr,
|
|
nullptr);
|
|
if (!streamOutput) {
|
|
blog(LOG_WARNING,
|
|
"Creation of stream output type '%s' "
|
|
"failed!",
|
|
type);
|
|
return false;
|
|
}
|
|
|
|
streamDelayStarting.Connect(
|
|
obs_output_get_signal_handler(streamOutput), "starting",
|
|
OBSStreamStarting, this);
|
|
streamStopping.Connect(
|
|
obs_output_get_signal_handler(streamOutput), "stopping",
|
|
OBSStreamStopping, this);
|
|
|
|
startStreaming.Connect(
|
|
obs_output_get_signal_handler(streamOutput), "start",
|
|
OBSStartStreaming, this);
|
|
stopStreaming.Connect(
|
|
obs_output_get_signal_handler(streamOutput), "stop",
|
|
OBSStopStreaming, this);
|
|
|
|
outputType = type;
|
|
}
|
|
|
|
obs_output_set_video_encoder(streamOutput, videoStreaming);
|
|
obs_output_set_audio_encoder(streamOutput, audioStreaming, 0);
|
|
obs_output_set_service(streamOutput, service);
|
|
return true;
|
|
}
|
|
|
|
static inline bool ServiceSupportsVodTrack(const char *service);
|
|
|
|
static void clear_archive_encoder(obs_output_t *output,
|
|
const char *expected_name)
|
|
{
|
|
obs_encoder_t *last = obs_output_get_audio_encoder(output, 1);
|
|
bool clear = false;
|
|
|
|
/* ensures that we don't remove twitch's soundtrack encoder */
|
|
if (last) {
|
|
const char *name = obs_encoder_get_name(last);
|
|
clear = name && strcmp(name, expected_name) == 0;
|
|
obs_encoder_release(last);
|
|
}
|
|
|
|
if (clear)
|
|
obs_output_set_audio_encoder(output, nullptr, 1);
|
|
}
|
|
|
|
void SimpleOutput::SetupVodTrack(obs_service_t *service)
|
|
{
|
|
bool advanced =
|
|
config_get_bool(main->Config(), "SimpleOutput", "UseAdvanced");
|
|
bool enable = config_get_bool(main->Config(), "SimpleOutput",
|
|
"VodTrackEnabled");
|
|
bool enableForCustomServer = config_get_bool(
|
|
GetGlobalConfig(), "General", "EnableCustomServerVodTrack");
|
|
|
|
OBSDataAutoRelease settings = obs_service_get_settings(service);
|
|
const char *name = obs_data_get_string(settings, "service");
|
|
|
|
const char *id = obs_service_get_id(service);
|
|
if (strcmp(id, "rtmp_custom") == 0)
|
|
enable = enableForCustomServer ? enable : false;
|
|
else
|
|
enable = advanced && enable && ServiceSupportsVodTrack(name);
|
|
|
|
if (enable)
|
|
obs_output_set_audio_encoder(streamOutput, audioArchive, 1);
|
|
else
|
|
clear_archive_encoder(streamOutput, SIMPLE_ARCHIVE_NAME);
|
|
}
|
|
|
|
bool SimpleOutput::StartStreaming(obs_service_t *service)
|
|
{
|
|
bool reconnect = config_get_bool(main->Config(), "Output", "Reconnect");
|
|
int retryDelay =
|
|
config_get_uint(main->Config(), "Output", "RetryDelay");
|
|
int maxRetries =
|
|
config_get_uint(main->Config(), "Output", "MaxRetries");
|
|
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");
|
|
const char *bindIP =
|
|
config_get_string(main->Config(), "Output", "BindIP");
|
|
#ifdef _WIN32
|
|
bool enableNewSocketLoop = config_get_bool(main->Config(), "Output",
|
|
"NewSocketLoopEnable");
|
|
bool enableLowLatencyMode =
|
|
config_get_bool(main->Config(), "Output", "LowLatencyEnable");
|
|
#endif
|
|
bool enableDynBitrate =
|
|
config_get_bool(main->Config(), "Output", "DynamicBitrate");
|
|
|
|
OBSDataAutoRelease settings = obs_data_create();
|
|
obs_data_set_string(settings, "bind_ip", bindIP);
|
|
#ifdef _WIN32
|
|
obs_data_set_bool(settings, "new_socket_loop_enabled",
|
|
enableNewSocketLoop);
|
|
obs_data_set_bool(settings, "low_latency_mode_enabled",
|
|
enableLowLatencyMode);
|
|
#endif
|
|
obs_data_set_bool(settings, "dyn_bitrate", enableDynBitrate);
|
|
obs_output_update(streamOutput, settings);
|
|
|
|
if (!reconnect)
|
|
maxRetries = 0;
|
|
|
|
obs_output_set_delay(streamOutput, useDelay ? delaySec : 0,
|
|
preserveDelay ? OBS_OUTPUT_DELAY_PRESERVE : 0);
|
|
|
|
obs_output_set_reconnect_settings(streamOutput, maxRetries, retryDelay);
|
|
|
|
SetupVodTrack(service);
|
|
|
|
if (obs_output_start(streamOutput)) {
|
|
return true;
|
|
}
|
|
|
|
const char *error = obs_output_get_last_error(streamOutput);
|
|
bool hasLastError = error && *error;
|
|
if (hasLastError)
|
|
lastError = error;
|
|
else
|
|
lastError = string();
|
|
|
|
const char *type = obs_output_get_id(streamOutput);
|
|
blog(LOG_WARNING, "Stream output type '%s' failed to start!%s%s", type,
|
|
hasLastError ? " Last Error: " : "", hasLastError ? error : "");
|
|
return false;
|
|
}
|
|
|
|
void SimpleOutput::UpdateRecording()
|
|
{
|
|
const char *recFormat =
|
|
config_get_string(main->Config(), "SimpleOutput", "RecFormat2");
|
|
bool flv = strcmp(recFormat, "flv") == 0;
|
|
int tracks =
|
|
config_get_int(main->Config(), "SimpleOutput", "RecTracks");
|
|
int idx = 0;
|
|
int idx2 = 0;
|
|
const char *quality =
|
|
config_get_string(main->Config(), "SimpleOutput", "RecQuality");
|
|
|
|
if (replayBufferActive || recordingActive)
|
|
return;
|
|
|
|
if (usingRecordingPreset) {
|
|
if (!ffmpegOutput)
|
|
UpdateRecordingSettings();
|
|
} else if (!obs_output_active(streamOutput)) {
|
|
Update();
|
|
}
|
|
|
|
if (!Active())
|
|
SetupOutputs();
|
|
|
|
if (!ffmpegOutput) {
|
|
obs_output_set_video_encoder(fileOutput, videoRecording);
|
|
if (flv || strcmp(quality, "Stream") == 0) {
|
|
obs_output_set_audio_encoder(fileOutput, audioRecording,
|
|
0);
|
|
} else {
|
|
for (int i = 0; i < MAX_AUDIO_MIXES; i++) {
|
|
if ((tracks & (1 << i)) != 0) {
|
|
obs_output_set_audio_encoder(
|
|
fileOutput, audioTrack[i],
|
|
idx++);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (replayBuffer) {
|
|
obs_output_set_video_encoder(replayBuffer, videoRecording);
|
|
if (flv || strcmp(quality, "Stream") == 0) {
|
|
obs_output_set_audio_encoder(replayBuffer,
|
|
audioRecording, 0);
|
|
} else {
|
|
for (int i = 0; i < MAX_AUDIO_MIXES; i++) {
|
|
if ((tracks & (1 << i)) != 0) {
|
|
obs_output_set_audio_encoder(
|
|
replayBuffer, audioTrack[i],
|
|
idx2++);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
recordingConfigured = true;
|
|
}
|
|
|
|
bool SimpleOutput::ConfigureRecording(bool updateReplayBuffer)
|
|
{
|
|
const char *path =
|
|
config_get_string(main->Config(), "SimpleOutput", "FilePath");
|
|
const char *format =
|
|
config_get_string(main->Config(), "SimpleOutput", "RecFormat2");
|
|
const char *mux = config_get_string(main->Config(), "SimpleOutput",
|
|
"MuxerCustom");
|
|
bool noSpace = config_get_bool(main->Config(), "SimpleOutput",
|
|
"FileNameWithoutSpace");
|
|
const char *filenameFormat = config_get_string(main->Config(), "Output",
|
|
"FilenameFormatting");
|
|
bool overwriteIfExists =
|
|
config_get_bool(main->Config(), "Output", "OverwriteIfExists");
|
|
const char *rbPrefix = config_get_string(main->Config(), "SimpleOutput",
|
|
"RecRBPrefix");
|
|
const char *rbSuffix = config_get_string(main->Config(), "SimpleOutput",
|
|
"RecRBSuffix");
|
|
int rbTime =
|
|
config_get_int(main->Config(), "SimpleOutput", "RecRBTime");
|
|
int rbSize =
|
|
config_get_int(main->Config(), "SimpleOutput", "RecRBSize");
|
|
int tracks =
|
|
config_get_int(main->Config(), "SimpleOutput", "RecTracks");
|
|
|
|
bool is_fragmented = strncmp(format, "fragmented", 10) == 0;
|
|
|
|
string f;
|
|
|
|
OBSDataAutoRelease settings = obs_data_create();
|
|
if (updateReplayBuffer) {
|
|
f = GetFormatString(filenameFormat, rbPrefix, rbSuffix);
|
|
string ext = GetFormatExt(format);
|
|
obs_data_set_string(settings, "directory", path);
|
|
obs_data_set_string(settings, "format", f.c_str());
|
|
obs_data_set_string(settings, "extension", ext.c_str());
|
|
obs_data_set_bool(settings, "allow_spaces", !noSpace);
|
|
obs_data_set_int(settings, "max_time_sec", rbTime);
|
|
obs_data_set_int(settings, "max_size_mb",
|
|
usingRecordingPreset ? rbSize : 0);
|
|
} else {
|
|
f = GetFormatString(filenameFormat, nullptr, nullptr);
|
|
string strPath = GetRecordingFilename(
|
|
path, ffmpegOutput ? "avi" : format, noSpace,
|
|
overwriteIfExists, f.c_str(), ffmpegOutput);
|
|
obs_data_set_string(settings, ffmpegOutput ? "url" : "path",
|
|
strPath.c_str());
|
|
if (ffmpegOutput)
|
|
obs_output_set_mixers(fileOutput, tracks);
|
|
}
|
|
|
|
// Use fragmented MOV/MP4 if user has not already specified custom movflags
|
|
if (is_fragmented && (!mux || strstr(mux, "movflags") == NULL)) {
|
|
string mux_frag =
|
|
"movflags=frag_keyframe+empty_moov+delay_moov";
|
|
if (mux) {
|
|
mux_frag += " ";
|
|
mux_frag += mux;
|
|
}
|
|
obs_data_set_string(settings, "muxer_settings",
|
|
mux_frag.c_str());
|
|
} else {
|
|
if (is_fragmented)
|
|
blog(LOG_WARNING,
|
|
"User enabled fragmented recording, "
|
|
"but custom muxer settings contained movflags.");
|
|
obs_data_set_string(settings, "muxer_settings", mux);
|
|
}
|
|
|
|
if (updateReplayBuffer)
|
|
obs_output_update(replayBuffer, settings);
|
|
else
|
|
obs_output_update(fileOutput, settings);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool SimpleOutput::StartRecording()
|
|
{
|
|
UpdateRecording();
|
|
if (!ConfigureRecording(false))
|
|
return false;
|
|
if (!obs_output_start(fileOutput)) {
|
|
QString error_reason;
|
|
const char *error = obs_output_get_last_error(fileOutput);
|
|
if (error)
|
|
error_reason = QT_UTF8(error);
|
|
else
|
|
error_reason = QTStr("Output.StartFailedGeneric");
|
|
QMessageBox::critical(main,
|
|
QTStr("Output.StartRecordingFailed"),
|
|
error_reason);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool SimpleOutput::StartReplayBuffer()
|
|
{
|
|
UpdateRecording();
|
|
if (!ConfigureRecording(true))
|
|
return false;
|
|
if (!obs_output_start(replayBuffer)) {
|
|
QMessageBox::critical(main, QTStr("Output.StartReplayFailed"),
|
|
QTStr("Output.StartFailedGeneric"));
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void SimpleOutput::StopStreaming(bool force)
|
|
{
|
|
if (force)
|
|
obs_output_force_stop(streamOutput);
|
|
else
|
|
obs_output_stop(streamOutput);
|
|
}
|
|
|
|
void SimpleOutput::StopRecording(bool force)
|
|
{
|
|
if (force)
|
|
obs_output_force_stop(fileOutput);
|
|
else
|
|
obs_output_stop(fileOutput);
|
|
}
|
|
|
|
void SimpleOutput::StopReplayBuffer(bool force)
|
|
{
|
|
if (force)
|
|
obs_output_force_stop(replayBuffer);
|
|
else
|
|
obs_output_stop(replayBuffer);
|
|
}
|
|
|
|
bool SimpleOutput::StreamingActive() const
|
|
{
|
|
return obs_output_active(streamOutput);
|
|
}
|
|
|
|
bool SimpleOutput::RecordingActive() const
|
|
{
|
|
return obs_output_active(fileOutput);
|
|
}
|
|
|
|
bool SimpleOutput::ReplayBufferActive() const
|
|
{
|
|
return obs_output_active(replayBuffer);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
struct AdvancedOutput : BasicOutputHandler {
|
|
OBSEncoder streamAudioEnc;
|
|
OBSEncoder streamArchiveEnc;
|
|
OBSEncoder recordTrack[MAX_AUDIO_MIXES];
|
|
OBSEncoder videoStreaming;
|
|
OBSEncoder videoRecording;
|
|
|
|
bool ffmpegOutput;
|
|
bool ffmpegRecording;
|
|
bool useStreamEncoder;
|
|
bool useStreamAudioEncoder;
|
|
bool usesBitrate = false;
|
|
|
|
AdvancedOutput(OBSBasic *main_);
|
|
|
|
inline void UpdateStreamSettings();
|
|
inline void UpdateRecordingSettings();
|
|
inline void UpdateAudioSettings();
|
|
virtual void Update() override;
|
|
|
|
inline void SetupVodTrack(obs_service_t *service);
|
|
|
|
inline void SetupStreaming();
|
|
inline void SetupRecording();
|
|
inline void SetupFFmpeg();
|
|
void SetupOutputs() override;
|
|
int GetAudioBitrate(size_t i, const char *id) const;
|
|
|
|
virtual bool SetupStreaming(obs_service_t *service) override;
|
|
virtual bool StartStreaming(obs_service_t *service) override;
|
|
virtual bool StartRecording() override;
|
|
virtual bool StartReplayBuffer() override;
|
|
virtual void StopStreaming(bool force) override;
|
|
virtual void StopRecording(bool force) override;
|
|
virtual void StopReplayBuffer(bool force) override;
|
|
virtual bool StreamingActive() const override;
|
|
virtual bool RecordingActive() const override;
|
|
virtual bool ReplayBufferActive() const override;
|
|
};
|
|
|
|
static OBSData GetDataFromJsonFile(const char *jsonFile)
|
|
{
|
|
char fullPath[512];
|
|
OBSDataAutoRelease data = nullptr;
|
|
|
|
int ret = GetProfilePath(fullPath, sizeof(fullPath), jsonFile);
|
|
if (ret > 0) {
|
|
BPtr<char> jsonData = os_quick_read_utf8_file(fullPath);
|
|
if (!!jsonData) {
|
|
data = obs_data_create_from_json(jsonData);
|
|
}
|
|
}
|
|
|
|
if (!data)
|
|
data = obs_data_create();
|
|
|
|
return data.Get();
|
|
}
|
|
|
|
static void ApplyEncoderDefaults(OBSData &settings,
|
|
const obs_encoder_t *encoder)
|
|
{
|
|
OBSData dataRet = obs_encoder_get_defaults(encoder);
|
|
obs_data_release(dataRet);
|
|
|
|
if (!!settings)
|
|
obs_data_apply(dataRet, settings);
|
|
settings = std::move(dataRet);
|
|
}
|
|
|
|
#define ADV_ARCHIVE_NAME "adv_archive_audio"
|
|
|
|
#ifdef __APPLE__
|
|
static void translate_macvth264_encoder(const char *&encoder)
|
|
{
|
|
if (strcmp(encoder, "vt_h264_hw") == 0) {
|
|
encoder = "com.apple.videotoolbox.videoencoder.h264.gva";
|
|
} else if (strcmp(encoder, "vt_h264_sw") == 0) {
|
|
encoder = "com.apple.videotoolbox.videoencoder.h264";
|
|
}
|
|
}
|
|
#endif
|
|
|
|
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 *streamAudioEncoder =
|
|
config_get_string(main->Config(), "AdvOut", "AudioEncoder");
|
|
const char *recordEncoder =
|
|
config_get_string(main->Config(), "AdvOut", "RecEncoder");
|
|
const char *recAudioEncoder =
|
|
config_get_string(main->Config(), "AdvOut", "RecAudioEncoder");
|
|
#ifdef __APPLE__
|
|
translate_macvth264_encoder(streamEncoder);
|
|
translate_macvth264_encoder(recordEncoder);
|
|
#endif
|
|
|
|
ffmpegOutput = astrcmpi(recType, "FFmpeg") == 0;
|
|
ffmpegRecording =
|
|
ffmpegOutput &&
|
|
config_get_bool(main->Config(), "AdvOut", "FFOutputToFile");
|
|
useStreamEncoder = astrcmpi(recordEncoder, "none") == 0;
|
|
useStreamAudioEncoder = astrcmpi(recAudioEncoder, "none") == 0;
|
|
|
|
OBSData streamEncSettings = GetDataFromJsonFile("streamEncoder.json");
|
|
OBSData recordEncSettings = GetDataFromJsonFile("recordEncoder.json");
|
|
|
|
if (ffmpegOutput) {
|
|
fileOutput = obs_output_create(
|
|
"ffmpeg_output", "adv_ffmpeg_output", nullptr, nullptr);
|
|
if (!fileOutput)
|
|
throw "Failed to create recording FFmpeg output "
|
|
"(advanced output)";
|
|
} else {
|
|
bool useReplayBuffer =
|
|
config_get_bool(main->Config(), "AdvOut", "RecRB");
|
|
if (useReplayBuffer) {
|
|
OBSDataAutoRelease hotkey;
|
|
const char *str = config_get_string(
|
|
main->Config(), "Hotkeys", "ReplayBuffer");
|
|
if (str)
|
|
hotkey = obs_data_create_from_json(str);
|
|
else
|
|
hotkey = nullptr;
|
|
|
|
replayBuffer = obs_output_create("replay_buffer",
|
|
Str("ReplayBuffer"),
|
|
nullptr, hotkey);
|
|
|
|
if (!replayBuffer)
|
|
throw "Failed to create replay buffer output "
|
|
"(simple output)";
|
|
|
|
signal_handler_t *signal =
|
|
obs_output_get_signal_handler(replayBuffer);
|
|
|
|
startReplayBuffer.Connect(signal, "start",
|
|
OBSStartReplayBuffer, this);
|
|
stopReplayBuffer.Connect(signal, "stop",
|
|
OBSStopReplayBuffer, this);
|
|
replayBufferStopping.Connect(signal, "stopping",
|
|
OBSReplayBufferStopping,
|
|
this);
|
|
replayBufferSaved.Connect(signal, "saved",
|
|
OBSReplayBufferSaved, this);
|
|
}
|
|
|
|
fileOutput = obs_output_create(
|
|
"ffmpeg_muxer", "adv_file_output", nullptr, nullptr);
|
|
if (!fileOutput)
|
|
throw "Failed to create recording output "
|
|
"(advanced output)";
|
|
|
|
if (!useStreamEncoder) {
|
|
videoRecording = obs_video_encoder_create(
|
|
recordEncoder, "advanced_video_recording",
|
|
recordEncSettings, nullptr);
|
|
if (!videoRecording)
|
|
throw "Failed to create recording video "
|
|
"encoder (advanced output)";
|
|
obs_encoder_release(videoRecording);
|
|
}
|
|
}
|
|
|
|
videoStreaming = obs_video_encoder_create(streamEncoder,
|
|
"advanced_video_stream",
|
|
streamEncSettings, nullptr);
|
|
if (!videoStreaming)
|
|
throw "Failed to create streaming video encoder "
|
|
"(advanced output)";
|
|
obs_encoder_release(videoStreaming);
|
|
|
|
const char *rate_control = obs_data_get_string(
|
|
useStreamEncoder ? streamEncSettings : recordEncSettings,
|
|
"rate_control");
|
|
if (!rate_control)
|
|
rate_control = "";
|
|
usesBitrate = astrcmpi(rate_control, "CBR") == 0 ||
|
|
astrcmpi(rate_control, "VBR") == 0 ||
|
|
astrcmpi(rate_control, "ABR") == 0;
|
|
|
|
for (int i = 0; i < MAX_AUDIO_MIXES; i++) {
|
|
char name[19];
|
|
snprintf(name, sizeof(name), "adv_record_audio_%d", i);
|
|
|
|
recordTrack[i] = obs_audio_encoder_create(
|
|
useStreamAudioEncoder ? streamAudioEncoder
|
|
: recAudioEncoder,
|
|
name, nullptr, i, nullptr);
|
|
|
|
if (!recordTrack[i]) {
|
|
throw "Failed to create audio encoder "
|
|
"(advanced output)";
|
|
}
|
|
|
|
obs_encoder_release(recordTrack[i]);
|
|
}
|
|
|
|
std::string id;
|
|
int streamTrack =
|
|
config_get_int(main->Config(), "AdvOut", "TrackIndex") - 1;
|
|
streamAudioEnc = obs_audio_encoder_create(streamAudioEncoder,
|
|
"adv_stream_audio", nullptr,
|
|
streamTrack, nullptr);
|
|
if (!streamAudioEnc)
|
|
throw "Failed to create streaming audio encoder "
|
|
"(advanced output)";
|
|
obs_encoder_release(streamAudioEnc);
|
|
|
|
id = "";
|
|
int vodTrack =
|
|
config_get_int(main->Config(), "AdvOut", "VodTrackIndex") - 1;
|
|
streamArchiveEnc = obs_audio_encoder_create(streamAudioEncoder,
|
|
ADV_ARCHIVE_NAME, nullptr,
|
|
vodTrack, nullptr);
|
|
if (!streamArchiveEnc)
|
|
throw "Failed to create archive audio encoder "
|
|
"(advanced output)";
|
|
obs_encoder_release(streamArchiveEnc);
|
|
|
|
startRecording.Connect(obs_output_get_signal_handler(fileOutput),
|
|
"start", OBSStartRecording, this);
|
|
stopRecording.Connect(obs_output_get_signal_handler(fileOutput), "stop",
|
|
OBSStopRecording, this);
|
|
recordStopping.Connect(obs_output_get_signal_handler(fileOutput),
|
|
"stopping", OBSRecordStopping, this);
|
|
recordFileChanged.Connect(obs_output_get_signal_handler(fileOutput),
|
|
"file_changed", OBSRecordFileChanged, this);
|
|
}
|
|
|
|
void AdvancedOutput::UpdateStreamSettings()
|
|
{
|
|
bool applyServiceSettings = config_get_bool(main->Config(), "AdvOut",
|
|
"ApplyServiceSettings");
|
|
bool enforceBitrate = !config_get_bool(main->Config(), "Stream1",
|
|
"IgnoreRecommended");
|
|
bool dynBitrate =
|
|
config_get_bool(main->Config(), "Output", "DynamicBitrate");
|
|
const char *streamEncoder =
|
|
config_get_string(main->Config(), "AdvOut", "Encoder");
|
|
|
|
OBSData settings = GetDataFromJsonFile("streamEncoder.json");
|
|
ApplyEncoderDefaults(settings, videoStreaming);
|
|
|
|
if (applyServiceSettings) {
|
|
int bitrate = (int)obs_data_get_int(settings, "bitrate");
|
|
int keyint_sec = (int)obs_data_get_int(settings, "keyint_sec");
|
|
obs_service_apply_encoder_settings(main->GetService(), settings,
|
|
nullptr);
|
|
if (!enforceBitrate)
|
|
obs_data_set_int(settings, "bitrate", bitrate);
|
|
|
|
int enforced_keyint_sec =
|
|
(int)obs_data_get_int(settings, "keyint_sec");
|
|
if (keyint_sec != 0 && keyint_sec < enforced_keyint_sec)
|
|
obs_data_set_int(settings, "keyint_sec", keyint_sec);
|
|
}
|
|
|
|
if (dynBitrate && astrcmpi(streamEncoder, "jim_nvenc") == 0)
|
|
obs_data_set_bool(settings, "lookahead", false);
|
|
|
|
video_t *video = obs_get_video();
|
|
enum video_format format = video_output_get_format(video);
|
|
|
|
switch (format) {
|
|
case VIDEO_FORMAT_I420:
|
|
case VIDEO_FORMAT_NV12:
|
|
case VIDEO_FORMAT_I010:
|
|
case VIDEO_FORMAT_P010:
|
|
break;
|
|
default:
|
|
obs_encoder_set_preferred_video_format(videoStreaming,
|
|
VIDEO_FORMAT_NV12);
|
|
}
|
|
|
|
obs_encoder_update(videoStreaming, settings);
|
|
}
|
|
|
|
inline void AdvancedOutput::UpdateRecordingSettings()
|
|
{
|
|
OBSData settings = GetDataFromJsonFile("recordEncoder.json");
|
|
obs_encoder_update(videoRecording, settings);
|
|
}
|
|
|
|
void AdvancedOutput::Update()
|
|
{
|
|
UpdateStreamSettings();
|
|
if (!useStreamEncoder && !ffmpegOutput)
|
|
UpdateRecordingSettings();
|
|
UpdateAudioSettings();
|
|
}
|
|
|
|
static inline bool ServiceSupportsVodTrack(const char *service)
|
|
{
|
|
static const char *vodTrackServices[] = {"Twitch"};
|
|
|
|
for (const char *vodTrackService : vodTrackServices) {
|
|
if (astrcmpi(vodTrackService, service) == 0)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
inline void AdvancedOutput::SetupStreaming()
|
|
{
|
|
bool rescale = config_get_bool(main->Config(), "AdvOut", "Rescale");
|
|
const char *rescaleRes =
|
|
config_get_string(main->Config(), "AdvOut", "RescaleRes");
|
|
unsigned int cx = 0;
|
|
unsigned int cy = 0;
|
|
|
|
if (rescale && rescaleRes && *rescaleRes) {
|
|
if (sscanf(rescaleRes, "%ux%u", &cx, &cy) != 2) {
|
|
cx = 0;
|
|
cy = 0;
|
|
}
|
|
}
|
|
|
|
obs_output_set_audio_encoder(streamOutput, streamAudioEnc, 0);
|
|
obs_encoder_set_scaled_size(videoStreaming, cx, cy);
|
|
|
|
const char *id = obs_service_get_id(main->GetService());
|
|
if (strcmp(id, "rtmp_custom") == 0) {
|
|
OBSDataAutoRelease settings = obs_data_create();
|
|
obs_service_apply_encoder_settings(main->GetService(), settings,
|
|
nullptr);
|
|
obs_encoder_update(videoStreaming, settings);
|
|
}
|
|
}
|
|
|
|
inline void AdvancedOutput::SetupRecording()
|
|
{
|
|
const char *path =
|
|
config_get_string(main->Config(), "AdvOut", "RecFilePath");
|
|
const char *mux =
|
|
config_get_string(main->Config(), "AdvOut", "RecMuxerCustom");
|
|
bool rescale = config_get_bool(main->Config(), "AdvOut", "RecRescale");
|
|
const char *rescaleRes =
|
|
config_get_string(main->Config(), "AdvOut", "RecRescaleRes");
|
|
int tracks;
|
|
|
|
const char *recFormat =
|
|
config_get_string(main->Config(), "AdvOut", "RecFormat2");
|
|
|
|
bool is_fragmented = strncmp(recFormat, "fragmented", 10) == 0;
|
|
bool flv = strcmp(recFormat, "flv") == 0;
|
|
|
|
if (flv)
|
|
tracks = config_get_int(main->Config(), "AdvOut", "FLVTrack");
|
|
else
|
|
tracks = config_get_int(main->Config(), "AdvOut", "RecTracks");
|
|
|
|
OBSDataAutoRelease settings = obs_data_create();
|
|
unsigned int cx = 0;
|
|
unsigned int cy = 0;
|
|
int idx = 0;
|
|
|
|
/* Hack to allow recordings without any audio tracks selected. It is no
|
|
* longer possible to select such a configuration in settings, but legacy
|
|
* configurations might still have this configured and we don't want to
|
|
* just break them. */
|
|
if (tracks == 0)
|
|
tracks = config_get_int(main->Config(), "AdvOut", "TrackIndex");
|
|
|
|
if (useStreamEncoder) {
|
|
obs_output_set_video_encoder(fileOutput, videoStreaming);
|
|
if (replayBuffer)
|
|
obs_output_set_video_encoder(replayBuffer,
|
|
videoStreaming);
|
|
} else {
|
|
if (rescale && rescaleRes && *rescaleRes) {
|
|
if (sscanf(rescaleRes, "%ux%u", &cx, &cy) != 2) {
|
|
cx = 0;
|
|
cy = 0;
|
|
}
|
|
}
|
|
|
|
obs_encoder_set_scaled_size(videoRecording, cx, cy);
|
|
obs_output_set_video_encoder(fileOutput, videoRecording);
|
|
if (replayBuffer)
|
|
obs_output_set_video_encoder(replayBuffer,
|
|
videoRecording);
|
|
}
|
|
|
|
if (!flv) {
|
|
for (int i = 0; i < MAX_AUDIO_MIXES; i++) {
|
|
if ((tracks & (1 << i)) != 0) {
|
|
obs_output_set_audio_encoder(
|
|
fileOutput, recordTrack[i], idx);
|
|
if (replayBuffer)
|
|
obs_output_set_audio_encoder(
|
|
replayBuffer, recordTrack[i],
|
|
idx);
|
|
idx++;
|
|
}
|
|
}
|
|
} else if (flv && tracks != 0) {
|
|
obs_output_set_audio_encoder(fileOutput,
|
|
recordTrack[tracks - 1], idx);
|
|
|
|
if (replayBuffer)
|
|
obs_output_set_audio_encoder(
|
|
replayBuffer, recordTrack[tracks - 1], idx);
|
|
}
|
|
|
|
// Use fragmented MOV/MP4 if user has not already specified custom movflags
|
|
if (is_fragmented && (!mux || strstr(mux, "movflags") == NULL)) {
|
|
string mux_frag =
|
|
"movflags=frag_keyframe+empty_moov+delay_moov";
|
|
if (mux) {
|
|
mux_frag += " ";
|
|
mux_frag += mux;
|
|
}
|
|
obs_data_set_string(settings, "muxer_settings",
|
|
mux_frag.c_str());
|
|
} else {
|
|
if (is_fragmented)
|
|
blog(LOG_WARNING,
|
|
"User enabled fragmented recording, "
|
|
"but custom muxer settings contained movflags.");
|
|
obs_data_set_string(settings, "muxer_settings", mux);
|
|
}
|
|
|
|
obs_data_set_string(settings, "path", path);
|
|
obs_output_update(fileOutput, settings);
|
|
if (replayBuffer)
|
|
obs_output_update(replayBuffer, settings);
|
|
}
|
|
|
|
inline void AdvancedOutput::SetupFFmpeg()
|
|
{
|
|
const char *url = config_get_string(main->Config(), "AdvOut", "FFURL");
|
|
int vBitrate = config_get_int(main->Config(), "AdvOut", "FFVBitrate");
|
|
int gopSize = config_get_int(main->Config(), "AdvOut", "FFVGOPSize");
|
|
bool rescale = config_get_bool(main->Config(), "AdvOut", "FFRescale");
|
|
const char *rescaleRes =
|
|
config_get_string(main->Config(), "AdvOut", "FFRescaleRes");
|
|
const char *formatName =
|
|
config_get_string(main->Config(), "AdvOut", "FFFormat");
|
|
const char *mimeType =
|
|
config_get_string(main->Config(), "AdvOut", "FFFormatMimeType");
|
|
const char *muxCustom =
|
|
config_get_string(main->Config(), "AdvOut", "FFMCustom");
|
|
const char *vEncoder =
|
|
config_get_string(main->Config(), "AdvOut", "FFVEncoder");
|
|
int vEncoderId =
|
|
config_get_int(main->Config(), "AdvOut", "FFVEncoderId");
|
|
const char *vEncCustom =
|
|
config_get_string(main->Config(), "AdvOut", "FFVCustom");
|
|
int aBitrate = config_get_int(main->Config(), "AdvOut", "FFABitrate");
|
|
int aMixes = config_get_int(main->Config(), "AdvOut", "FFAudioMixes");
|
|
const char *aEncoder =
|
|
config_get_string(main->Config(), "AdvOut", "FFAEncoder");
|
|
int aEncoderId =
|
|
config_get_int(main->Config(), "AdvOut", "FFAEncoderId");
|
|
const char *aEncCustom =
|
|
config_get_string(main->Config(), "AdvOut", "FFACustom");
|
|
OBSDataAutoRelease settings = obs_data_create();
|
|
|
|
obs_data_set_string(settings, "url", url);
|
|
obs_data_set_string(settings, "format_name", formatName);
|
|
obs_data_set_string(settings, "format_mime_type", mimeType);
|
|
obs_data_set_string(settings, "muxer_settings", muxCustom);
|
|
obs_data_set_int(settings, "gop_size", gopSize);
|
|
obs_data_set_int(settings, "video_bitrate", vBitrate);
|
|
obs_data_set_string(settings, "video_encoder", vEncoder);
|
|
obs_data_set_int(settings, "video_encoder_id", vEncoderId);
|
|
obs_data_set_string(settings, "video_settings", vEncCustom);
|
|
obs_data_set_int(settings, "audio_bitrate", aBitrate);
|
|
obs_data_set_string(settings, "audio_encoder", aEncoder);
|
|
obs_data_set_int(settings, "audio_encoder_id", aEncoderId);
|
|
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_mixers(fileOutput, aMixes);
|
|
obs_output_set_media(fileOutput, obs_get_video(), obs_get_audio());
|
|
obs_output_update(fileOutput, settings);
|
|
}
|
|
|
|
static inline void SetEncoderName(obs_encoder_t *encoder, const char *name,
|
|
const char *defaultName)
|
|
{
|
|
obs_encoder_set_name(encoder, (name && *name) ? name : defaultName);
|
|
}
|
|
|
|
inline void AdvancedOutput::UpdateAudioSettings()
|
|
{
|
|
bool applyServiceSettings = config_get_bool(main->Config(), "AdvOut",
|
|
"ApplyServiceSettings");
|
|
bool enforceBitrate = !config_get_bool(main->Config(), "Stream1",
|
|
"IgnoreRecommended");
|
|
int streamTrackIndex =
|
|
config_get_int(main->Config(), "AdvOut", "TrackIndex");
|
|
int vodTrackIndex =
|
|
config_get_int(main->Config(), "AdvOut", "VodTrackIndex");
|
|
const char *audioEncoder =
|
|
config_get_string(main->Config(), "AdvOut", "AudioEncoder");
|
|
const char *recAudioEncoder =
|
|
config_get_string(main->Config(), "AdvOut", "RecAudioEncoder");
|
|
OBSDataAutoRelease settings[MAX_AUDIO_MIXES];
|
|
|
|
for (size_t i = 0; i < MAX_AUDIO_MIXES; i++) {
|
|
string cfg_name = "Track";
|
|
cfg_name += to_string((int)i + 1);
|
|
cfg_name += "Name";
|
|
const char *name = config_get_string(main->Config(), "AdvOut",
|
|
cfg_name.c_str());
|
|
|
|
string def_name = "Track";
|
|
def_name += to_string((int)i + 1);
|
|
SetEncoderName(recordTrack[i], name, def_name.c_str());
|
|
}
|
|
|
|
for (size_t i = 0; i < MAX_AUDIO_MIXES; i++) {
|
|
int track = (int)(i + 1);
|
|
settings[i] = obs_data_create();
|
|
obs_data_set_int(settings[i], "bitrate",
|
|
GetAudioBitrate(i, recAudioEncoder));
|
|
|
|
obs_encoder_update(recordTrack[i], settings[i]);
|
|
|
|
obs_data_set_int(settings[i], "bitrate",
|
|
GetAudioBitrate(i, audioEncoder));
|
|
|
|
if (track == streamTrackIndex || track == vodTrackIndex) {
|
|
if (applyServiceSettings) {
|
|
int bitrate = (int)obs_data_get_int(settings[i],
|
|
"bitrate");
|
|
obs_service_apply_encoder_settings(
|
|
main->GetService(), nullptr,
|
|
settings[i]);
|
|
|
|
if (!enforceBitrate)
|
|
obs_data_set_int(settings[i], "bitrate",
|
|
bitrate);
|
|
}
|
|
}
|
|
|
|
if (track == streamTrackIndex)
|
|
obs_encoder_update(streamAudioEnc, settings[i]);
|
|
if (track == vodTrackIndex)
|
|
obs_encoder_update(streamArchiveEnc, settings[i]);
|
|
}
|
|
}
|
|
|
|
void AdvancedOutput::SetupOutputs()
|
|
{
|
|
obs_encoder_set_video(videoStreaming, obs_get_video());
|
|
if (videoRecording)
|
|
obs_encoder_set_video(videoRecording, obs_get_video());
|
|
for (size_t i = 0; i < MAX_AUDIO_MIXES; i++)
|
|
obs_encoder_set_audio(recordTrack[i], obs_get_audio());
|
|
obs_encoder_set_audio(streamAudioEnc, obs_get_audio());
|
|
obs_encoder_set_audio(streamArchiveEnc, obs_get_audio());
|
|
|
|
SetupStreaming();
|
|
|
|
if (ffmpegOutput)
|
|
SetupFFmpeg();
|
|
else
|
|
SetupRecording();
|
|
}
|
|
|
|
int AdvancedOutput::GetAudioBitrate(size_t i, const char *id) const
|
|
{
|
|
static const char *names[] = {
|
|
"Track1Bitrate", "Track2Bitrate", "Track3Bitrate",
|
|
"Track4Bitrate", "Track5Bitrate", "Track6Bitrate",
|
|
};
|
|
int bitrate = (int)config_get_uint(main->Config(), "AdvOut", names[i]);
|
|
return FindClosestAvailableAudioBitrate(id, bitrate);
|
|
}
|
|
|
|
inline void AdvancedOutput::SetupVodTrack(obs_service_t *service)
|
|
{
|
|
int streamTrack =
|
|
config_get_int(main->Config(), "AdvOut", "TrackIndex");
|
|
bool vodTrackEnabled =
|
|
config_get_bool(main->Config(), "AdvOut", "VodTrackEnabled");
|
|
int vodTrackIndex =
|
|
config_get_int(main->Config(), "AdvOut", "VodTrackIndex");
|
|
bool enableForCustomServer = config_get_bool(
|
|
GetGlobalConfig(), "General", "EnableCustomServerVodTrack");
|
|
|
|
const char *id = obs_service_get_id(service);
|
|
if (strcmp(id, "rtmp_custom") == 0) {
|
|
vodTrackEnabled = enableForCustomServer ? vodTrackEnabled
|
|
: false;
|
|
} else {
|
|
OBSDataAutoRelease settings = obs_service_get_settings(service);
|
|
const char *service = obs_data_get_string(settings, "service");
|
|
if (!ServiceSupportsVodTrack(service))
|
|
vodTrackEnabled = false;
|
|
}
|
|
|
|
if (vodTrackEnabled && streamTrack != vodTrackIndex)
|
|
obs_output_set_audio_encoder(streamOutput, streamArchiveEnc, 1);
|
|
else
|
|
clear_archive_encoder(streamOutput, ADV_ARCHIVE_NAME);
|
|
}
|
|
|
|
bool AdvancedOutput::SetupStreaming(obs_service_t *service)
|
|
{
|
|
if (!useStreamEncoder ||
|
|
(!ffmpegOutput && !obs_output_active(fileOutput))) {
|
|
UpdateStreamSettings();
|
|
}
|
|
|
|
UpdateAudioSettings();
|
|
|
|
if (!Active())
|
|
SetupOutputs();
|
|
|
|
Auth *auth = main->GetAuth();
|
|
if (auth)
|
|
auth->OnStreamConfig();
|
|
|
|
/* --------------------- */
|
|
|
|
const char *type = GetStreamOutputType(service);
|
|
if (!type)
|
|
return false;
|
|
|
|
/* XXX: this is messy and disgusting and should be refactored */
|
|
if (outputType != type) {
|
|
streamDelayStarting.Disconnect();
|
|
streamStopping.Disconnect();
|
|
startStreaming.Disconnect();
|
|
stopStreaming.Disconnect();
|
|
|
|
streamOutput =
|
|
obs_output_create(type, "adv_stream", nullptr, nullptr);
|
|
if (!streamOutput) {
|
|
blog(LOG_WARNING,
|
|
"Creation of stream output type '%s' "
|
|
"failed!",
|
|
type);
|
|
return false;
|
|
}
|
|
|
|
streamDelayStarting.Connect(
|
|
obs_output_get_signal_handler(streamOutput), "starting",
|
|
OBSStreamStarting, this);
|
|
streamStopping.Connect(
|
|
obs_output_get_signal_handler(streamOutput), "stopping",
|
|
OBSStreamStopping, this);
|
|
|
|
startStreaming.Connect(
|
|
obs_output_get_signal_handler(streamOutput), "start",
|
|
OBSStartStreaming, this);
|
|
stopStreaming.Connect(
|
|
obs_output_get_signal_handler(streamOutput), "stop",
|
|
OBSStopStreaming, this);
|
|
|
|
outputType = type;
|
|
}
|
|
|
|
obs_output_set_video_encoder(streamOutput, videoStreaming);
|
|
obs_output_set_audio_encoder(streamOutput, streamAudioEnc, 0);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool AdvancedOutput::StartStreaming(obs_service_t *service)
|
|
{
|
|
obs_output_set_service(streamOutput, service);
|
|
|
|
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");
|
|
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");
|
|
const char *bindIP =
|
|
config_get_string(main->Config(), "Output", "BindIP");
|
|
#ifdef _WIN32
|
|
bool enableNewSocketLoop = config_get_bool(main->Config(), "Output",
|
|
"NewSocketLoopEnable");
|
|
bool enableLowLatencyMode =
|
|
config_get_bool(main->Config(), "Output", "LowLatencyEnable");
|
|
#endif
|
|
bool enableDynBitrate =
|
|
config_get_bool(main->Config(), "Output", "DynamicBitrate");
|
|
|
|
OBSDataAutoRelease settings = obs_data_create();
|
|
obs_data_set_string(settings, "bind_ip", bindIP);
|
|
#ifdef _WIN32
|
|
obs_data_set_bool(settings, "new_socket_loop_enabled",
|
|
enableNewSocketLoop);
|
|
obs_data_set_bool(settings, "low_latency_mode_enabled",
|
|
enableLowLatencyMode);
|
|
#endif
|
|
obs_data_set_bool(settings, "dyn_bitrate", enableDynBitrate);
|
|
obs_output_update(streamOutput, settings);
|
|
|
|
if (!reconnect)
|
|
maxRetries = 0;
|
|
|
|
obs_output_set_delay(streamOutput, useDelay ? delaySec : 0,
|
|
preserveDelay ? OBS_OUTPUT_DELAY_PRESERVE : 0);
|
|
|
|
obs_output_set_reconnect_settings(streamOutput, maxRetries, retryDelay);
|
|
|
|
SetupVodTrack(service);
|
|
|
|
if (obs_output_start(streamOutput)) {
|
|
return true;
|
|
}
|
|
|
|
const char *error = obs_output_get_last_error(streamOutput);
|
|
bool hasLastError = error && *error;
|
|
if (hasLastError)
|
|
lastError = error;
|
|
else
|
|
lastError = string();
|
|
|
|
const char *type = obs_output_get_id(streamOutput);
|
|
blog(LOG_WARNING, "Stream output type '%s' failed to start!%s%s", type,
|
|
hasLastError ? " Last Error: " : "", hasLastError ? error : "");
|
|
return false;
|
|
}
|
|
|
|
bool AdvancedOutput::StartRecording()
|
|
{
|
|
const char *path;
|
|
const char *recFormat;
|
|
const char *filenameFormat;
|
|
bool noSpace = false;
|
|
bool overwriteIfExists = false;
|
|
bool splitFile;
|
|
const char *splitFileType;
|
|
int splitFileTime;
|
|
int splitFileSize;
|
|
|
|
if (!useStreamEncoder) {
|
|
if (!ffmpegOutput) {
|
|
UpdateRecordingSettings();
|
|
}
|
|
} else if (!obs_output_active(streamOutput)) {
|
|
UpdateStreamSettings();
|
|
}
|
|
|
|
UpdateAudioSettings();
|
|
|
|
if (!Active())
|
|
SetupOutputs();
|
|
|
|
if (!ffmpegOutput || ffmpegRecording) {
|
|
path = config_get_string(main->Config(), "AdvOut",
|
|
ffmpegRecording ? "FFFilePath"
|
|
: "RecFilePath");
|
|
recFormat = config_get_string(main->Config(), "AdvOut",
|
|
ffmpegRecording ? "FFExtension"
|
|
: "RecFormat2");
|
|
filenameFormat = config_get_string(main->Config(), "Output",
|
|
"FilenameFormatting");
|
|
overwriteIfExists = config_get_bool(main->Config(), "Output",
|
|
"OverwriteIfExists");
|
|
noSpace = config_get_bool(main->Config(), "AdvOut",
|
|
ffmpegRecording
|
|
? "FFFileNameWithoutSpace"
|
|
: "RecFileNameWithoutSpace");
|
|
splitFile = config_get_bool(main->Config(), "AdvOut",
|
|
"RecSplitFile");
|
|
|
|
string strPath = GetRecordingFilename(path, recFormat, noSpace,
|
|
overwriteIfExists,
|
|
filenameFormat,
|
|
ffmpegRecording);
|
|
|
|
OBSDataAutoRelease settings = obs_data_create();
|
|
obs_data_set_string(settings, ffmpegRecording ? "url" : "path",
|
|
strPath.c_str());
|
|
|
|
if (splitFile) {
|
|
splitFileType = config_get_string(
|
|
main->Config(), "AdvOut", "RecSplitFileType");
|
|
splitFileTime =
|
|
(astrcmpi(splitFileType, "Time") == 0)
|
|
? config_get_int(main->Config(),
|
|
"AdvOut",
|
|
"RecSplitFileTime")
|
|
: 0;
|
|
splitFileSize =
|
|
(astrcmpi(splitFileType, "Size") == 0)
|
|
? config_get_int(main->Config(),
|
|
"AdvOut",
|
|
"RecSplitFileSize")
|
|
: 0;
|
|
string ext = GetFormatExt(recFormat);
|
|
obs_data_set_string(settings, "directory", path);
|
|
obs_data_set_string(settings, "format", filenameFormat);
|
|
obs_data_set_string(settings, "extension", ext.c_str());
|
|
obs_data_set_bool(settings, "allow_spaces", !noSpace);
|
|
obs_data_set_bool(settings, "allow_overwrite",
|
|
overwriteIfExists);
|
|
obs_data_set_bool(settings, "split_file", true);
|
|
obs_data_set_int(settings, "max_time_sec",
|
|
splitFileTime * 60);
|
|
obs_data_set_int(settings, "max_size_mb",
|
|
splitFileSize);
|
|
}
|
|
|
|
obs_output_update(fileOutput, settings);
|
|
}
|
|
|
|
if (!obs_output_start(fileOutput)) {
|
|
QString error_reason;
|
|
const char *error = obs_output_get_last_error(fileOutput);
|
|
if (error)
|
|
error_reason = QT_UTF8(error);
|
|
else
|
|
error_reason = QTStr("Output.StartFailedGeneric");
|
|
QMessageBox::critical(main,
|
|
QTStr("Output.StartRecordingFailed"),
|
|
error_reason);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool AdvancedOutput::StartReplayBuffer()
|
|
{
|
|
const char *path;
|
|
const char *recFormat;
|
|
const char *filenameFormat;
|
|
bool noSpace = false;
|
|
bool overwriteIfExists = false;
|
|
const char *rbPrefix;
|
|
const char *rbSuffix;
|
|
int rbTime;
|
|
int rbSize;
|
|
|
|
if (!useStreamEncoder) {
|
|
if (!ffmpegOutput)
|
|
UpdateRecordingSettings();
|
|
} else if (!obs_output_active(streamOutput)) {
|
|
UpdateStreamSettings();
|
|
}
|
|
|
|
UpdateAudioSettings();
|
|
|
|
if (!Active())
|
|
SetupOutputs();
|
|
|
|
if (!ffmpegOutput || ffmpegRecording) {
|
|
path = config_get_string(main->Config(), "AdvOut",
|
|
ffmpegRecording ? "FFFilePath"
|
|
: "RecFilePath");
|
|
recFormat = config_get_string(main->Config(), "AdvOut",
|
|
ffmpegRecording ? "FFExtension"
|
|
: "RecFormat2");
|
|
filenameFormat = config_get_string(main->Config(), "Output",
|
|
"FilenameFormatting");
|
|
overwriteIfExists = config_get_bool(main->Config(), "Output",
|
|
"OverwriteIfExists");
|
|
noSpace = config_get_bool(main->Config(), "AdvOut",
|
|
ffmpegRecording
|
|
? "FFFileNameWithoutSpace"
|
|
: "RecFileNameWithoutSpace");
|
|
rbPrefix = config_get_string(main->Config(), "SimpleOutput",
|
|
"RecRBPrefix");
|
|
rbSuffix = config_get_string(main->Config(), "SimpleOutput",
|
|
"RecRBSuffix");
|
|
rbTime = config_get_int(main->Config(), "AdvOut", "RecRBTime");
|
|
rbSize = config_get_int(main->Config(), "AdvOut", "RecRBSize");
|
|
|
|
string f = GetFormatString(filenameFormat, rbPrefix, rbSuffix);
|
|
string ext = GetFormatExt(recFormat);
|
|
|
|
OBSDataAutoRelease settings = obs_data_create();
|
|
|
|
obs_data_set_string(settings, "directory", path);
|
|
obs_data_set_string(settings, "format", f.c_str());
|
|
obs_data_set_string(settings, "extension", ext.c_str());
|
|
obs_data_set_bool(settings, "allow_spaces", !noSpace);
|
|
obs_data_set_int(settings, "max_time_sec", rbTime);
|
|
obs_data_set_int(settings, "max_size_mb",
|
|
usesBitrate ? 0 : rbSize);
|
|
|
|
obs_output_update(replayBuffer, settings);
|
|
}
|
|
|
|
if (!obs_output_start(replayBuffer)) {
|
|
QString error_reason;
|
|
const char *error = obs_output_get_last_error(replayBuffer);
|
|
if (error)
|
|
error_reason = QT_UTF8(error);
|
|
else
|
|
error_reason = QTStr("Output.StartFailedGeneric");
|
|
QMessageBox::critical(main, QTStr("Output.StartReplayFailed"),
|
|
error_reason);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void AdvancedOutput::StopStreaming(bool force)
|
|
{
|
|
if (force)
|
|
obs_output_force_stop(streamOutput);
|
|
else
|
|
obs_output_stop(streamOutput);
|
|
}
|
|
|
|
void AdvancedOutput::StopRecording(bool force)
|
|
{
|
|
if (force)
|
|
obs_output_force_stop(fileOutput);
|
|
else
|
|
obs_output_stop(fileOutput);
|
|
}
|
|
|
|
void AdvancedOutput::StopReplayBuffer(bool force)
|
|
{
|
|
if (force)
|
|
obs_output_force_stop(replayBuffer);
|
|
else
|
|
obs_output_stop(replayBuffer);
|
|
}
|
|
|
|
bool AdvancedOutput::StreamingActive() const
|
|
{
|
|
return obs_output_active(streamOutput);
|
|
}
|
|
|
|
bool AdvancedOutput::RecordingActive() const
|
|
{
|
|
return obs_output_active(fileOutput);
|
|
}
|
|
|
|
bool AdvancedOutput::ReplayBufferActive() const
|
|
{
|
|
return obs_output_active(replayBuffer);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
void BasicOutputHandler::SetupAutoRemux(const char *&container)
|
|
{
|
|
bool autoRemux = config_get_bool(main->Config(), "Video", "AutoRemux");
|
|
if (autoRemux && strcmp(container, "mp4") == 0)
|
|
container = "mkv";
|
|
}
|
|
|
|
std::string BasicOutputHandler::GetRecordingFilename(
|
|
const char *path, const char *container, bool noSpace, bool overwrite,
|
|
const char *format, bool ffmpeg)
|
|
{
|
|
if (!ffmpeg)
|
|
SetupAutoRemux(container);
|
|
|
|
string dst =
|
|
GetOutputFilename(path, container, noSpace, overwrite, format);
|
|
lastRecordingPath = dst;
|
|
return dst;
|
|
}
|
|
|
|
BasicOutputHandler *CreateSimpleOutputHandler(OBSBasic *main)
|
|
{
|
|
return new SimpleOutput(main);
|
|
}
|
|
|
|
BasicOutputHandler *CreateAdvancedOutputHandler(OBSBasic *main)
|
|
{
|
|
return new AdvancedOutput(main);
|
|
}
|