|
|
@@ -0,0 +1,1261 @@
|
|
|
+#include <chrono>
|
|
|
+
|
|
|
+#include <QFormLayout>
|
|
|
+
|
|
|
+#include <obs.hpp>
|
|
|
+#include <util/platform.h>
|
|
|
+#include <util/util_uint64.h>
|
|
|
+#include <graphics/vec4.h>
|
|
|
+#include <graphics/graphics.h>
|
|
|
+#include <graphics/math-extra.h>
|
|
|
+#include <qt-wrappers.hpp>
|
|
|
+
|
|
|
+#include "window-basic-auto-config.hpp"
|
|
|
+#include "window-basic-main.hpp"
|
|
|
+#include "obs-app.hpp"
|
|
|
+
|
|
|
+#include "ui_AutoConfigTestPage.h"
|
|
|
+
|
|
|
+#define wiz reinterpret_cast<AutoConfig *>(wizard())
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+/* ------------------------------------------------------------------------- */
|
|
|
+
|
|
|
+class TestMode {
|
|
|
+ obs_video_info ovi;
|
|
|
+ OBSSource source[6];
|
|
|
+
|
|
|
+ static void render_rand(void *, uint32_t cx, uint32_t cy)
|
|
|
+ {
|
|
|
+ gs_effect_t *solid = obs_get_base_effect(OBS_EFFECT_SOLID);
|
|
|
+ gs_eparam_t *randomvals[3] = {gs_effect_get_param_by_name(solid, "randomvals1"),
|
|
|
+ gs_effect_get_param_by_name(solid, "randomvals2"),
|
|
|
+ gs_effect_get_param_by_name(solid, "randomvals3")};
|
|
|
+
|
|
|
+ struct vec4 r;
|
|
|
+
|
|
|
+ for (int i = 0; i < 3; i++) {
|
|
|
+ vec4_set(&r, rand_float(true) * 100.0f, rand_float(true) * 100.0f,
|
|
|
+ rand_float(true) * 50000.0f + 10000.0f, 0.0f);
|
|
|
+ gs_effect_set_vec4(randomvals[i], &r);
|
|
|
+ }
|
|
|
+
|
|
|
+ while (gs_effect_loop(solid, "Random"))
|
|
|
+ gs_draw_sprite(nullptr, 0, cx, cy);
|
|
|
+ }
|
|
|
+
|
|
|
+public:
|
|
|
+ inline TestMode()
|
|
|
+ {
|
|
|
+ obs_get_video_info(&ovi);
|
|
|
+ obs_add_main_render_callback(render_rand, this);
|
|
|
+
|
|
|
+ for (uint32_t i = 0; i < 6; i++) {
|
|
|
+ source[i] = obs_get_output_source(i);
|
|
|
+ obs_source_release(source[i]);
|
|
|
+ obs_set_output_source(i, nullptr);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ inline ~TestMode()
|
|
|
+ {
|
|
|
+ for (uint32_t i = 0; i < 6; i++)
|
|
|
+ obs_set_output_source(i, source[i]);
|
|
|
+
|
|
|
+ obs_remove_main_render_callback(render_rand, this);
|
|
|
+ obs_reset_video(&ovi);
|
|
|
+ }
|
|
|
+
|
|
|
+ inline void SetVideo(int cx, int cy, int fps_num, int fps_den)
|
|
|
+ {
|
|
|
+ obs_video_info newOVI = ovi;
|
|
|
+
|
|
|
+ newOVI.output_width = (uint32_t)cx;
|
|
|
+ newOVI.output_height = (uint32_t)cy;
|
|
|
+ newOVI.fps_num = (uint32_t)fps_num;
|
|
|
+ newOVI.fps_den = (uint32_t)fps_den;
|
|
|
+
|
|
|
+ obs_reset_video(&newOVI);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/* ------------------------------------------------------------------------- */
|
|
|
+
|
|
|
+#define TEST_STR(x) "Basic.AutoConfig.TestPage." x
|
|
|
+#define SUBTITLE_TESTING TEST_STR("SubTitle.Testing")
|
|
|
+#define SUBTITLE_COMPLETE TEST_STR("SubTitle.Complete")
|
|
|
+#define TEST_BW TEST_STR("TestingBandwidth")
|
|
|
+#define TEST_BW_NO_OUTPUT TEST_STR("TestingBandwidth.NoOutput")
|
|
|
+#define TEST_BW_CONNECTING TEST_STR("TestingBandwidth.Connecting")
|
|
|
+#define TEST_BW_CONNECT_FAIL TEST_STR("TestingBandwidth.ConnectFailed")
|
|
|
+#define TEST_BW_SERVER TEST_STR("TestingBandwidth.Server")
|
|
|
+#define TEST_RES_VAL TEST_STR("TestingRes.Resolution")
|
|
|
+#define TEST_RES_FAIL TEST_STR("TestingRes.Fail")
|
|
|
+#define TEST_SE TEST_STR("TestingStreamEncoder")
|
|
|
+#define TEST_RE TEST_STR("TestingRecordingEncoder")
|
|
|
+#define TEST_RESULT_SE TEST_STR("Result.StreamingEncoder")
|
|
|
+#define TEST_RESULT_RE TEST_STR("Result.RecordingEncoder")
|
|
|
+
|
|
|
+void AutoConfigTestPage::StartBandwidthStage()
|
|
|
+{
|
|
|
+ ui->progressLabel->setText(QTStr(TEST_BW));
|
|
|
+ testThread = std::thread([this]() { TestBandwidthThread(); });
|
|
|
+}
|
|
|
+
|
|
|
+void AutoConfigTestPage::StartStreamEncoderStage()
|
|
|
+{
|
|
|
+ ui->progressLabel->setText(QTStr(TEST_SE));
|
|
|
+ testThread = std::thread([this]() { TestStreamEncoderThread(); });
|
|
|
+}
|
|
|
+
|
|
|
+void AutoConfigTestPage::StartRecordingEncoderStage()
|
|
|
+{
|
|
|
+ ui->progressLabel->setText(QTStr(TEST_RE));
|
|
|
+ testThread = std::thread([this]() { TestRecordingEncoderThread(); });
|
|
|
+}
|
|
|
+
|
|
|
+void AutoConfigTestPage::GetServers(std::vector<ServerInfo> &servers)
|
|
|
+{
|
|
|
+ OBSDataAutoRelease settings = obs_data_create();
|
|
|
+ obs_data_set_string(settings, "service", wiz->serviceName.c_str());
|
|
|
+
|
|
|
+ obs_properties_t *ppts = obs_get_service_properties("rtmp_common");
|
|
|
+ obs_property_t *p = obs_properties_get(ppts, "service");
|
|
|
+ obs_property_modified(p, settings);
|
|
|
+
|
|
|
+ p = obs_properties_get(ppts, "server");
|
|
|
+ size_t count = obs_property_list_item_count(p);
|
|
|
+ servers.reserve(count);
|
|
|
+
|
|
|
+ for (size_t i = 0; i < count; i++) {
|
|
|
+ const char *name = obs_property_list_item_name(p, i);
|
|
|
+ const char *server = obs_property_list_item_string(p, i);
|
|
|
+
|
|
|
+ if (wiz->CanTestServer(name)) {
|
|
|
+ ServerInfo info(name, server);
|
|
|
+ servers.push_back(info);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ obs_properties_destroy(ppts);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void string_depad_key(string &key)
|
|
|
+{
|
|
|
+ while (!key.empty()) {
|
|
|
+ char ch = key.back();
|
|
|
+ if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r')
|
|
|
+ key.pop_back();
|
|
|
+ else
|
|
|
+ break;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+const char *FindAudioEncoderFromCodec(const char *type);
|
|
|
+
|
|
|
+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;
|
|
|
+}
|
|
|
+
|
|
|
+void AutoConfigTestPage::TestBandwidthThread()
|
|
|
+{
|
|
|
+ bool connected = false;
|
|
|
+ bool stopped = false;
|
|
|
+
|
|
|
+ TestMode testMode;
|
|
|
+ testMode.SetVideo(128, 128, 60, 1);
|
|
|
+
|
|
|
+ QMetaObject::invokeMethod(this, "Progress", Q_ARG(int, 0));
|
|
|
+
|
|
|
+ /*
|
|
|
+ * create encoders
|
|
|
+ * create output
|
|
|
+ * test for 10 seconds
|
|
|
+ */
|
|
|
+
|
|
|
+ QMetaObject::invokeMethod(this, "UpdateMessage", Q_ARG(QString, QStringLiteral("")));
|
|
|
+
|
|
|
+ /* -----------------------------------*/
|
|
|
+ /* create obs objects */
|
|
|
+
|
|
|
+ const char *serverType = wiz->customServer ? "rtmp_custom" : "rtmp_common";
|
|
|
+
|
|
|
+ OBSEncoderAutoRelease vencoder = obs_video_encoder_create("obs_x264", "test_x264", nullptr, nullptr);
|
|
|
+ OBSEncoderAutoRelease aencoder = obs_audio_encoder_create("ffmpeg_aac", "test_aac", nullptr, 0, nullptr);
|
|
|
+ OBSServiceAutoRelease service = obs_service_create(serverType, "test_service", nullptr, nullptr);
|
|
|
+
|
|
|
+ /* -----------------------------------*/
|
|
|
+ /* configure settings */
|
|
|
+
|
|
|
+ // service: "service", "server", "key"
|
|
|
+ // vencoder: "bitrate", "rate_control",
|
|
|
+ // obs_service_apply_encoder_settings
|
|
|
+ // aencoder: "bitrate"
|
|
|
+ // output: "bind_ip" via main config -> "Output", "BindIP"
|
|
|
+ // obs_output_set_service
|
|
|
+
|
|
|
+ OBSDataAutoRelease service_settings = obs_data_create();
|
|
|
+ OBSDataAutoRelease vencoder_settings = obs_data_create();
|
|
|
+ OBSDataAutoRelease aencoder_settings = obs_data_create();
|
|
|
+ OBSDataAutoRelease output_settings = obs_data_create();
|
|
|
+
|
|
|
+ std::string key = wiz->key;
|
|
|
+ if (wiz->service == AutoConfig::Service::Twitch || wiz->service == AutoConfig::Service::AmazonIVS) {
|
|
|
+ string_depad_key(key);
|
|
|
+ key += "?bandwidthtest";
|
|
|
+ } else if (wiz->serviceName == "Restream.io" || wiz->serviceName == "Restream.io - RTMP") {
|
|
|
+ string_depad_key(key);
|
|
|
+ key += "?test=true";
|
|
|
+ }
|
|
|
+
|
|
|
+ obs_data_set_string(service_settings, "service", wiz->serviceName.c_str());
|
|
|
+ obs_data_set_string(service_settings, "key", key.c_str());
|
|
|
+
|
|
|
+ obs_data_set_int(vencoder_settings, "bitrate", wiz->startingBitrate);
|
|
|
+ obs_data_set_string(vencoder_settings, "rate_control", "CBR");
|
|
|
+ obs_data_set_string(vencoder_settings, "preset", "veryfast");
|
|
|
+ obs_data_set_int(vencoder_settings, "keyint_sec", 2);
|
|
|
+
|
|
|
+ obs_data_set_int(aencoder_settings, "bitrate", 32);
|
|
|
+
|
|
|
+ OBSBasic *main = reinterpret_cast<OBSBasic *>(App()->GetMainWindow());
|
|
|
+ const char *bind_ip = config_get_string(main->Config(), "Output", "BindIP");
|
|
|
+ obs_data_set_string(output_settings, "bind_ip", bind_ip);
|
|
|
+
|
|
|
+ const char *ip_family = config_get_string(main->Config(), "Output", "IPFamily");
|
|
|
+ obs_data_set_string(output_settings, "ip_family", ip_family);
|
|
|
+
|
|
|
+ /* -----------------------------------*/
|
|
|
+ /* determine which servers to test */
|
|
|
+
|
|
|
+ std::vector<ServerInfo> servers;
|
|
|
+ if (wiz->customServer)
|
|
|
+ servers.emplace_back(wiz->server.c_str(), wiz->server.c_str());
|
|
|
+ else
|
|
|
+ GetServers(servers);
|
|
|
+
|
|
|
+ /* just use the first server if it only has one alternate server,
|
|
|
+ * or if using Restream or Nimo TV due to their "auto" servers */
|
|
|
+ if (servers.size() < 3 || wiz->serviceName.substr(0, 11) == "Restream.io" || wiz->serviceName == "Nimo TV") {
|
|
|
+ servers.resize(1);
|
|
|
+
|
|
|
+ } else if ((wiz->service == AutoConfig::Service::Twitch && wiz->twitchAuto) ||
|
|
|
+ (wiz->service == AutoConfig::Service::AmazonIVS && wiz->amazonIVSAuto)) {
|
|
|
+ /* if using Twitch and "Auto" is available, test 3 closest
|
|
|
+ * server */
|
|
|
+ servers.erase(servers.begin() + 1);
|
|
|
+ servers.resize(3);
|
|
|
+ } else if (wiz->service == AutoConfig::Service::YouTube) {
|
|
|
+ /* Only test first set of primary + backup servers */
|
|
|
+ servers.resize(2);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!wiz->serviceConfigServers.empty()) {
|
|
|
+ if (wiz->service == AutoConfig::Service::Twitch && wiz->twitchAuto) {
|
|
|
+ // servers from Twitch service config replace the "auto" entry
|
|
|
+ servers.erase(servers.begin());
|
|
|
+ }
|
|
|
+
|
|
|
+ for (auto it = std::rbegin(wiz->serviceConfigServers); it != std::rend(wiz->serviceConfigServers);
|
|
|
+ it++) {
|
|
|
+ auto same_server =
|
|
|
+ std::find_if(std::begin(servers), std::end(servers),
|
|
|
+ [&](const ServerInfo &si) { return si.address == it->address; });
|
|
|
+ if (same_server != std::end(servers))
|
|
|
+ servers.erase(same_server);
|
|
|
+ servers.emplace(std::begin(servers), it->name.c_str(), it->address.c_str());
|
|
|
+ }
|
|
|
+
|
|
|
+ if (wiz->service == AutoConfig::Service::Twitch && wiz->twitchAuto) {
|
|
|
+ // see above, only test 3 servers
|
|
|
+ // rtmps urls are currently counted as separate servers
|
|
|
+ servers.resize(3);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* -----------------------------------*/
|
|
|
+ /* apply service settings */
|
|
|
+
|
|
|
+ obs_service_update(service, service_settings);
|
|
|
+ obs_service_apply_encoder_settings(service, vencoder_settings, aencoder_settings);
|
|
|
+
|
|
|
+ if (wiz->multitrackVideo.testSuccessful) {
|
|
|
+ obs_data_set_int(vencoder_settings, "bitrate", wiz->startingBitrate);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* -----------------------------------*/
|
|
|
+ /* create output */
|
|
|
+
|
|
|
+ /* Check if the service has a preferred output type */
|
|
|
+ const char *output_type = obs_service_get_preferred_output_type(service);
|
|
|
+ if (!output_type || (obs_get_output_flags(output_type) & OBS_OUTPUT_SERVICE) == 0) {
|
|
|
+ /* Otherwise, prefer first-party output types */
|
|
|
+ const char *protocol = obs_service_get_protocol(service);
|
|
|
+
|
|
|
+ if (can_use_output(protocol, "rtmp_output", "RTMP", "RTMPS")) {
|
|
|
+ output_type = "rtmp_output";
|
|
|
+ } else if (can_use_output(protocol, "ffmpeg_hls_muxer", "HLS")) {
|
|
|
+ output_type = "ffmpeg_hls_muxer";
|
|
|
+ } else if (can_use_output(protocol, "ffmpeg_mpegts_muxer", "SRT", "RIST")) {
|
|
|
+ output_type = "ffmpeg_mpegts_muxer";
|
|
|
+ }
|
|
|
+
|
|
|
+ /* If third-party protocol, use the first enumerated type */
|
|
|
+ if (!output_type)
|
|
|
+ obs_enum_output_types_with_protocol(protocol, &output_type, return_first_id);
|
|
|
+
|
|
|
+ /* If none, fail */
|
|
|
+ if (!output_type) {
|
|
|
+ QMetaObject::invokeMethod(this, "Failure", Q_ARG(QString, QTStr(TEST_BW_NO_OUTPUT)));
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ OBSOutputAutoRelease output = obs_output_create(output_type, "test_stream", nullptr, nullptr);
|
|
|
+ obs_output_update(output, output_settings);
|
|
|
+
|
|
|
+ const char *audio_codec = obs_output_get_supported_audio_codecs(output);
|
|
|
+
|
|
|
+ if (strcmp(audio_codec, "aac") != 0) {
|
|
|
+ const char *id = FindAudioEncoderFromCodec(audio_codec);
|
|
|
+ aencoder = obs_audio_encoder_create(id, "test_audio", nullptr, 0, nullptr);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* -----------------------------------*/
|
|
|
+ /* connect encoders/services/outputs */
|
|
|
+
|
|
|
+ obs_encoder_update(vencoder, vencoder_settings);
|
|
|
+ obs_encoder_update(aencoder, aencoder_settings);
|
|
|
+ obs_encoder_set_video(vencoder, obs_get_video());
|
|
|
+ obs_encoder_set_audio(aencoder, obs_get_audio());
|
|
|
+
|
|
|
+ obs_output_set_video_encoder(output, vencoder);
|
|
|
+ obs_output_set_audio_encoder(output, aencoder, 0);
|
|
|
+ obs_output_set_reconnect_settings(output, 0, 0);
|
|
|
+
|
|
|
+ obs_output_set_service(output, service);
|
|
|
+
|
|
|
+ /* -----------------------------------*/
|
|
|
+ /* connect signals */
|
|
|
+
|
|
|
+ auto on_started = [&]() {
|
|
|
+ unique_lock<mutex> lock(m);
|
|
|
+ connected = true;
|
|
|
+ stopped = false;
|
|
|
+ cv.notify_one();
|
|
|
+ };
|
|
|
+
|
|
|
+ auto on_stopped = [&]() {
|
|
|
+ unique_lock<mutex> lock(m);
|
|
|
+ connected = false;
|
|
|
+ stopped = true;
|
|
|
+ cv.notify_one();
|
|
|
+ };
|
|
|
+
|
|
|
+ using on_started_t = decltype(on_started);
|
|
|
+ using on_stopped_t = decltype(on_stopped);
|
|
|
+
|
|
|
+ auto pre_on_started = [](void *data, calldata_t *) {
|
|
|
+ on_started_t &on_started = *reinterpret_cast<on_started_t *>(data);
|
|
|
+ on_started();
|
|
|
+ };
|
|
|
+
|
|
|
+ auto pre_on_stopped = [](void *data, calldata_t *) {
|
|
|
+ on_stopped_t &on_stopped = *reinterpret_cast<on_stopped_t *>(data);
|
|
|
+ on_stopped();
|
|
|
+ };
|
|
|
+
|
|
|
+ signal_handler *sh = obs_output_get_signal_handler(output);
|
|
|
+ signal_handler_connect(sh, "start", pre_on_started, &on_started);
|
|
|
+ signal_handler_connect(sh, "stop", pre_on_stopped, &on_stopped);
|
|
|
+
|
|
|
+ /* -----------------------------------*/
|
|
|
+ /* test servers */
|
|
|
+
|
|
|
+ bool success = false;
|
|
|
+
|
|
|
+ for (size_t i = 0; i < servers.size(); i++) {
|
|
|
+ auto &server = servers[i];
|
|
|
+
|
|
|
+ connected = false;
|
|
|
+ stopped = false;
|
|
|
+
|
|
|
+ int per = int((i + 1) * 100 / servers.size());
|
|
|
+ QMetaObject::invokeMethod(this, "Progress", Q_ARG(int, per));
|
|
|
+ QMetaObject::invokeMethod(this, "UpdateMessage",
|
|
|
+ Q_ARG(QString, QTStr(TEST_BW_CONNECTING).arg(server.name.c_str())));
|
|
|
+
|
|
|
+ obs_data_set_string(service_settings, "server", server.address.c_str());
|
|
|
+ obs_service_update(service, service_settings);
|
|
|
+
|
|
|
+ if (!obs_output_start(output))
|
|
|
+ continue;
|
|
|
+
|
|
|
+ unique_lock<mutex> ul(m);
|
|
|
+ if (cancel) {
|
|
|
+ ul.unlock();
|
|
|
+ obs_output_force_stop(output);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (!stopped && !connected)
|
|
|
+ cv.wait(ul);
|
|
|
+ if (cancel) {
|
|
|
+ ul.unlock();
|
|
|
+ obs_output_force_stop(output);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (!connected)
|
|
|
+ continue;
|
|
|
+
|
|
|
+ QMetaObject::invokeMethod(this, "UpdateMessage",
|
|
|
+ Q_ARG(QString, QTStr(TEST_BW_SERVER).arg(server.name.c_str())));
|
|
|
+
|
|
|
+ /* ignore first 2.5 seconds due to possible buffering skewing
|
|
|
+ * the result */
|
|
|
+ cv.wait_for(ul, chrono::milliseconds(2500));
|
|
|
+ if (stopped)
|
|
|
+ continue;
|
|
|
+ if (cancel) {
|
|
|
+ ul.unlock();
|
|
|
+ obs_output_force_stop(output);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* continue test */
|
|
|
+ int start_bytes = (int)obs_output_get_total_bytes(output);
|
|
|
+ uint64_t t_start = os_gettime_ns();
|
|
|
+
|
|
|
+ cv.wait_for(ul, chrono::seconds(10));
|
|
|
+ if (stopped)
|
|
|
+ continue;
|
|
|
+ if (cancel) {
|
|
|
+ ul.unlock();
|
|
|
+ obs_output_force_stop(output);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ obs_output_stop(output);
|
|
|
+ cv.wait(ul);
|
|
|
+
|
|
|
+ uint64_t total_time = os_gettime_ns() - t_start;
|
|
|
+ if (total_time == 0)
|
|
|
+ total_time = 1;
|
|
|
+
|
|
|
+ int total_bytes = (int)obs_output_get_total_bytes(output) - start_bytes;
|
|
|
+ uint64_t bitrate = util_mul_div64(total_bytes, 8ULL * 1000000000ULL / 1000ULL, total_time);
|
|
|
+ if (obs_output_get_frames_dropped(output) || (int)bitrate < (wiz->startingBitrate * 75 / 100)) {
|
|
|
+ server.bitrate = (int)bitrate * 70 / 100;
|
|
|
+ } else {
|
|
|
+ server.bitrate = wiz->startingBitrate;
|
|
|
+ }
|
|
|
+
|
|
|
+ server.ms = obs_output_get_connect_time_ms(output);
|
|
|
+ success = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!success) {
|
|
|
+ QMetaObject::invokeMethod(this, "Failure", Q_ARG(QString, QTStr(TEST_BW_CONNECT_FAIL)));
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ int bestBitrate = 0;
|
|
|
+ int bestMS = 0x7FFFFFFF;
|
|
|
+ string bestServer;
|
|
|
+ string bestServerName;
|
|
|
+
|
|
|
+ for (auto &server : servers) {
|
|
|
+ bool close = abs(server.bitrate - bestBitrate) < 400;
|
|
|
+
|
|
|
+ if ((!close && server.bitrate > bestBitrate) || (close && server.ms < bestMS)) {
|
|
|
+ bestServer = server.address;
|
|
|
+ bestServerName = server.name;
|
|
|
+ bestBitrate = server.bitrate;
|
|
|
+ bestMS = server.ms;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ wiz->server = std::move(bestServer);
|
|
|
+ wiz->serverName = std::move(bestServerName);
|
|
|
+ wiz->idealBitrate = bestBitrate;
|
|
|
+
|
|
|
+ QMetaObject::invokeMethod(this, "NextStage");
|
|
|
+}
|
|
|
+
|
|
|
+/* this is used to estimate the lower bitrate limit for a given
|
|
|
+ * resolution/fps. yes, it is a totally arbitrary equation that gets
|
|
|
+ * the closest to the expected values */
|
|
|
+static long double EstimateBitrateVal(int cx, int cy, int fps_num, int fps_den)
|
|
|
+{
|
|
|
+ long fps = (long double)fps_num / (long double)fps_den;
|
|
|
+ long double areaVal = pow((long double)(cx * cy), 0.85l);
|
|
|
+ return areaVal * sqrt(pow(fps, 1.1l));
|
|
|
+}
|
|
|
+
|
|
|
+static long double EstimateMinBitrate(int cx, int cy, int fps_num, int fps_den)
|
|
|
+{
|
|
|
+ long double val = EstimateBitrateVal(1920, 1080, 60, 1) / 5800.0l;
|
|
|
+ return EstimateBitrateVal(cx, cy, fps_num, fps_den) / val;
|
|
|
+}
|
|
|
+
|
|
|
+static long double EstimateUpperBitrate(int cx, int cy, int fps_num, int fps_den)
|
|
|
+{
|
|
|
+ long double val = EstimateBitrateVal(1280, 720, 30, 1) / 3000.0l;
|
|
|
+ return EstimateBitrateVal(cx, cy, fps_num, fps_den) / val;
|
|
|
+}
|
|
|
+
|
|
|
+struct Result {
|
|
|
+ int cx;
|
|
|
+ int cy;
|
|
|
+ int fps_num;
|
|
|
+ int fps_den;
|
|
|
+
|
|
|
+ inline Result(int cx_, int cy_, int fps_num_, int fps_den_)
|
|
|
+ : cx(cx_),
|
|
|
+ cy(cy_),
|
|
|
+ fps_num(fps_num_),
|
|
|
+ fps_den(fps_den_)
|
|
|
+ {
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+static void CalcBaseRes(int &baseCX, int &baseCY)
|
|
|
+{
|
|
|
+ const int maxBaseArea = 1920 * 1200;
|
|
|
+ const int clipResArea = 1920 * 1080;
|
|
|
+
|
|
|
+ /* if base resolution unusually high, recalculate to a more reasonable
|
|
|
+ * value to start the downscaling at, based upon 1920x1080's area.
|
|
|
+ *
|
|
|
+ * for 16:9 resolutions this will always change the starting value to
|
|
|
+ * 1920x1080 */
|
|
|
+ if ((baseCX * baseCY) > maxBaseArea) {
|
|
|
+ long double xyAspect = (long double)baseCX / (long double)baseCY;
|
|
|
+ baseCY = (int)sqrt((long double)clipResArea / xyAspect);
|
|
|
+ baseCX = (int)((long double)baseCY * xyAspect);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+bool AutoConfigTestPage::TestSoftwareEncoding()
|
|
|
+{
|
|
|
+ TestMode testMode;
|
|
|
+ QMetaObject::invokeMethod(this, "UpdateMessage", Q_ARG(QString, QStringLiteral("")));
|
|
|
+
|
|
|
+ /* -----------------------------------*/
|
|
|
+ /* create obs objects */
|
|
|
+
|
|
|
+ OBSEncoderAutoRelease vencoder = obs_video_encoder_create("obs_x264", "test_x264", nullptr, nullptr);
|
|
|
+ OBSEncoderAutoRelease aencoder = obs_audio_encoder_create("ffmpeg_aac", "test_aac", nullptr, 0, nullptr);
|
|
|
+ OBSOutputAutoRelease output = obs_output_create("null_output", "null", nullptr, nullptr);
|
|
|
+
|
|
|
+ /* -----------------------------------*/
|
|
|
+ /* configure settings */
|
|
|
+
|
|
|
+ OBSDataAutoRelease aencoder_settings = obs_data_create();
|
|
|
+ OBSDataAutoRelease vencoder_settings = obs_data_create();
|
|
|
+ obs_data_set_int(aencoder_settings, "bitrate", 32);
|
|
|
+
|
|
|
+ if (wiz->type != AutoConfig::Type::Recording) {
|
|
|
+ obs_data_set_int(vencoder_settings, "keyint_sec", 2);
|
|
|
+ obs_data_set_int(vencoder_settings, "bitrate", wiz->idealBitrate);
|
|
|
+ obs_data_set_string(vencoder_settings, "rate_control", "CBR");
|
|
|
+ obs_data_set_string(vencoder_settings, "profile", "main");
|
|
|
+ obs_data_set_string(vencoder_settings, "preset", "veryfast");
|
|
|
+ } else {
|
|
|
+ obs_data_set_int(vencoder_settings, "crf", 20);
|
|
|
+ obs_data_set_string(vencoder_settings, "rate_control", "CRF");
|
|
|
+ obs_data_set_string(vencoder_settings, "profile", "high");
|
|
|
+ obs_data_set_string(vencoder_settings, "preset", "veryfast");
|
|
|
+ }
|
|
|
+
|
|
|
+ /* -----------------------------------*/
|
|
|
+ /* apply settings */
|
|
|
+
|
|
|
+ obs_encoder_update(vencoder, vencoder_settings);
|
|
|
+ obs_encoder_update(aencoder, aencoder_settings);
|
|
|
+
|
|
|
+ /* -----------------------------------*/
|
|
|
+ /* connect encoders/services/outputs */
|
|
|
+
|
|
|
+ obs_output_set_video_encoder(output, vencoder);
|
|
|
+ obs_output_set_audio_encoder(output, aencoder, 0);
|
|
|
+
|
|
|
+ /* -----------------------------------*/
|
|
|
+ /* connect signals */
|
|
|
+
|
|
|
+ auto on_stopped = [&]() {
|
|
|
+ unique_lock<mutex> lock(m);
|
|
|
+ cv.notify_one();
|
|
|
+ };
|
|
|
+
|
|
|
+ using on_stopped_t = decltype(on_stopped);
|
|
|
+
|
|
|
+ auto pre_on_stopped = [](void *data, calldata_t *) {
|
|
|
+ on_stopped_t &on_stopped = *reinterpret_cast<on_stopped_t *>(data);
|
|
|
+ on_stopped();
|
|
|
+ };
|
|
|
+
|
|
|
+ signal_handler *sh = obs_output_get_signal_handler(output);
|
|
|
+ signal_handler_connect(sh, "deactivate", pre_on_stopped, &on_stopped);
|
|
|
+
|
|
|
+ /* -----------------------------------*/
|
|
|
+ /* calculate starting resolution */
|
|
|
+
|
|
|
+ int baseCX = wiz->baseResolutionCX;
|
|
|
+ int baseCY = wiz->baseResolutionCY;
|
|
|
+ CalcBaseRes(baseCX, baseCY);
|
|
|
+
|
|
|
+ /* -----------------------------------*/
|
|
|
+ /* calculate starting test rates */
|
|
|
+
|
|
|
+ int pcores = os_get_physical_cores();
|
|
|
+ int lcores = os_get_logical_cores();
|
|
|
+ int maxDataRate;
|
|
|
+ if (lcores > 8 || pcores > 4) {
|
|
|
+ /* superb */
|
|
|
+ maxDataRate = 1920 * 1200 * 60 + 1000;
|
|
|
+
|
|
|
+ } else if (lcores > 4 && pcores == 4) {
|
|
|
+ /* great */
|
|
|
+ maxDataRate = 1920 * 1080 * 60 + 1000;
|
|
|
+
|
|
|
+ } else if (pcores == 4) {
|
|
|
+ /* okay */
|
|
|
+ maxDataRate = 1920 * 1080 * 30 + 1000;
|
|
|
+
|
|
|
+ } else {
|
|
|
+ /* toaster */
|
|
|
+ maxDataRate = 960 * 540 * 30 + 1000;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* -----------------------------------*/
|
|
|
+ /* perform tests */
|
|
|
+
|
|
|
+ vector<Result> results;
|
|
|
+ int i = 0;
|
|
|
+ int count = 1;
|
|
|
+
|
|
|
+ auto testRes = [&](int cy, int fps_num, int fps_den, bool force) {
|
|
|
+ int per = ++i * 100 / count;
|
|
|
+ QMetaObject::invokeMethod(this, "Progress", Q_ARG(int, per));
|
|
|
+
|
|
|
+ if (cy > baseCY)
|
|
|
+ return true;
|
|
|
+
|
|
|
+ /* no need for more than 3 tests max */
|
|
|
+ if (results.size() >= 3)
|
|
|
+ return true;
|
|
|
+
|
|
|
+ if (!fps_num || !fps_den) {
|
|
|
+ fps_num = wiz->specificFPSNum;
|
|
|
+ fps_den = wiz->specificFPSDen;
|
|
|
+ }
|
|
|
+
|
|
|
+ long double fps = ((long double)fps_num / (long double)fps_den);
|
|
|
+
|
|
|
+ int cx = int(((long double)baseCX / (long double)baseCY) * (long double)cy);
|
|
|
+
|
|
|
+ if (!force && wiz->type != AutoConfig::Type::Recording) {
|
|
|
+ int est = EstimateMinBitrate(cx, cy, fps_num, fps_den);
|
|
|
+ if (est > wiz->idealBitrate)
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ long double rate = (long double)cx * (long double)cy * fps;
|
|
|
+ if (!force && rate > maxDataRate)
|
|
|
+ return true;
|
|
|
+
|
|
|
+ testMode.SetVideo(cx, cy, fps_num, fps_den);
|
|
|
+
|
|
|
+ obs_encoder_set_video(vencoder, obs_get_video());
|
|
|
+ obs_encoder_set_audio(aencoder, obs_get_audio());
|
|
|
+ obs_encoder_update(vencoder, vencoder_settings);
|
|
|
+
|
|
|
+ obs_output_set_media(output, obs_get_video(), obs_get_audio());
|
|
|
+
|
|
|
+ QString cxStr = QString::number(cx);
|
|
|
+ QString cyStr = QString::number(cy);
|
|
|
+
|
|
|
+ QString fpsStr = (fps_den > 1) ? QString::number(fps, 'f', 2) : QString::number(fps, 'g', 2);
|
|
|
+
|
|
|
+ QMetaObject::invokeMethod(this, "UpdateMessage",
|
|
|
+ Q_ARG(QString, QTStr(TEST_RES_VAL).arg(cxStr, cyStr, fpsStr)));
|
|
|
+
|
|
|
+ unique_lock<mutex> ul(m);
|
|
|
+ if (cancel)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ if (!obs_output_start(output)) {
|
|
|
+ QMetaObject::invokeMethod(this, "Failure", Q_ARG(QString, QTStr(TEST_RES_FAIL)));
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ cv.wait_for(ul, chrono::seconds(5));
|
|
|
+
|
|
|
+ obs_output_stop(output);
|
|
|
+ cv.wait(ul);
|
|
|
+
|
|
|
+ int skipped = (int)video_output_get_skipped_frames(obs_get_video());
|
|
|
+ if (force || skipped <= 10)
|
|
|
+ results.emplace_back(cx, cy, fps_num, fps_den);
|
|
|
+
|
|
|
+ return !cancel;
|
|
|
+ };
|
|
|
+
|
|
|
+ if (wiz->specificFPSNum && wiz->specificFPSDen) {
|
|
|
+ count = 7;
|
|
|
+ if (!testRes(2160, 0, 0, false))
|
|
|
+ return false;
|
|
|
+ if (!testRes(1440, 0, 0, false))
|
|
|
+ return false;
|
|
|
+ if (!testRes(1080, 0, 0, false))
|
|
|
+ return false;
|
|
|
+ if (!testRes(720, 0, 0, false))
|
|
|
+ return false;
|
|
|
+ if (!testRes(480, 0, 0, false))
|
|
|
+ return false;
|
|
|
+ if (!testRes(360, 0, 0, false))
|
|
|
+ return false;
|
|
|
+ if (!testRes(240, 0, 0, true))
|
|
|
+ return false;
|
|
|
+ } else {
|
|
|
+ count = 14;
|
|
|
+ if (!testRes(2160, 60, 1, false))
|
|
|
+ return false;
|
|
|
+ if (!testRes(2160, 30, 1, false))
|
|
|
+ return false;
|
|
|
+ if (!testRes(1440, 60, 1, false))
|
|
|
+ return false;
|
|
|
+ if (!testRes(1440, 30, 1, false))
|
|
|
+ return false;
|
|
|
+ if (!testRes(1080, 60, 1, false))
|
|
|
+ return false;
|
|
|
+ if (!testRes(1080, 30, 1, false))
|
|
|
+ return false;
|
|
|
+ if (!testRes(720, 60, 1, false))
|
|
|
+ return false;
|
|
|
+ if (!testRes(720, 30, 1, false))
|
|
|
+ return false;
|
|
|
+ if (!testRes(480, 60, 1, false))
|
|
|
+ return false;
|
|
|
+ if (!testRes(480, 30, 1, false))
|
|
|
+ return false;
|
|
|
+ if (!testRes(360, 60, 1, false))
|
|
|
+ return false;
|
|
|
+ if (!testRes(360, 30, 1, false))
|
|
|
+ return false;
|
|
|
+ if (!testRes(240, 60, 1, false))
|
|
|
+ return false;
|
|
|
+ if (!testRes(240, 30, 1, true))
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* -----------------------------------*/
|
|
|
+ /* find preferred settings */
|
|
|
+
|
|
|
+ int minArea = 960 * 540 + 1000;
|
|
|
+
|
|
|
+ if (!wiz->specificFPSNum && wiz->preferHighFPS && results.size() > 1) {
|
|
|
+ Result &result1 = results[0];
|
|
|
+ Result &result2 = results[1];
|
|
|
+
|
|
|
+ if (result1.fps_num == 30 && result2.fps_num == 60) {
|
|
|
+ int nextArea = result2.cx * result2.cy;
|
|
|
+ if (nextArea >= minArea)
|
|
|
+ results.erase(results.begin());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ Result result = results.front();
|
|
|
+ wiz->idealResolutionCX = result.cx;
|
|
|
+ wiz->idealResolutionCY = result.cy;
|
|
|
+ wiz->idealFPSNum = result.fps_num;
|
|
|
+ wiz->idealFPSDen = result.fps_den;
|
|
|
+
|
|
|
+ long double fUpperBitrate = EstimateUpperBitrate(result.cx, result.cy, result.fps_num, result.fps_den);
|
|
|
+
|
|
|
+ int upperBitrate = int(floor(fUpperBitrate / 50.0l) * 50.0l);
|
|
|
+
|
|
|
+ if (wiz->streamingEncoder != AutoConfig::Encoder::x264) {
|
|
|
+ upperBitrate *= 114;
|
|
|
+ upperBitrate /= 100;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (wiz->testMultitrackVideo && wiz->multitrackVideo.testSuccessful &&
|
|
|
+ !wiz->multitrackVideo.bitrate.has_value())
|
|
|
+ wiz->multitrackVideo.bitrate = wiz->idealBitrate;
|
|
|
+
|
|
|
+ if (wiz->idealBitrate > upperBitrate)
|
|
|
+ wiz->idealBitrate = upperBitrate;
|
|
|
+
|
|
|
+ softwareTested = true;
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+void AutoConfigTestPage::FindIdealHardwareResolution()
|
|
|
+{
|
|
|
+ int baseCX = wiz->baseResolutionCX;
|
|
|
+ int baseCY = wiz->baseResolutionCY;
|
|
|
+ CalcBaseRes(baseCX, baseCY);
|
|
|
+
|
|
|
+ vector<Result> results;
|
|
|
+
|
|
|
+ int pcores = os_get_physical_cores();
|
|
|
+ int maxDataRate;
|
|
|
+ if (pcores >= 4) {
|
|
|
+ maxDataRate = 1920 * 1200 * 60 + 1000;
|
|
|
+ } else {
|
|
|
+ maxDataRate = 1280 * 720 * 30 + 1000;
|
|
|
+ }
|
|
|
+
|
|
|
+ auto testRes = [&](int cy, int fps_num, int fps_den, bool force) {
|
|
|
+ if (cy > baseCY)
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (results.size() >= 3)
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (!fps_num || !fps_den) {
|
|
|
+ fps_num = wiz->specificFPSNum;
|
|
|
+ fps_den = wiz->specificFPSDen;
|
|
|
+ }
|
|
|
+
|
|
|
+ long double fps = ((long double)fps_num / (long double)fps_den);
|
|
|
+
|
|
|
+ int cx = int(((long double)baseCX / (long double)baseCY) * (long double)cy);
|
|
|
+
|
|
|
+ long double rate = (long double)cx * (long double)cy * fps;
|
|
|
+ if (!force && rate > maxDataRate)
|
|
|
+ return;
|
|
|
+
|
|
|
+ AutoConfig::Encoder encType = wiz->streamingEncoder;
|
|
|
+ bool nvenc = encType == AutoConfig::Encoder::NVENC;
|
|
|
+
|
|
|
+ int minBitrate = EstimateMinBitrate(cx, cy, fps_num, fps_den);
|
|
|
+
|
|
|
+ /* most hardware encoders don't have a good quality to bitrate
|
|
|
+ * ratio, so increase the minimum bitrate estimate for them.
|
|
|
+ * NVENC currently is the exception because of the improvements
|
|
|
+ * its made to its quality in recent generations. */
|
|
|
+ if (!nvenc)
|
|
|
+ minBitrate = minBitrate * 114 / 100;
|
|
|
+
|
|
|
+ if (wiz->type == AutoConfig::Type::Recording)
|
|
|
+ force = true;
|
|
|
+ if (force || wiz->idealBitrate >= minBitrate)
|
|
|
+ results.emplace_back(cx, cy, fps_num, fps_den);
|
|
|
+ };
|
|
|
+
|
|
|
+ if (wiz->specificFPSNum && wiz->specificFPSDen) {
|
|
|
+ testRes(2160, 0, 0, false);
|
|
|
+ testRes(1440, 0, 0, false);
|
|
|
+ testRes(1080, 0, 0, false);
|
|
|
+ testRes(720, 0, 0, false);
|
|
|
+ testRes(480, 0, 0, false);
|
|
|
+ testRes(360, 0, 0, false);
|
|
|
+ testRes(240, 0, 0, true);
|
|
|
+ } else {
|
|
|
+ testRes(2160, 60, 1, false);
|
|
|
+ testRes(2160, 30, 1, false);
|
|
|
+ testRes(1440, 60, 1, false);
|
|
|
+ testRes(1440, 30, 1, false);
|
|
|
+ testRes(1080, 60, 1, false);
|
|
|
+ testRes(1080, 30, 1, false);
|
|
|
+ testRes(720, 60, 1, false);
|
|
|
+ testRes(720, 30, 1, false);
|
|
|
+ testRes(480, 60, 1, false);
|
|
|
+ testRes(480, 30, 1, false);
|
|
|
+ testRes(360, 60, 1, false);
|
|
|
+ testRes(360, 30, 1, false);
|
|
|
+ testRes(240, 60, 1, false);
|
|
|
+ testRes(240, 30, 1, true);
|
|
|
+ }
|
|
|
+
|
|
|
+ int minArea = 960 * 540 + 1000;
|
|
|
+
|
|
|
+ if (!wiz->specificFPSNum && wiz->preferHighFPS && results.size() > 1) {
|
|
|
+ Result &result1 = results[0];
|
|
|
+ Result &result2 = results[1];
|
|
|
+
|
|
|
+ if (result1.fps_num == 30 && result2.fps_num == 60) {
|
|
|
+ int nextArea = result2.cx * result2.cy;
|
|
|
+ if (nextArea >= minArea)
|
|
|
+ results.erase(results.begin());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ Result result = results.front();
|
|
|
+ wiz->idealResolutionCX = result.cx;
|
|
|
+ wiz->idealResolutionCY = result.cy;
|
|
|
+ wiz->idealFPSNum = result.fps_num;
|
|
|
+ wiz->idealFPSDen = result.fps_den;
|
|
|
+}
|
|
|
+
|
|
|
+void AutoConfigTestPage::TestStreamEncoderThread()
|
|
|
+{
|
|
|
+ bool preferHardware = wiz->preferHardware;
|
|
|
+ if (!softwareTested) {
|
|
|
+ if (!preferHardware || !wiz->hardwareEncodingAvailable) {
|
|
|
+ if (!TestSoftwareEncoding()) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!softwareTested) {
|
|
|
+ if (wiz->nvencAvailable)
|
|
|
+ wiz->streamingEncoder = AutoConfig::Encoder::NVENC;
|
|
|
+ else if (wiz->qsvAvailable)
|
|
|
+ wiz->streamingEncoder = AutoConfig::Encoder::QSV;
|
|
|
+ else if (wiz->appleAvailable)
|
|
|
+ wiz->streamingEncoder = AutoConfig::Encoder::Apple;
|
|
|
+ else
|
|
|
+ wiz->streamingEncoder = AutoConfig::Encoder::AMD;
|
|
|
+ } else {
|
|
|
+ wiz->streamingEncoder = AutoConfig::Encoder::x264;
|
|
|
+ }
|
|
|
+
|
|
|
+#ifdef __linux__
|
|
|
+ // On linux CBR rate control is not guaranteed so fallback to x264.
|
|
|
+ if (wiz->streamingEncoder == AutoConfig::Encoder::QSV) {
|
|
|
+ wiz->streamingEncoder = AutoConfig::Encoder::x264;
|
|
|
+ if (!TestSoftwareEncoding()) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+#endif
|
|
|
+
|
|
|
+ if (preferHardware && !softwareTested && wiz->hardwareEncodingAvailable)
|
|
|
+ FindIdealHardwareResolution();
|
|
|
+
|
|
|
+ QMetaObject::invokeMethod(this, "NextStage");
|
|
|
+}
|
|
|
+
|
|
|
+void AutoConfigTestPage::TestRecordingEncoderThread()
|
|
|
+{
|
|
|
+ if (!wiz->hardwareEncodingAvailable && !softwareTested) {
|
|
|
+ if (!TestSoftwareEncoding()) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (wiz->type == AutoConfig::Type::Recording && wiz->hardwareEncodingAvailable)
|
|
|
+ FindIdealHardwareResolution();
|
|
|
+
|
|
|
+ wiz->recordingQuality = AutoConfig::Quality::High;
|
|
|
+
|
|
|
+ bool recordingOnly = wiz->type == AutoConfig::Type::Recording;
|
|
|
+
|
|
|
+ if (wiz->hardwareEncodingAvailable) {
|
|
|
+ if (wiz->nvencAvailable)
|
|
|
+ wiz->recordingEncoder = AutoConfig::Encoder::NVENC;
|
|
|
+ else if (wiz->qsvAvailable)
|
|
|
+ wiz->recordingEncoder = AutoConfig::Encoder::QSV;
|
|
|
+ else if (wiz->appleAvailable)
|
|
|
+ wiz->recordingEncoder = AutoConfig::Encoder::Apple;
|
|
|
+ else
|
|
|
+ wiz->recordingEncoder = AutoConfig::Encoder::AMD;
|
|
|
+ } else {
|
|
|
+ wiz->recordingEncoder = AutoConfig::Encoder::x264;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (wiz->recordingEncoder != AutoConfig::Encoder::NVENC) {
|
|
|
+ if (!recordingOnly) {
|
|
|
+ wiz->recordingEncoder = AutoConfig::Encoder::Stream;
|
|
|
+ wiz->recordingQuality = AutoConfig::Quality::Stream;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ QMetaObject::invokeMethod(this, "NextStage");
|
|
|
+}
|
|
|
+
|
|
|
+#define ENCODER_TEXT(x) "Basic.Settings.Output.Simple.Encoder." x
|
|
|
+#define ENCODER_SOFTWARE ENCODER_TEXT("Software")
|
|
|
+#define ENCODER_NVENC ENCODER_TEXT("Hardware.NVENC.H264")
|
|
|
+#define ENCODER_QSV ENCODER_TEXT("Hardware.QSV.H264")
|
|
|
+#define ENCODER_AMD ENCODER_TEXT("Hardware.AMD.H264")
|
|
|
+#define ENCODER_APPLE ENCODER_TEXT("Hardware.Apple.H264")
|
|
|
+
|
|
|
+#define QUALITY_SAME "Basic.Settings.Output.Simple.RecordingQuality.Stream"
|
|
|
+#define QUALITY_HIGH "Basic.Settings.Output.Simple.RecordingQuality.Small"
|
|
|
+
|
|
|
+void set_closest_res(int &cx, int &cy, struct obs_service_resolution *res_list, size_t count)
|
|
|
+{
|
|
|
+ int best_pixel_diff = 0x7FFFFFFF;
|
|
|
+ int start_cx = cx;
|
|
|
+ int start_cy = cy;
|
|
|
+
|
|
|
+ for (size_t i = 0; i < count; i++) {
|
|
|
+ struct obs_service_resolution &res = res_list[i];
|
|
|
+ int pixel_cx_diff = abs(start_cx - res.cx);
|
|
|
+ int pixel_cy_diff = abs(start_cy - res.cy);
|
|
|
+ int pixel_diff = pixel_cx_diff + pixel_cy_diff;
|
|
|
+
|
|
|
+ if (pixel_diff < best_pixel_diff) {
|
|
|
+ best_pixel_diff = pixel_diff;
|
|
|
+ cx = res.cx;
|
|
|
+ cy = res.cy;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void AutoConfigTestPage::FinalizeResults()
|
|
|
+{
|
|
|
+ ui->stackedWidget->setCurrentIndex(1);
|
|
|
+ setSubTitle(QTStr(SUBTITLE_COMPLETE));
|
|
|
+
|
|
|
+ QFormLayout *form = results;
|
|
|
+
|
|
|
+ auto encName = [](AutoConfig::Encoder enc) -> QString {
|
|
|
+ switch (enc) {
|
|
|
+ case AutoConfig::Encoder::x264:
|
|
|
+ return QTStr(ENCODER_SOFTWARE);
|
|
|
+ case AutoConfig::Encoder::NVENC:
|
|
|
+ return QTStr(ENCODER_NVENC);
|
|
|
+ case AutoConfig::Encoder::QSV:
|
|
|
+ return QTStr(ENCODER_QSV);
|
|
|
+ case AutoConfig::Encoder::AMD:
|
|
|
+ return QTStr(ENCODER_AMD);
|
|
|
+ case AutoConfig::Encoder::Apple:
|
|
|
+ return QTStr(ENCODER_APPLE);
|
|
|
+ case AutoConfig::Encoder::Stream:
|
|
|
+ return QTStr(QUALITY_SAME);
|
|
|
+ }
|
|
|
+
|
|
|
+ return QTStr(ENCODER_SOFTWARE);
|
|
|
+ };
|
|
|
+
|
|
|
+ auto newLabel = [this](const char *str) -> QLabel * {
|
|
|
+ return new QLabel(QTStr(str), this);
|
|
|
+ };
|
|
|
+
|
|
|
+ if (wiz->type == AutoConfig::Type::Streaming) {
|
|
|
+ const char *serverType = wiz->customServer ? "rtmp_custom" : "rtmp_common";
|
|
|
+
|
|
|
+ OBSServiceAutoRelease service = obs_service_create(serverType, "temp_service", nullptr, nullptr);
|
|
|
+
|
|
|
+ OBSDataAutoRelease service_settings = obs_data_create();
|
|
|
+ OBSDataAutoRelease vencoder_settings = obs_data_create();
|
|
|
+
|
|
|
+ if (wiz->testMultitrackVideo && wiz->multitrackVideo.testSuccessful &&
|
|
|
+ !wiz->multitrackVideo.bitrate.has_value())
|
|
|
+ wiz->multitrackVideo.bitrate = wiz->idealBitrate;
|
|
|
+
|
|
|
+ obs_data_set_int(vencoder_settings, "bitrate", wiz->idealBitrate);
|
|
|
+
|
|
|
+ obs_data_set_string(service_settings, "service", wiz->serviceName.c_str());
|
|
|
+ obs_service_update(service, service_settings);
|
|
|
+ obs_service_apply_encoder_settings(service, vencoder_settings, nullptr);
|
|
|
+
|
|
|
+ BPtr<obs_service_resolution> res_list;
|
|
|
+ size_t res_count;
|
|
|
+ int maxFPS;
|
|
|
+ obs_service_get_supported_resolutions(service, &res_list, &res_count);
|
|
|
+ obs_service_get_max_fps(service, &maxFPS);
|
|
|
+
|
|
|
+ if (res_list) {
|
|
|
+ set_closest_res(wiz->idealResolutionCX, wiz->idealResolutionCY, res_list, res_count);
|
|
|
+ }
|
|
|
+ if (maxFPS) {
|
|
|
+ double idealFPS = (double)wiz->idealFPSNum / (double)wiz->idealFPSDen;
|
|
|
+ if (idealFPS > (double)maxFPS) {
|
|
|
+ wiz->idealFPSNum = maxFPS;
|
|
|
+ wiz->idealFPSDen = 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ wiz->idealBitrate = (int)obs_data_get_int(vencoder_settings, "bitrate");
|
|
|
+
|
|
|
+ if (!wiz->customServer)
|
|
|
+ form->addRow(newLabel("Basic.AutoConfig.StreamPage.Service"),
|
|
|
+ new QLabel(wiz->serviceName.c_str(), ui->finishPage));
|
|
|
+ form->addRow(newLabel("Basic.AutoConfig.StreamPage.Server"),
|
|
|
+ new QLabel(wiz->serverName.c_str(), ui->finishPage));
|
|
|
+ form->addRow(newLabel("Basic.Settings.Stream.MultitrackVideoLabel"),
|
|
|
+ newLabel(wiz->multitrackVideo.testSuccessful ? "Yes" : "No"));
|
|
|
+
|
|
|
+ if (wiz->multitrackVideo.testSuccessful) {
|
|
|
+ form->addRow(newLabel("Basic.Settings.Output.VideoBitrate"), newLabel("Automatic"));
|
|
|
+ form->addRow(newLabel(TEST_RESULT_SE), newLabel("Automatic"));
|
|
|
+ form->addRow(newLabel("Basic.AutoConfig.TestPage.Result.StreamingResolution"),
|
|
|
+ newLabel("Automatic"));
|
|
|
+ } else {
|
|
|
+ form->addRow(newLabel("Basic.Settings.Output.VideoBitrate"),
|
|
|
+ new QLabel(QString::number(wiz->idealBitrate), ui->finishPage));
|
|
|
+ form->addRow(newLabel(TEST_RESULT_SE),
|
|
|
+ new QLabel(encName(wiz->streamingEncoder), ui->finishPage));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ QString baseRes =
|
|
|
+ QString("%1x%2").arg(QString::number(wiz->baseResolutionCX), QString::number(wiz->baseResolutionCY));
|
|
|
+ QString scaleRes =
|
|
|
+ QString("%1x%2").arg(QString::number(wiz->idealResolutionCX), QString::number(wiz->idealResolutionCY));
|
|
|
+
|
|
|
+ if (wiz->recordingEncoder != AutoConfig::Encoder::Stream ||
|
|
|
+ wiz->recordingQuality != AutoConfig::Quality::Stream)
|
|
|
+ form->addRow(newLabel(TEST_RESULT_RE), new QLabel(encName(wiz->recordingEncoder), ui->finishPage));
|
|
|
+
|
|
|
+ QString recQuality;
|
|
|
+
|
|
|
+ switch (wiz->recordingQuality) {
|
|
|
+ case AutoConfig::Quality::High:
|
|
|
+ recQuality = QTStr(QUALITY_HIGH);
|
|
|
+ break;
|
|
|
+ case AutoConfig::Quality::Stream:
|
|
|
+ recQuality = QTStr(QUALITY_SAME);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ form->addRow(newLabel("Basic.Settings.Output.Simple.RecordingQuality"), new QLabel(recQuality, ui->finishPage));
|
|
|
+
|
|
|
+ long double fps = (long double)wiz->idealFPSNum / (long double)wiz->idealFPSDen;
|
|
|
+
|
|
|
+ QString fpsStr = (wiz->idealFPSDen > 1) ? QString::number(fps, 'f', 2) : QString::number(fps, 'g', 2);
|
|
|
+
|
|
|
+ form->addRow(newLabel("Basic.Settings.Video.BaseResolution"), new QLabel(baseRes, ui->finishPage));
|
|
|
+ form->addRow(newLabel("Basic.Settings.Video.ScaledResolution"), new QLabel(scaleRes, ui->finishPage));
|
|
|
+ form->addRow(newLabel("Basic.Settings.Video.FPS"), new QLabel(fpsStr, ui->finishPage));
|
|
|
+
|
|
|
+ // FIXME: form layout is super squished, probably need to set proper sizepolicy on all widgets?
|
|
|
+}
|
|
|
+
|
|
|
+#define STARTING_SEPARATOR "\n==== Auto-config wizard testing commencing ======\n"
|
|
|
+#define STOPPING_SEPARATOR "\n==== Auto-config wizard testing stopping ========\n"
|
|
|
+
|
|
|
+void AutoConfigTestPage::NextStage()
|
|
|
+{
|
|
|
+ if (testThread.joinable())
|
|
|
+ testThread.join();
|
|
|
+ if (cancel)
|
|
|
+ return;
|
|
|
+
|
|
|
+ ui->subProgressLabel->setText(QString());
|
|
|
+
|
|
|
+ /* make it skip to bandwidth stage if only set to config recording */
|
|
|
+ if (stage == Stage::Starting) {
|
|
|
+ if (!started) {
|
|
|
+ blog(LOG_INFO, STARTING_SEPARATOR);
|
|
|
+ started = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (wiz->type != AutoConfig::Type::Streaming) {
|
|
|
+ stage = Stage::StreamEncoder;
|
|
|
+ } else if (!wiz->bandwidthTest) {
|
|
|
+ stage = Stage::BandwidthTest;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (stage == Stage::Starting) {
|
|
|
+ stage = Stage::BandwidthTest;
|
|
|
+ StartBandwidthStage();
|
|
|
+
|
|
|
+ } else if (stage == Stage::BandwidthTest) {
|
|
|
+ stage = Stage::StreamEncoder;
|
|
|
+ StartStreamEncoderStage();
|
|
|
+
|
|
|
+ } else if (stage == Stage::StreamEncoder) {
|
|
|
+ stage = Stage::RecordingEncoder;
|
|
|
+ StartRecordingEncoderStage();
|
|
|
+
|
|
|
+ } else {
|
|
|
+ stage = Stage::Finished;
|
|
|
+ FinalizeResults();
|
|
|
+ emit completeChanged();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void AutoConfigTestPage::UpdateMessage(QString message)
|
|
|
+{
|
|
|
+ ui->subProgressLabel->setText(message);
|
|
|
+}
|
|
|
+
|
|
|
+void AutoConfigTestPage::Failure(QString message)
|
|
|
+{
|
|
|
+ ui->errorLabel->setText(message);
|
|
|
+ ui->stackedWidget->setCurrentIndex(2);
|
|
|
+}
|
|
|
+
|
|
|
+void AutoConfigTestPage::Progress(int percentage)
|
|
|
+{
|
|
|
+ ui->progressBar->setValue(percentage);
|
|
|
+}
|
|
|
+
|
|
|
+AutoConfigTestPage::AutoConfigTestPage(QWidget *parent) : QWizardPage(parent), ui(new Ui_AutoConfigTestPage)
|
|
|
+{
|
|
|
+ ui->setupUi(this);
|
|
|
+ setTitle(QTStr("Basic.AutoConfig.TestPage"));
|
|
|
+ setSubTitle(QTStr(SUBTITLE_TESTING));
|
|
|
+ setCommitPage(true);
|
|
|
+}
|
|
|
+
|
|
|
+AutoConfigTestPage::~AutoConfigTestPage()
|
|
|
+{
|
|
|
+ if (testThread.joinable()) {
|
|
|
+ {
|
|
|
+ unique_lock<mutex> ul(m);
|
|
|
+ cancel = true;
|
|
|
+ cv.notify_one();
|
|
|
+ }
|
|
|
+ testThread.join();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (started)
|
|
|
+ blog(LOG_INFO, STOPPING_SEPARATOR);
|
|
|
+}
|
|
|
+
|
|
|
+void AutoConfigTestPage::initializePage()
|
|
|
+{
|
|
|
+ if (wiz->type == AutoConfig::Type::VirtualCam) {
|
|
|
+ wiz->idealResolutionCX = wiz->baseResolutionCX;
|
|
|
+ wiz->idealResolutionCY = wiz->baseResolutionCY;
|
|
|
+ wiz->idealFPSNum = 30;
|
|
|
+ wiz->idealFPSDen = 1;
|
|
|
+ stage = Stage::Finished;
|
|
|
+ } else {
|
|
|
+ stage = Stage::Starting;
|
|
|
+ }
|
|
|
+
|
|
|
+ setSubTitle(QTStr(SUBTITLE_TESTING));
|
|
|
+ softwareTested = false;
|
|
|
+ cancel = false;
|
|
|
+ DeleteLayout(results);
|
|
|
+ results = new QFormLayout();
|
|
|
+ results->setContentsMargins(0, 0, 0, 0);
|
|
|
+ ui->finishPageLayout->insertLayout(1, results);
|
|
|
+ ui->stackedWidget->setCurrentIndex(0);
|
|
|
+ NextStage();
|
|
|
+}
|
|
|
+
|
|
|
+void AutoConfigTestPage::cleanupPage()
|
|
|
+{
|
|
|
+ if (testThread.joinable()) {
|
|
|
+ {
|
|
|
+ unique_lock<mutex> ul(m);
|
|
|
+ cancel = true;
|
|
|
+ cv.notify_one();
|
|
|
+ }
|
|
|
+ testThread.join();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+bool AutoConfigTestPage::isComplete() const
|
|
|
+{
|
|
|
+ return stage == Stage::Finished;
|
|
|
+}
|
|
|
+
|
|
|
+int AutoConfigTestPage::nextId() const
|
|
|
+{
|
|
|
+ return -1;
|
|
|
+}
|
PatTheMav