diff --git a/js/module.d.ts b/js/module.d.ts index 2bb3aee9f..9066315bf 100644 --- a/js/module.d.ts +++ b/js/module.d.ts @@ -307,6 +307,8 @@ export declare const VideoEncoderFactory: IVideoEncoderFactory; export declare const ServiceFactory: IServiceFactory; export declare const SimpleStreamingFactory: ISimpleStreamingFactory; export declare const AdvancedStreamingFactory: IAdvancedStreamingFactory; +export declare const EnhancedBroadcastingAdvancedStreamingFactory: IEnhancedBroadcastingAdvancedStreamingFactory; +export declare const EnhancedBroadcastingSimpleStreamingFactory: IEnhancedBroadcastingSimpleStreamingFactory; export declare const DelayFactory: IDelayFactory; export declare const ReconnectFactory: IReconnectFactory; export declare const NetworkFactory: INetworkFactory; @@ -794,7 +796,8 @@ export interface IVideoEncoderFactory { create(id: string, name: string, settings?: ISettings): IVideoEncoder; } export interface IStreaming { - videoEncoder: IVideoEncoder; + // Video encoder value is only ignored in the Enhanced Broadcasting mode, otherwise it should be set + videoEncoder?: IVideoEncoder; service: IService; enforceServiceBitrate: boolean; enableTwitchVOD: boolean; @@ -803,7 +806,7 @@ export interface IStreaming { network: INetwork; video: IVideo; signalHandler: (signal: EOutputSignal) => void; - start(): void; + start(): void; // throws stop(force?: boolean): void; droppedFrames: number; totalFrames: number; @@ -838,6 +841,26 @@ export interface IAdvancedStreamingFactory { destroy(stream: IAdvancedStreaming): void; legacySettings: IAdvancedStreaming; } +export interface IEnhancedBroadcastingAdvancedStreaming extends IAdvancedStreaming { + // If set, the Enhanced Broadcasting stream will be in the Dual Output mode. + // This value should be initialized before the stream start. + additionalVideo?: IVideo, +} +export interface IEnhancedBroadcastingAdvancedStreamingFactory { + create(): IEnhancedBroadcastingAdvancedStreaming; + destroy(stream: IEnhancedBroadcastingAdvancedStreaming): void; + legacySettings: IEnhancedBroadcastingAdvancedStreaming; +} +export interface IEnhancedBroadcastingSimpleStreaming extends ISimpleStreaming { + // If set, the Enhanced Broadcasting stream will be in the Dual Output mode. + // This value should be initialized before the stream start. + additionalVideo?: IVideo, +} +export interface IEnhancedBroadcastingSimpleStreamingFactory { + create(): IEnhancedBroadcastingSimpleStreaming; + destroy(stream: IEnhancedBroadcastingSimpleStreaming): void; + legacySettings: IEnhancedBroadcastingSimpleStreaming; +} export interface IFileOutput { path: string; format: ERecordingFormat; diff --git a/js/module.js b/js/module.js index 48ea85376..61471a348 100644 --- a/js/module.js +++ b/js/module.js @@ -1,6 +1,6 @@ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -exports.NodeObs = exports.getSourcesSize = exports.createSources = exports.addItems = exports.AdvancedReplayBufferFactory = exports.SimpleReplayBufferFactory = exports.AudioEncoderFactory = exports.AdvancedRecordingFactory = exports.SimpleRecordingFactory = exports.AudioTrackFactory = exports.NetworkFactory = exports.ReconnectFactory = exports.DelayFactory = exports.AdvancedStreamingFactory = exports.SimpleStreamingFactory = exports.ServiceFactory = exports.VideoEncoderFactory = exports.IPC = exports.ModuleFactory = exports.AudioFactory = exports.Audio = exports.FaderFactory = exports.VolmeterFactory = exports.DisplayFactory = exports.TransitionFactory = exports.FilterFactory = exports.SceneFactory = exports.InputFactory = exports.VideoFactory = exports.Video = exports.Global = exports.DefaultPluginPathMac = exports.DefaultPluginDataPath = exports.DefaultPluginPath = exports.DefaultDataPath = exports.DefaultBinPath = exports.DefaultDrawPluginPath = exports.DefaultOpenGLPath = exports.DefaultD3D11Path = void 0; +exports.NodeObs = exports.getSourcesSize = exports.createSources = exports.addItems = exports.AdvancedReplayBufferFactory = exports.SimpleReplayBufferFactory = exports.AudioEncoderFactory = exports.AdvancedRecordingFactory = exports.SimpleRecordingFactory = exports.AudioTrackFactory = exports.NetworkFactory = exports.ReconnectFactory = exports.DelayFactory = exports.AdvancedStreamingFactory = exports.EnhancedBroadcastingSimpleStreamingFactory = exports.EnhancedBroadcastingAdvancedStreamingFactory = exports.SimpleStreamingFactory = exports.ServiceFactory = exports.VideoEncoderFactory = exports.IPC = exports.ModuleFactory = exports.AudioFactory = exports.Audio = exports.FaderFactory = exports.VolmeterFactory = exports.DisplayFactory = exports.TransitionFactory = exports.FilterFactory = exports.SceneFactory = exports.InputFactory = exports.VideoFactory = exports.Video = exports.Global = exports.DefaultPluginPathMac = exports.DefaultPluginDataPath = exports.DefaultPluginPath = exports.DefaultDataPath = exports.DefaultBinPath = exports.DefaultDrawPluginPath = exports.DefaultOpenGLPath = exports.DefaultD3D11Path = void 0; const path = require("path"); const fs = require("fs"); // Mac- search for optional OSN.app bundle (Chromium requires an app bundle to find obs64 helper apps) @@ -34,6 +34,8 @@ exports.VideoEncoderFactory = obs.VideoEncoder; exports.ServiceFactory = obs.Service; exports.SimpleStreamingFactory = obs.SimpleStreaming; exports.AdvancedStreamingFactory = obs.AdvancedStreaming; +exports.EnhancedBroadcastingAdvancedStreamingFactory = obs.EnhancedBroadcastingAdvancedStreaming; +exports.EnhancedBroadcastingSimpleStreamingFactory = obs.EnhancedBroadcastingSimpleStreaming; exports.DelayFactory = obs.Delay; exports.ReconnectFactory = obs.Reconnect; exports.NetworkFactory = obs.Network; @@ -70,7 +72,7 @@ function createSources(sources) { console.error(`[OSN] Failed to create input for source "${source.name}":`, error instanceof Error ? error.message : error); return; // Skip the rest of this iteration if input creation fails } - + if (newSource) { if (newSource.audioMixers) { newSource.muted = source.muted ?? false; @@ -80,7 +82,7 @@ function createSources(sources) { newSource.deinterlaceMode = source.deinterlaceMode; newSource.deinterlaceFieldOrder = source.deinterlaceFieldOrder; items.push(newSource); - + const filters = source.filters; if (Array.isArray(filters)) { filters.forEach(function (filter) { @@ -90,7 +92,7 @@ function createSources(sources) { } catch (filterError) { console.error(`[OSN] Failed to create filter "${filter.name}" for source "${source.name}":`, filterError instanceof Error ? filterError.message : filterError); } - + if (ObsFilter) { ObsFilter.enabled = filter.enabled ?? true; newSource.addFilter(ObsFilter); diff --git a/js/module.ts b/js/module.ts index 6ef9a70ea..8063934e3 100644 --- a/js/module.ts +++ b/js/module.ts @@ -392,6 +392,8 @@ export const VideoEncoderFactory: IVideoEncoderFactory = obs.VideoEncoder; export const ServiceFactory: IServiceFactory = obs.Service; export const SimpleStreamingFactory: ISimpleStreamingFactory = obs.SimpleStreaming; export const AdvancedStreamingFactory: IAdvancedStreamingFactory = obs.AdvancedStreaming; +export const EnhancedBroadcastingAdvancedStreamingFactory: IEnhancedBroadcastingAdvancedStreamingFactory = obs.EnhancedBroadcastingAdvancedStreaming; +export const EnhancedBroadcastingSimpleStreamingFactory: IEnhancedBroadcastingSimpleStreamingFactory = obs.EnhancedBroadcastingSimpleStreaming; export const DelayFactory: IDelayFactory = obs.Delay; export const ReconnectFactory: IReconnectFactory = obs.Reconnect; export const NetworkFactory: INetworkFactory = obs.Network; @@ -581,12 +583,12 @@ export interface IGlobal { readonly version: number; /** - * Percentage of CPU being used + * Percentage of CPU being used */ readonly cpuPercentage: number; /** - * Current FPS + * Current FPS */ readonly currentFrameRate: number; @@ -601,7 +603,7 @@ export interface IGlobal { readonly diskSpaceAvailable: number; /** - * Current memory usage + * Current memory usage */ readonly memoryUsage: number; } @@ -1705,7 +1707,8 @@ export interface IVideoEncoderFactory { } export interface IStreaming { - videoEncoder: IVideoEncoder, + // Video encoder value is ignored only in the Enhanced Broadcasting mode, otherwise it should be set + videoEncoder?: IVideoEncoder, service: IService, enforceServiceBitrate: boolean, enableTwitchVOD: boolean, @@ -1714,7 +1717,7 @@ export interface IStreaming { network: INetwork, video: IVideo, signalHandler: (signal: EOutputSignal) => void, - start(): void, + start(): void, // throws stop(force?: boolean): void, droppedFrames: number; totalFrames: number; @@ -1755,6 +1758,30 @@ export interface IAdvancedStreamingFactory { legacySettings: IAdvancedStreaming; } +export interface IEnhancedBroadcastingAdvancedStreaming extends IAdvancedStreaming { + // If set, the Enhanced Broadcasting stream will be in the Dual Output mode. + // This value should be initialized before the stream start. + additionalVideo?: IVideo, +} + +export interface IEnhancedBroadcastingAdvancedStreamingFactory { + create(): IEnhancedBroadcastingAdvancedStreaming; + destroy(stream: IEnhancedBroadcastingAdvancedStreaming): void; + legacySettings: IEnhancedBroadcastingAdvancedStreaming; +} + +export interface IEnhancedBroadcastingSimpleStreaming extends ISimpleStreaming { + // If set, the Enhanced Broadcasting stream will be in the Dual Output mode. + // This value should be initialized before the stream start. + additionalVideo?: IVideo, +} + +export interface IEnhancedBroadcastingSimpleStreamingFactory { + create(): IEnhancedBroadcastingSimpleStreaming; + destroy(stream: IEnhancedBroadcastingSimpleStreaming): void; + legacySettings: IEnhancedBroadcastingSimpleStreaming; +} + export interface IFileOutput { path: string, format: ERecordingFormat, diff --git a/obs-studio-client/CMakeLists.txt b/obs-studio-client/CMakeLists.txt index b8abce6c9..ec3530915 100644 --- a/obs-studio-client/CMakeLists.txt +++ b/obs-studio-client/CMakeLists.txt @@ -98,10 +98,18 @@ SET(osn-client_SOURCES "source/audio.cpp" "source/streaming.hpp" "source/streaming.cpp" + "source/simple-streaming-base.hpp" + "source/simple-streaming-base.cpp" "source/simple-streaming.hpp" "source/simple-streaming.cpp" + "source/advanced-streaming-base.hpp" + "source/advanced-streaming-base.cpp" "source/advanced-streaming.hpp" "source/advanced-streaming.cpp" + "source/enhanced-broadcasting-advanced-streaming.hpp" + "source/enhanced-broadcasting-advanced-streaming.cpp" + "source/enhanced-broadcasting-simple-streaming.hpp" + "source/enhanced-broadcasting-simple-streaming.cpp" "source/worker-signals.hpp" "source/delay.hpp" "source/delay.cpp" @@ -187,7 +195,7 @@ target_link_libraries(${PROJECT_NAME} ${LIBOBS_LIBRARIES}) add_definitions(-DNAPI_VERSION=7) #Define the OSN_VERSION -add_compile_definitions(OSN_VERSION=\"$ENV{tagartifact}\") +add_compile_definitions(OSN_VERSION=\"$ENV{tagartifact}\") set_target_properties( obs_studio_client PROPERTIES @@ -235,5 +243,5 @@ install( TARGETS obs_studio_client RUNTIME DESTINATION "./" COMPONENT Runtime LIBRARY DESTINATION "./" COMPONENT Runtime - ARCHIVE DESTINATION "./" COMPONENT Runtime + ARCHIVE DESTINATION "./" COMPONENT Runtime ) diff --git a/obs-studio-client/source/advanced-streaming-base.cpp b/obs-studio-client/source/advanced-streaming-base.cpp new file mode 100644 index 000000000..3c13403ef --- /dev/null +++ b/obs-studio-client/source/advanced-streaming-base.cpp @@ -0,0 +1,134 @@ +/****************************************************************************** + Copyright (C) 2016-2022 by Streamlabs (General Workings Inc) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +******************************************************************************/ + +#include "advanced-streaming-base.hpp" + +Napi::Value osn::AdvancedStreamingBase::GetAudioTrack(const Napi::CallbackInfo &info) +{ + auto conn = GetConnection(info); + if (!conn) + return info.Env().Undefined(); + + std::vector response = conn->call_synchronous_helper("AdvancedStreaming", "GetAudioTrack", {ipc::value(this->uid)}); + + if (!ValidateResponse(info, response)) + return info.Env().Undefined(); + + return Napi::Number::New(info.Env(), response[1].value_union.ui32); +} + +void osn::AdvancedStreamingBase::SetAudioTrack(const Napi::CallbackInfo &info, const Napi::Value &value) +{ + auto conn = GetConnection(info); + if (!conn) + return; + + conn->call_synchronous_helper("AdvancedStreaming", "SetAudioTrack", {ipc::value(this->uid), ipc::value(value.ToNumber().Uint32Value())}); +} + +Napi::Value osn::AdvancedStreamingBase::GetTwitchTrack(const Napi::CallbackInfo &info) +{ + auto conn = GetConnection(info); + if (!conn) + return info.Env().Undefined(); + + std::vector response = conn->call_synchronous_helper("AdvancedStreaming", "GetTwitchTrack", {ipc::value(this->uid)}); + + if (!ValidateResponse(info, response)) + return info.Env().Undefined(); + + return Napi::Number::New(info.Env(), response[1].value_union.ui32); +} + +void osn::AdvancedStreamingBase::SetTwitchTrack(const Napi::CallbackInfo &info, const Napi::Value &value) +{ + auto conn = GetConnection(info); + if (!conn) + return; + + conn->call_synchronous_helper("AdvancedStreaming", "SetTwitchTrack", {ipc::value(this->uid), ipc::value(value.ToNumber().Uint32Value())}); +} + +Napi::Value osn::AdvancedStreamingBase::GetRescaling(const Napi::CallbackInfo &info) +{ + auto conn = GetConnection(info); + if (!conn) + return info.Env().Undefined(); + + std::vector response = conn->call_synchronous_helper("AdvancedStreaming", "GetRescaling", {ipc::value(this->uid)}); + + if (!ValidateResponse(info, response)) + return info.Env().Undefined(); + + return Napi::Boolean::New(info.Env(), response[1].value_union.ui32); +} + +void osn::AdvancedStreamingBase::SetRescaling(const Napi::CallbackInfo &info, const Napi::Value &value) +{ + auto conn = GetConnection(info); + if (!conn) + return; + + conn->call_synchronous_helper("AdvancedStreaming", "SetRescaling", {ipc::value(this->uid), ipc::value(value.ToNumber().Uint32Value())}); +} + +Napi::Value osn::AdvancedStreamingBase::GetOutputWidth(const Napi::CallbackInfo &info) +{ + auto conn = GetConnection(info); + if (!conn) + return info.Env().Undefined(); + + std::vector response = conn->call_synchronous_helper("AdvancedStreaming", "GetOutputWidth", {ipc::value(this->uid)}); + + if (!ValidateResponse(info, response)) + return info.Env().Undefined(); + + return Napi::Number::New(info.Env(), response[1].value_union.ui32); +} + +void osn::AdvancedStreamingBase::SetOutputWidth(const Napi::CallbackInfo &info, const Napi::Value &value) +{ + auto conn = GetConnection(info); + if (!conn) + return; + + conn->call_synchronous_helper("AdvancedStreaming", "SetOutputWidth", {ipc::value(this->uid), ipc::value(value.ToNumber().Uint32Value())}); +} + +Napi::Value osn::AdvancedStreamingBase::GetOutputHeight(const Napi::CallbackInfo &info) +{ + auto conn = GetConnection(info); + if (!conn) + return info.Env().Undefined(); + + std::vector response = conn->call_synchronous_helper("AdvancedStreaming", "GetOutputHeight", {ipc::value(this->uid)}); + + if (!ValidateResponse(info, response)) + return info.Env().Undefined(); + + return Napi::Number::New(info.Env(), response[1].value_union.ui32); +} + +void osn::AdvancedStreamingBase::SetOutputHeight(const Napi::CallbackInfo &info, const Napi::Value &value) +{ + auto conn = GetConnection(info); + if (!conn) + return; + + conn->call_synchronous_helper("AdvancedStreaming", "SetOutputHeight", {ipc::value(this->uid), ipc::value(value.ToNumber().Uint32Value())}); +} diff --git a/obs-studio-client/source/advanced-streaming-base.hpp b/obs-studio-client/source/advanced-streaming-base.hpp new file mode 100644 index 000000000..1ad27dea1 --- /dev/null +++ b/obs-studio-client/source/advanced-streaming-base.hpp @@ -0,0 +1,39 @@ +/****************************************************************************** + Copyright (C) 2016-2022 by Streamlabs (General Workings Inc) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +******************************************************************************/ + +#pragma once +#include +#include "streaming.hpp" + +namespace osn { + +class AdvancedStreamingBase : public osn::Streaming { +public: + Napi::Value GetAudioTrack(const Napi::CallbackInfo &info); + void SetAudioTrack(const Napi::CallbackInfo &info, const Napi::Value &value); + Napi::Value GetTwitchTrack(const Napi::CallbackInfo &info); + void SetTwitchTrack(const Napi::CallbackInfo &info, const Napi::Value &value); + Napi::Value GetRescaling(const Napi::CallbackInfo &info); + void SetRescaling(const Napi::CallbackInfo &info, const Napi::Value &value); + Napi::Value GetOutputWidth(const Napi::CallbackInfo &info); + void SetOutputWidth(const Napi::CallbackInfo &info, const Napi::Value &value); + Napi::Value GetOutputHeight(const Napi::CallbackInfo &info); + void SetOutputHeight(const Napi::CallbackInfo &info, const Napi::Value &value); +}; + +} \ No newline at end of file diff --git a/obs-studio-client/source/advanced-streaming.cpp b/obs-studio-client/source/advanced-streaming.cpp index 267169b07..45697af65 100644 --- a/obs-studio-client/source/advanced-streaming.cpp +++ b/obs-studio-client/source/advanced-streaming.cpp @@ -116,121 +116,6 @@ void osn::AdvancedStreaming::Destroy(const Napi::CallbackInfo &info) return; } -Napi::Value osn::AdvancedStreaming::GetAudioTrack(const Napi::CallbackInfo &info) -{ - auto conn = GetConnection(info); - if (!conn) - return info.Env().Undefined(); - - std::vector response = conn->call_synchronous_helper("AdvancedStreaming", "GetAudioTrack", {ipc::value(this->uid)}); - - if (!ValidateResponse(info, response)) - return info.Env().Undefined(); - - return Napi::Number::New(info.Env(), response[1].value_union.ui32); -} - -void osn::AdvancedStreaming::SetAudioTrack(const Napi::CallbackInfo &info, const Napi::Value &value) -{ - auto conn = GetConnection(info); - if (!conn) - return; - - conn->call_synchronous_helper("AdvancedStreaming", "SetAudioTrack", {ipc::value(this->uid), ipc::value(value.ToNumber().Uint32Value())}); -} - -Napi::Value osn::AdvancedStreaming::GetTwitchTrack(const Napi::CallbackInfo &info) -{ - auto conn = GetConnection(info); - if (!conn) - return info.Env().Undefined(); - - std::vector response = conn->call_synchronous_helper("AdvancedStreaming", "GetTwitchTrack", {ipc::value(this->uid)}); - - if (!ValidateResponse(info, response)) - return info.Env().Undefined(); - - return Napi::Number::New(info.Env(), response[1].value_union.ui32); -} - -void osn::AdvancedStreaming::SetTwitchTrack(const Napi::CallbackInfo &info, const Napi::Value &value) -{ - auto conn = GetConnection(info); - if (!conn) - return; - - conn->call_synchronous_helper("AdvancedStreaming", "SetTwitchTrack", {ipc::value(this->uid), ipc::value(value.ToNumber().Uint32Value())}); -} - -Napi::Value osn::AdvancedStreaming::GetRescaling(const Napi::CallbackInfo &info) -{ - auto conn = GetConnection(info); - if (!conn) - return info.Env().Undefined(); - - std::vector response = conn->call_synchronous_helper("AdvancedStreaming", "GetRescaling", {ipc::value(this->uid)}); - - if (!ValidateResponse(info, response)) - return info.Env().Undefined(); - - return Napi::Boolean::New(info.Env(), response[1].value_union.ui32); -} - -void osn::AdvancedStreaming::SetRescaling(const Napi::CallbackInfo &info, const Napi::Value &value) -{ - auto conn = GetConnection(info); - if (!conn) - return; - - conn->call_synchronous_helper("AdvancedStreaming", "SetRescaling", {ipc::value(this->uid), ipc::value(value.ToNumber().Uint32Value())}); -} - -Napi::Value osn::AdvancedStreaming::GetOutputWidth(const Napi::CallbackInfo &info) -{ - auto conn = GetConnection(info); - if (!conn) - return info.Env().Undefined(); - - std::vector response = conn->call_synchronous_helper("AdvancedStreaming", "GetOutputWidth", {ipc::value(this->uid)}); - - if (!ValidateResponse(info, response)) - return info.Env().Undefined(); - - return Napi::Number::New(info.Env(), response[1].value_union.ui32); -} - -void osn::AdvancedStreaming::SetOutputWidth(const Napi::CallbackInfo &info, const Napi::Value &value) -{ - auto conn = GetConnection(info); - if (!conn) - return; - - conn->call_synchronous_helper("AdvancedStreaming", "SetOutputWidth", {ipc::value(this->uid), ipc::value(value.ToNumber().Uint32Value())}); -} - -Napi::Value osn::AdvancedStreaming::GetOutputHeight(const Napi::CallbackInfo &info) -{ - auto conn = GetConnection(info); - if (!conn) - return info.Env().Undefined(); - - std::vector response = conn->call_synchronous_helper("AdvancedStreaming", "GetOutputHeight", {ipc::value(this->uid)}); - - if (!ValidateResponse(info, response)) - return info.Env().Undefined(); - - return Napi::Number::New(info.Env(), response[1].value_union.ui32); -} - -void osn::AdvancedStreaming::SetOutputHeight(const Napi::CallbackInfo &info, const Napi::Value &value) -{ - auto conn = GetConnection(info); - if (!conn) - return; - - conn->call_synchronous_helper("AdvancedStreaming", "SetOutputHeight", {ipc::value(this->uid), ipc::value(value.ToNumber().Uint32Value())}); -} - Napi::Value osn::AdvancedStreaming::GetLegacySettings(const Napi::CallbackInfo &info) { auto conn = GetConnection(info); diff --git a/obs-studio-client/source/advanced-streaming.hpp b/obs-studio-client/source/advanced-streaming.hpp index 261c5585c..b15274bf5 100644 --- a/obs-studio-client/source/advanced-streaming.hpp +++ b/obs-studio-client/source/advanced-streaming.hpp @@ -18,10 +18,11 @@ #pragma once #include -#include "streaming.hpp" +#include "advanced-streaming-base.hpp" namespace osn { -class AdvancedStreaming : public Napi::ObjectWrap, public osn::Streaming { + +class AdvancedStreaming : public Napi::ObjectWrap, public osn::AdvancedStreamingBase { public: static Napi::FunctionReference constructor; static Napi::Object Init(Napi::Env env, Napi::Object exports); @@ -30,18 +31,8 @@ class AdvancedStreaming : public Napi::ObjectWrap, publi static Napi::Value Create(const Napi::CallbackInfo &info); static void Destroy(const Napi::CallbackInfo &info); - Napi::Value GetAudioTrack(const Napi::CallbackInfo &info); - void SetAudioTrack(const Napi::CallbackInfo &info, const Napi::Value &value); - Napi::Value GetTwitchTrack(const Napi::CallbackInfo &info); - void SetTwitchTrack(const Napi::CallbackInfo &info, const Napi::Value &value); - Napi::Value GetRescaling(const Napi::CallbackInfo &info); - void SetRescaling(const Napi::CallbackInfo &info, const Napi::Value &value); - Napi::Value GetOutputWidth(const Napi::CallbackInfo &info); - void SetOutputWidth(const Napi::CallbackInfo &info, const Napi::Value &value); - Napi::Value GetOutputHeight(const Napi::CallbackInfo &info); - void SetOutputHeight(const Napi::CallbackInfo &info, const Napi::Value &value); - static Napi::Value GetLegacySettings(const Napi::CallbackInfo &info); static void SetLegacySettings(const Napi::CallbackInfo &info, const Napi::Value &value); }; + } \ No newline at end of file diff --git a/obs-studio-client/source/enhanced-broadcasting-advanced-streaming.cpp b/obs-studio-client/source/enhanced-broadcasting-advanced-streaming.cpp new file mode 100644 index 000000000..0744f9899 --- /dev/null +++ b/obs-studio-client/source/enhanced-broadcasting-advanced-streaming.cpp @@ -0,0 +1,201 @@ +/****************************************************************************** + Copyright (C) 2016-2022 by Streamlabs (General Workings Inc) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +******************************************************************************/ + +#include "enhanced-broadcasting-advanced-streaming.hpp" +#include "utility.hpp" +#include "service.hpp" +#include "delay.hpp" +#include "reconnect.hpp" +#include "network.hpp" +#include "video.hpp" + +Napi::FunctionReference osn::EnhancedBroadcastingAdvancedStreaming::constructor; + +Napi::Object osn::EnhancedBroadcastingAdvancedStreaming::Init(Napi::Env env, Napi::Object exports) +{ + Napi::HandleScope scope(env); + Napi::Function func = DefineClass( + env, "EnhancedBroadcastingAdvancedStreaming", + {StaticMethod("create", &osn::EnhancedBroadcastingAdvancedStreaming::Create), + StaticMethod("destroy", &osn::EnhancedBroadcastingAdvancedStreaming::Destroy), + + InstanceAccessor("videoEncoder", &osn::EnhancedBroadcastingAdvancedStreaming::GetVideoEncoder, + &osn::EnhancedBroadcastingAdvancedStreaming::SetVideoEncoder), + InstanceAccessor("service", &osn::EnhancedBroadcastingAdvancedStreaming::GetService, &osn::EnhancedBroadcastingAdvancedStreaming::SetService), + InstanceAccessor("enforceServiceBitrate", &osn::EnhancedBroadcastingAdvancedStreaming::GetEnforceServiceBirate, + &osn::EnhancedBroadcastingAdvancedStreaming::SetEnforceServiceBirate), + InstanceAccessor("enableTwitchVOD", &osn::EnhancedBroadcastingAdvancedStreaming::GetEnableTwitchVOD, + &osn::EnhancedBroadcastingAdvancedStreaming::SetEnableTwitchVOD), + InstanceAccessor("signalHandler", &osn::EnhancedBroadcastingAdvancedStreaming::GetSignalHandler, + &osn::EnhancedBroadcastingAdvancedStreaming::SetSignalHandler), + InstanceAccessor("delay", &osn::EnhancedBroadcastingAdvancedStreaming::GetDelay, &osn::EnhancedBroadcastingAdvancedStreaming::SetDelay), + InstanceAccessor("reconnect", &osn::EnhancedBroadcastingAdvancedStreaming::GetReconnect, + &osn::EnhancedBroadcastingAdvancedStreaming::SetReconnect), + InstanceAccessor("network", &osn::EnhancedBroadcastingAdvancedStreaming::GetNetwork, &osn::EnhancedBroadcastingAdvancedStreaming::SetNetwork), + InstanceAccessor("video", &osn::EnhancedBroadcastingAdvancedStreaming::GetCanvas, &osn::EnhancedBroadcastingAdvancedStreaming::SetCanvas), + InstanceAccessor("additionalVideo", &osn::EnhancedBroadcastingAdvancedStreaming::GetAdditionalCanvas, + &osn::EnhancedBroadcastingAdvancedStreaming::SetAdditionalCanvas), + InstanceAccessor("droppedFrames", &osn::EnhancedBroadcastingAdvancedStreaming::GetDroppedFrames, nullptr), + InstanceAccessor("totalFrames", &osn::EnhancedBroadcastingAdvancedStreaming::GetTotalFrames, nullptr), + InstanceAccessor("kbitsPerSec", &osn::EnhancedBroadcastingAdvancedStreaming::GetKBitsPerSec, nullptr), + InstanceAccessor("dataOutput", &osn::EnhancedBroadcastingAdvancedStreaming::GetDataOutput, nullptr), + + InstanceAccessor("audioTrack", &osn::EnhancedBroadcastingAdvancedStreaming::GetAudioTrack, + &osn::EnhancedBroadcastingAdvancedStreaming::SetAudioTrack), + InstanceAccessor("twitchTrack", &osn::EnhancedBroadcastingAdvancedStreaming::GetTwitchTrack, + &osn::EnhancedBroadcastingAdvancedStreaming::SetTwitchTrack), + InstanceAccessor("rescaling", &osn::EnhancedBroadcastingAdvancedStreaming::GetRescaling, + &osn::EnhancedBroadcastingAdvancedStreaming::SetRescaling), + InstanceAccessor("outputWidth", &osn::EnhancedBroadcastingAdvancedStreaming::GetOutputWidth, + &osn::EnhancedBroadcastingAdvancedStreaming::SetOutputWidth), + InstanceAccessor("outputHeight", &osn::EnhancedBroadcastingAdvancedStreaming::GetOutputHeight, + &osn::EnhancedBroadcastingAdvancedStreaming::SetOutputHeight), + + InstanceMethod("start", &osn::EnhancedBroadcastingAdvancedStreaming::Start), + InstanceMethod("stop", &osn::EnhancedBroadcastingAdvancedStreaming::Stop), + + StaticAccessor("legacySettings", &osn::EnhancedBroadcastingAdvancedStreaming::GetLegacySettings, + &osn::EnhancedBroadcastingAdvancedStreaming::SetLegacySettings)}); + + exports.Set("EnhancedBroadcastingAdvancedStreaming", func); + osn::EnhancedBroadcastingAdvancedStreaming::constructor = Napi::Persistent(func); + osn::EnhancedBroadcastingAdvancedStreaming::constructor.SuppressDestruct(); + + return exports; +} + +osn::EnhancedBroadcastingAdvancedStreaming::EnhancedBroadcastingAdvancedStreaming(const Napi::CallbackInfo &info) + : Napi::ObjectWrap(info) +{ + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + size_t length = info.Length(); + + if (length <= 0 || !info[0].IsNumber()) { + Napi::TypeError::New(env, "Number expected").ThrowAsJavaScriptException(); + return; + } + + this->uid = (uint64_t)info[0].ToNumber().Int64Value(); + this->className = std::string("EnhancedBroadcastingAdvancedStreaming"); +} + +Napi::Value osn::EnhancedBroadcastingAdvancedStreaming::Create(const Napi::CallbackInfo &info) +{ + auto conn = GetConnection(info); + if (!conn) + return info.Env().Undefined(); + + std::vector response = conn->call_synchronous_helper("EnhancedBroadcastingAdvancedStreaming", "Create", {}); + + if (!ValidateResponse(info, response)) + return info.Env().Undefined(); + + auto instance = + osn::EnhancedBroadcastingAdvancedStreaming::constructor.New({Napi::Number::New(info.Env(), static_cast(response[1].value_union.ui64))}); + + return instance; +} + +void osn::EnhancedBroadcastingAdvancedStreaming::Destroy(const Napi::CallbackInfo &info) +{ + if (info.Length() != 1) + return; + + auto stream = Napi::ObjectWrap::Unwrap(info[0].ToObject()); + + stream->stopWorker(); + stream->cb.Reset(); + + auto conn = GetConnection(info); + if (!conn) + return; + + std::vector response = conn->call_synchronous_helper("EnhancedBroadcastingAdvancedStreaming", "Destroy", {ipc::value(stream->uid)}); + + if (!ValidateResponse(info, response)) + return; +} + +Napi::Value osn::EnhancedBroadcastingAdvancedStreaming::GetAdditionalCanvas(const Napi::CallbackInfo &info) +{ + auto conn = GetConnection(info); + if (!conn) + return info.Env().Undefined(); + + std::vector response = conn->call_synchronous_helper(className, "GetAdditionalVideoCanvas", {ipc::value(this->uid)}); + + if (!ValidateResponse(info, response)) + return info.Env().Undefined(); + + auto instance = osn::Video::constructor.New({Napi::Number::New(info.Env(), static_cast(response[1].value_union.ui64))}); + + return instance; +} + +void osn::EnhancedBroadcastingAdvancedStreaming::SetAdditionalCanvas(const Napi::CallbackInfo &info, const Napi::Value &value) +{ + osn::Video *canvas = Napi::ObjectWrap::Unwrap(value.ToObject()); + + if (!canvas) { + Napi::TypeError::New(info.Env(), "Invalid canvas argument").ThrowAsJavaScriptException(); + return; + } + + auto conn = GetConnection(info); + if (!conn) + return; + + conn->call(className, "SetAdditionalVideoCanvas", {ipc::value(this->uid), ipc::value(canvas->canvasId)}); +} + +Napi::Value osn::EnhancedBroadcastingAdvancedStreaming::GetLegacySettings(const Napi::CallbackInfo &info) +{ + auto conn = GetConnection(info); + if (!conn) + return info.Env().Undefined(); + + std::vector response = conn->call_synchronous_helper("EnhancedBroadcastingAdvancedStreaming", "GetLegacySettings", {}); + + if (!ValidateResponse(info, response)) + return info.Env().Undefined(); + + auto instance = + osn::EnhancedBroadcastingAdvancedStreaming::constructor.New({Napi::Number::New(info.Env(), static_cast(response[1].value_union.ui64))}); + + return instance; +} + +void osn::EnhancedBroadcastingAdvancedStreaming::SetLegacySettings(const Napi::CallbackInfo &info, const Napi::Value &value) +{ + osn::EnhancedBroadcastingAdvancedStreaming *streaming = Napi::ObjectWrap::Unwrap(value.ToObject()); + + if (!streaming) { + Napi::TypeError::New(info.Env(), "Invalid service argument").ThrowAsJavaScriptException(); + return; + } + + auto conn = GetConnection(info); + if (!conn) + return; + + std::vector response = conn->call_synchronous_helper("EnhancedBroadcastingAdvancedStreaming", "SetLegacySettings", {streaming->uid}); + + if (!ValidateResponse(info, response)) + return; +} \ No newline at end of file diff --git a/obs-studio-client/source/enhanced-broadcasting-advanced-streaming.hpp b/obs-studio-client/source/enhanced-broadcasting-advanced-streaming.hpp new file mode 100644 index 000000000..37ee11a2f --- /dev/null +++ b/obs-studio-client/source/enhanced-broadcasting-advanced-streaming.hpp @@ -0,0 +1,39 @@ +/****************************************************************************** + Copyright (C) 2016-2022 by Streamlabs (General Workings Inc) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +******************************************************************************/ + +#pragma once +#include +#include "advanced-streaming.hpp" + +namespace osn { +class EnhancedBroadcastingAdvancedStreaming : public Napi::ObjectWrap, public osn::AdvancedStreamingBase { +public: + static Napi::FunctionReference constructor; + static Napi::Object Init(Napi::Env env, Napi::Object exports); + EnhancedBroadcastingAdvancedStreaming(const Napi::CallbackInfo &info); + + static Napi::Value Create(const Napi::CallbackInfo &info); + static void Destroy(const Napi::CallbackInfo &info); + + Napi::Value GetAdditionalCanvas(const Napi::CallbackInfo &info); + void SetAdditionalCanvas(const Napi::CallbackInfo &info, const Napi::Value &value); + + static Napi::Value GetLegacySettings(const Napi::CallbackInfo &info); + static void SetLegacySettings(const Napi::CallbackInfo &info, const Napi::Value &value); +}; +} \ No newline at end of file diff --git a/obs-studio-client/source/enhanced-broadcasting-simple-streaming.cpp b/obs-studio-client/source/enhanced-broadcasting-simple-streaming.cpp new file mode 100644 index 000000000..01d95d940 --- /dev/null +++ b/obs-studio-client/source/enhanced-broadcasting-simple-streaming.cpp @@ -0,0 +1,198 @@ +/****************************************************************************** + Copyright (C) 2016-2022 by Streamlabs (General Workings Inc) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +******************************************************************************/ + +#include "enhanced-broadcasting-simple-streaming.hpp" +#include "utility.hpp" +#include "service.hpp" +#include "delay.hpp" +#include "reconnect.hpp" +#include "network.hpp" +#include "video.hpp" + +Napi::FunctionReference osn::EnhancedBroadcastingSimpleStreaming::constructor; + +Napi::Object osn::EnhancedBroadcastingSimpleStreaming::Init(Napi::Env env, Napi::Object exports) +{ + Napi::HandleScope scope(env); + Napi::Function func = DefineClass( + env, "EnhancedBroadcastingSimpleStreaming", + {StaticMethod("create", &osn::EnhancedBroadcastingSimpleStreaming::Create), + StaticMethod("destroy", &osn::EnhancedBroadcastingSimpleStreaming::Destroy), + + InstanceAccessor("videoEncoder", &osn::EnhancedBroadcastingSimpleStreaming::GetVideoEncoder, + &osn::EnhancedBroadcastingSimpleStreaming::SetVideoEncoder), + InstanceAccessor("audioEncoder", &osn::EnhancedBroadcastingSimpleStreaming::GetAudioEncoder, + &osn::EnhancedBroadcastingSimpleStreaming::SetAudioEncoder), + InstanceAccessor("service", &osn::EnhancedBroadcastingSimpleStreaming::GetService, &osn::EnhancedBroadcastingSimpleStreaming::SetService), + InstanceAccessor("enforceServiceBitrate", &osn::EnhancedBroadcastingSimpleStreaming::GetEnforceServiceBirate, + &osn::EnhancedBroadcastingSimpleStreaming::SetEnforceServiceBirate), + InstanceAccessor("enableTwitchVOD", &osn::EnhancedBroadcastingSimpleStreaming::GetEnableTwitchVOD, + &osn::EnhancedBroadcastingSimpleStreaming::SetEnableTwitchVOD), + InstanceAccessor("audioEncoder", &osn::EnhancedBroadcastingSimpleStreaming::GetAudioEncoder, + &osn::EnhancedBroadcastingSimpleStreaming::SetAudioEncoder), + InstanceAccessor("useAdvanced", &osn::EnhancedBroadcastingSimpleStreaming::GetUseAdvanced, + &osn::EnhancedBroadcastingSimpleStreaming::SetUseAdvanced), + InstanceAccessor("customEncSettings", &osn::EnhancedBroadcastingSimpleStreaming::GetCustomEncSettings, + &osn::EnhancedBroadcastingSimpleStreaming::SetCustomEncSettings), + InstanceAccessor("signalHandler", &osn::EnhancedBroadcastingSimpleStreaming::GetSignalHandler, + &osn::EnhancedBroadcastingSimpleStreaming::SetSignalHandler), + InstanceAccessor("delay", &osn::EnhancedBroadcastingSimpleStreaming::GetDelay, &osn::EnhancedBroadcastingSimpleStreaming::SetDelay), + InstanceAccessor("reconnect", &osn::EnhancedBroadcastingSimpleStreaming::GetReconnect, + &osn::EnhancedBroadcastingSimpleStreaming::SetReconnect), + InstanceAccessor("network", &osn::EnhancedBroadcastingSimpleStreaming::GetNetwork, &osn::EnhancedBroadcastingSimpleStreaming::SetNetwork), + InstanceAccessor("video", &osn::EnhancedBroadcastingSimpleStreaming::GetCanvas, &osn::EnhancedBroadcastingSimpleStreaming::SetCanvas), + InstanceAccessor("additionalVideo", &osn::EnhancedBroadcastingSimpleStreaming::GetAdditionalCanvas, + &osn::EnhancedBroadcastingSimpleStreaming::SetAdditionalCanvas), + InstanceAccessor("droppedFrames", &osn::EnhancedBroadcastingSimpleStreaming::GetDroppedFrames, nullptr), + InstanceAccessor("totalFrames", &osn::EnhancedBroadcastingSimpleStreaming::GetTotalFrames, nullptr), + InstanceAccessor("kbitsPerSec", &osn::EnhancedBroadcastingSimpleStreaming::GetKBitsPerSec, nullptr), + InstanceAccessor("dataOutput", &osn::EnhancedBroadcastingSimpleStreaming::GetDataOutput, nullptr), + + InstanceMethod("start", &osn::EnhancedBroadcastingSimpleStreaming::Start), + InstanceMethod("stop", &osn::EnhancedBroadcastingSimpleStreaming::Stop), + + StaticAccessor("legacySettings", &osn::EnhancedBroadcastingSimpleStreaming::GetLegacySettings, + &osn::EnhancedBroadcastingSimpleStreaming::SetLegacySettings)}); + + exports.Set("EnhancedBroadcastingSimpleStreaming", func); + osn::EnhancedBroadcastingSimpleStreaming::constructor = Napi::Persistent(func); + osn::EnhancedBroadcastingSimpleStreaming::constructor.SuppressDestruct(); + + return exports; +} + +osn::EnhancedBroadcastingSimpleStreaming::EnhancedBroadcastingSimpleStreaming(const Napi::CallbackInfo &info) + : Napi::ObjectWrap(info) +{ + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + size_t length = info.Length(); + + if (length <= 0 || !info[0].IsNumber()) { + Napi::TypeError::New(env, "Number expected").ThrowAsJavaScriptException(); + return; + } + + this->uid = (uint64_t)info[0].ToNumber().Int64Value(); + this->className = std::string("EnhancedBroadcastingSimpleStreaming"); +} + +Napi::Value osn::EnhancedBroadcastingSimpleStreaming::Create(const Napi::CallbackInfo &info) +{ + auto conn = GetConnection(info); + if (!conn) + return info.Env().Undefined(); + + std::vector response = conn->call_synchronous_helper("EnhancedBroadcastingSimpleStreaming", "Create", {}); + + if (!ValidateResponse(info, response)) + return info.Env().Undefined(); + + auto instance = + osn::EnhancedBroadcastingSimpleStreaming::constructor.New({Napi::Number::New(info.Env(), static_cast(response[1].value_union.ui64))}); + + return instance; +} + +void osn::EnhancedBroadcastingSimpleStreaming::Destroy(const Napi::CallbackInfo &info) +{ + if (info.Length() != 1) + return; + + auto stream = Napi::ObjectWrap::Unwrap(info[0].ToObject()); + + stream->stopWorker(); + stream->cb.Reset(); + + auto conn = GetConnection(info); + if (!conn) + return; + + std::vector response = conn->call_synchronous_helper("EnhancedBroadcastingSimpleStreaming", "Destroy", {ipc::value(stream->uid)}); + + if (!ValidateResponse(info, response)) + return; +} + +Napi::Value osn::EnhancedBroadcastingSimpleStreaming::GetAdditionalCanvas(const Napi::CallbackInfo &info) +{ + auto conn = GetConnection(info); + if (!conn) + return info.Env().Undefined(); + + std::vector response = conn->call_synchronous_helper(className, "GetAdditionalVideoCanvas", {ipc::value(this->uid)}); + + if (!ValidateResponse(info, response)) + return info.Env().Undefined(); + + auto instance = osn::Video::constructor.New({Napi::Number::New(info.Env(), static_cast(response[1].value_union.ui64))}); + + return instance; +} + +void osn::EnhancedBroadcastingSimpleStreaming::SetAdditionalCanvas(const Napi::CallbackInfo &info, const Napi::Value &value) +{ + osn::Video *canvas = Napi::ObjectWrap::Unwrap(value.ToObject()); + + if (!canvas) { + Napi::TypeError::New(info.Env(), "Invalid canvas argument").ThrowAsJavaScriptException(); + return; + } + + auto conn = GetConnection(info); + if (!conn) + return; + + conn->call(className, "SetAdditionalVideoCanvas", {ipc::value(this->uid), ipc::value(canvas->canvasId)}); +} + +Napi::Value osn::EnhancedBroadcastingSimpleStreaming::GetLegacySettings(const Napi::CallbackInfo &info) +{ + auto conn = GetConnection(info); + if (!conn) + return info.Env().Undefined(); + + std::vector response = conn->call_synchronous_helper("EnhancedBroadcastingSimpleStreaming", "GetLegacySettings", {}); + + if (!ValidateResponse(info, response)) + return info.Env().Undefined(); + + auto instance = + osn::EnhancedBroadcastingSimpleStreaming::constructor.New({Napi::Number::New(info.Env(), static_cast(response[1].value_union.ui64))}); + + return instance; +} + +void osn::EnhancedBroadcastingSimpleStreaming::SetLegacySettings(const Napi::CallbackInfo &info, const Napi::Value &value) +{ + osn::EnhancedBroadcastingSimpleStreaming *streaming = Napi::ObjectWrap::Unwrap(value.ToObject()); + + if (!streaming) { + Napi::TypeError::New(info.Env(), "Invalid service argument").ThrowAsJavaScriptException(); + return; + } + + auto conn = GetConnection(info); + if (!conn) + return; + + std::vector response = conn->call_synchronous_helper("EnhancedBroadcastingSimpleStreaming", "SetLegacySettings", {streaming->uid}); + + if (!ValidateResponse(info, response)) + return; +} \ No newline at end of file diff --git a/obs-studio-client/source/enhanced-broadcasting-simple-streaming.hpp b/obs-studio-client/source/enhanced-broadcasting-simple-streaming.hpp new file mode 100644 index 000000000..00b60d49b --- /dev/null +++ b/obs-studio-client/source/enhanced-broadcasting-simple-streaming.hpp @@ -0,0 +1,39 @@ +/****************************************************************************** + Copyright (C) 2016-2022 by Streamlabs (General Workings Inc) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +******************************************************************************/ + +#pragma once +#include +#include "simple-streaming.hpp" + +namespace osn { +class EnhancedBroadcastingSimpleStreaming : public Napi::ObjectWrap, public osn::SimpleStreamingBase { +public: + static Napi::FunctionReference constructor; + static Napi::Object Init(Napi::Env env, Napi::Object exports); + EnhancedBroadcastingSimpleStreaming(const Napi::CallbackInfo &info); + + static Napi::Value Create(const Napi::CallbackInfo &info); + static void Destroy(const Napi::CallbackInfo &info); + + Napi::Value GetAdditionalCanvas(const Napi::CallbackInfo &info); + void SetAdditionalCanvas(const Napi::CallbackInfo &info, const Napi::Value &value); + + static Napi::Value GetLegacySettings(const Napi::CallbackInfo &info); + static void SetLegacySettings(const Napi::CallbackInfo &info, const Napi::Value &value); +}; +} \ No newline at end of file diff --git a/obs-studio-client/source/main.cpp b/obs-studio-client/source/main.cpp index 132f8efac..5b439f5ca 100644 --- a/obs-studio-client/source/main.cpp +++ b/obs-studio-client/source/main.cpp @@ -54,6 +54,8 @@ #include "advanced-recording.hpp" #include "simple-replay-buffer.hpp" #include "advanced-replay-buffer.hpp" +#include "enhanced-broadcasting-advanced-streaming.hpp" +#include "enhanced-broadcasting-simple-streaming.hpp" #if defined(_WIN32) // Checks ForceGPUAsRenderDevice setting @@ -138,6 +140,8 @@ Napi::Object main_node(Napi::Env env, Napi::Object exports) osn::AdvancedRecording::Init(env, exports); osn::SimpleReplayBuffer::Init(env, exports); osn::AdvancedReplayBuffer::Init(env, exports); + osn::EnhancedBroadcastingAdvancedStreaming::Init(env, exports); + osn::EnhancedBroadcastingSimpleStreaming::Init(env, exports); return exports; }; diff --git a/obs-studio-client/source/simple-streaming-base.cpp b/obs-studio-client/source/simple-streaming-base.cpp new file mode 100644 index 000000000..4e9aef8ae --- /dev/null +++ b/obs-studio-client/source/simple-streaming-base.cpp @@ -0,0 +1,98 @@ +/****************************************************************************** + Copyright (C) 2016-2022 by Streamlabs (General Workings Inc) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +******************************************************************************/ + +#include "simple-streaming-base.hpp" + +#include "audio-encoder.hpp" + +Napi::Value osn::SimpleStreamingBase::GetAudioEncoder(const Napi::CallbackInfo &info) +{ + auto conn = GetConnection(info); + if (!conn) + return info.Env().Undefined(); + + std::vector response = conn->call_synchronous_helper("SimpleStreaming", "GetAudioEncoder", {ipc::value(this->uid)}); + + if (!ValidateResponse(info, response)) + return info.Env().Undefined(); + + auto instance = osn::AudioEncoder::constructor.New({Napi::Number::New(info.Env(), static_cast(response[1].value_union.ui64))}); + return instance; +} + +Napi::Value osn::SimpleStreamingBase::GetUseAdvanced(const Napi::CallbackInfo &info) +{ + auto conn = GetConnection(info); + if (!conn) + return info.Env().Undefined(); + + std::vector response = conn->call_synchronous_helper("SimpleStreaming", "GetUseAdvanced", {ipc::value(this->uid)}); + + if (!ValidateResponse(info, response)) + return info.Env().Undefined(); + + return Napi::Boolean::New(info.Env(), response[1].value_union.ui32); +} + +void osn::SimpleStreamingBase::SetUseAdvanced(const Napi::CallbackInfo &info, const Napi::Value &value) +{ + auto conn = GetConnection(info); + if (!conn) + return; + + conn->call_synchronous_helper("SimpleStreaming", "SetUseAdvanced", {ipc::value(this->uid), ipc::value(value.ToBoolean().Value())}); +} + +Napi::Value osn::SimpleStreamingBase::GetCustomEncSettings(const Napi::CallbackInfo &info) +{ + auto conn = GetConnection(info); + if (!conn) + return info.Env().Undefined(); + + std::vector response = conn->call_synchronous_helper("SimpleStreaming", "GetCustomEncSettings", {ipc::value(this->uid)}); + + if (!ValidateResponse(info, response)) + return info.Env().Undefined(); + + return Napi::String::New(info.Env(), response[1].value_str.c_str()); +} + +void osn::SimpleStreamingBase::SetCustomEncSettings(const Napi::CallbackInfo &info, const Napi::Value &value) +{ + auto conn = GetConnection(info); + if (!conn) + return; + + conn->call_synchronous_helper("SimpleStreaming", "SetCustomEncSettings", {ipc::value(this->uid), ipc::value(value.ToString().Utf8Value())}); +} + +void osn::SimpleStreamingBase::SetAudioEncoder(const Napi::CallbackInfo &info, const Napi::Value &value) +{ + osn::AudioEncoder *encoder = Napi::ObjectWrap::Unwrap(value.ToObject()); + + if (!encoder) { + Napi::TypeError::New(info.Env(), "Invalid encoder argument").ThrowAsJavaScriptException(); + return; + } + + auto conn = GetConnection(info); + if (!conn) + return; + + conn->call(className, "SetAudioEncoder", {ipc::value(this->uid), ipc::value(encoder->uid)}); +} diff --git a/obs-studio-server/source/osn-output-signals.hpp b/obs-studio-client/source/simple-streaming-base.hpp similarity index 56% rename from obs-studio-server/source/osn-output-signals.hpp rename to obs-studio-client/source/simple-streaming-base.hpp index 50da406ed..b92a38463 100644 --- a/obs-studio-server/source/osn-output-signals.hpp +++ b/obs-studio-client/source/simple-streaming-base.hpp @@ -17,46 +17,19 @@ ******************************************************************************/ #pragma once -#include -#include -#include -#include +#include +#include "streaming.hpp" namespace osn { -struct signalInfo { - std::string signal; - int code; - std::string errorMessage; -}; - -class OutputSignals { -public: - OutputSignals() - { - output = nullptr; - canvas = nullptr; - } - virtual ~OutputSignals() {} +class SimpleStreamingBase : public osn::Streaming { public: - std::mutex signalsMtx; - std::queue signalsReceived; - std::vector signals; - obs_output_t *output; - obs_video_info *canvas; - - void ConnectSignals(); - -public: - std::condition_variable cvStop; - std::mutex mtxOutputStop; - void createOutput(const std::string &type, const std::string &name); - void deleteOutput(); - void startOutput(); + Napi::Value GetAudioEncoder(const Napi::CallbackInfo &info); + void SetAudioEncoder(const Napi::CallbackInfo &info, const Napi::Value &value); + Napi::Value GetUseAdvanced(const Napi::CallbackInfo &info); + void SetUseAdvanced(const Napi::CallbackInfo &info, const Napi::Value &value); + Napi::Value GetCustomEncSettings(const Napi::CallbackInfo &info); + void SetCustomEncSettings(const Napi::CallbackInfo &info, const Napi::Value &value); }; -struct cbData { - std::string signal; - OutputSignals *outputClass; -}; -} +} \ No newline at end of file diff --git a/obs-studio-client/source/simple-streaming.cpp b/obs-studio-client/source/simple-streaming.cpp index 8c3e56246..7f5edc455 100644 --- a/obs-studio-client/source/simple-streaming.cpp +++ b/obs-studio-client/source/simple-streaming.cpp @@ -115,83 +115,6 @@ void osn::SimpleStreaming::Destroy(const Napi::CallbackInfo &info) return; } -Napi::Value osn::SimpleStreaming::GetAudioEncoder(const Napi::CallbackInfo &info) -{ - auto conn = GetConnection(info); - if (!conn) - return info.Env().Undefined(); - - std::vector response = conn->call_synchronous_helper("SimpleStreaming", "GetAudioEncoder", {ipc::value(this->uid)}); - - if (!ValidateResponse(info, response)) - return info.Env().Undefined(); - - auto instance = osn::AudioEncoder::constructor.New({Napi::Number::New(info.Env(), static_cast(response[1].value_union.ui64))}); - return instance; -} - -Napi::Value osn::SimpleStreaming::GetUseAdvanced(const Napi::CallbackInfo &info) -{ - auto conn = GetConnection(info); - if (!conn) - return info.Env().Undefined(); - - std::vector response = conn->call_synchronous_helper("SimpleStreaming", "GetUseAdvanced", {ipc::value(this->uid)}); - - if (!ValidateResponse(info, response)) - return info.Env().Undefined(); - - return Napi::Boolean::New(info.Env(), response[1].value_union.ui32); -} - -void osn::SimpleStreaming::SetUseAdvanced(const Napi::CallbackInfo &info, const Napi::Value &value) -{ - auto conn = GetConnection(info); - if (!conn) - return; - - conn->call_synchronous_helper("SimpleStreaming", "SetUseAdvanced", {ipc::value(this->uid), ipc::value(value.ToBoolean().Value())}); -} - -Napi::Value osn::SimpleStreaming::GetCustomEncSettings(const Napi::CallbackInfo &info) -{ - auto conn = GetConnection(info); - if (!conn) - return info.Env().Undefined(); - - std::vector response = conn->call_synchronous_helper("SimpleStreaming", "GetCustomEncSettings", {ipc::value(this->uid)}); - - if (!ValidateResponse(info, response)) - return info.Env().Undefined(); - - return Napi::String::New(info.Env(), response[1].value_str.c_str()); -} - -void osn::SimpleStreaming::SetCustomEncSettings(const Napi::CallbackInfo &info, const Napi::Value &value) -{ - auto conn = GetConnection(info); - if (!conn) - return; - - conn->call_synchronous_helper("SimpleStreaming", "SetCustomEncSettings", {ipc::value(this->uid), ipc::value(value.ToString().Utf8Value())}); -} - -void osn::SimpleStreaming::SetAudioEncoder(const Napi::CallbackInfo &info, const Napi::Value &value) -{ - osn::AudioEncoder *encoder = Napi::ObjectWrap::Unwrap(value.ToObject()); - - if (!encoder) { - Napi::TypeError::New(info.Env(), "Invalid encoder argument").ThrowAsJavaScriptException(); - return; - } - - auto conn = GetConnection(info); - if (!conn) - return; - - conn->call(className, "SetAudioEncoder", {ipc::value(this->uid), ipc::value(encoder->uid)}); -} - Napi::Value osn::SimpleStreaming::GetLegacySettings(const Napi::CallbackInfo &info) { auto conn = GetConnection(info); diff --git a/obs-studio-client/source/simple-streaming.hpp b/obs-studio-client/source/simple-streaming.hpp index 95edee1ab..a94bd5861 100644 --- a/obs-studio-client/source/simple-streaming.hpp +++ b/obs-studio-client/source/simple-streaming.hpp @@ -18,10 +18,11 @@ #pragma once #include -#include "streaming.hpp" +#include "simple-streaming-base.hpp" namespace osn { -class SimpleStreaming : public Napi::ObjectWrap, public osn::Streaming { + +class SimpleStreaming : public Napi::ObjectWrap, public SimpleStreamingBase { public: static Napi::FunctionReference constructor; static Napi::Object Init(Napi::Env env, Napi::Object exports); @@ -30,13 +31,6 @@ class SimpleStreaming : public Napi::ObjectWrap, public os static Napi::Value Create(const Napi::CallbackInfo &info); static void Destroy(const Napi::CallbackInfo &info); - Napi::Value GetAudioEncoder(const Napi::CallbackInfo &info); - void SetAudioEncoder(const Napi::CallbackInfo &info, const Napi::Value &value); - Napi::Value GetUseAdvanced(const Napi::CallbackInfo &info); - void SetUseAdvanced(const Napi::CallbackInfo &info, const Napi::Value &value); - Napi::Value GetCustomEncSettings(const Napi::CallbackInfo &info); - void SetCustomEncSettings(const Napi::CallbackInfo &info, const Napi::Value &value); - static Napi::Value GetLegacySettings(const Napi::CallbackInfo &info); static void SetLegacySettings(const Napi::CallbackInfo &info, const Napi::Value &value); }; diff --git a/obs-studio-client/source/streaming.cpp b/obs-studio-client/source/streaming.cpp index c51b906a6..86c6c482b 100644 --- a/obs-studio-client/source/streaming.cpp +++ b/obs-studio-client/source/streaming.cpp @@ -290,7 +290,8 @@ void osn::Streaming::Start(const Napi::CallbackInfo &info) startWorker(info.Env(), this->cb.Value(), className, this->uid); - conn->call(className, "Start", {ipc::value(this->uid)}); + std::vector response = conn->call_synchronous_helper(className, "Start", {ipc::value(this->uid)}); + ValidateResponse(info, response); } void osn::Streaming::Stop(const Napi::CallbackInfo &info) diff --git a/obs-studio-server/CMakeLists.txt b/obs-studio-server/CMakeLists.txt index 3f91439fc..9399093c8 100644 --- a/obs-studio-server/CMakeLists.txt +++ b/obs-studio-server/CMakeLists.txt @@ -292,9 +292,11 @@ SET(osn-server_SOURCES "${PROJECT_SOURCE_DIR}/source/osn-multitrack-video-data-model.hpp" "${PROJECT_SOURCE_DIR}/source/osn-multitrack-video-output.cpp" "${PROJECT_SOURCE_DIR}/source/osn-multitrack-video-output.hpp" + "${PROJECT_SOURCE_DIR}/source/osn-multitrack-video-system-info.hpp" + "${PROJECT_SOURCE_DIR}/source/osn-multitrack-video.cpp" + "${PROJECT_SOURCE_DIR}/source/osn-multitrack-video.hpp" "${PROJECT_SOURCE_DIR}/source/osn-audio-bitrate.cpp" "${PROJECT_SOURCE_DIR}/source/osn-audio-bitrate.hpp" - "${PROJECT_SOURCE_DIR}/source/osn-multitrack-video-system-info.hpp" "${PROJECT_SOURCE_DIR}/source/osn-output.cpp" "${PROJECT_SOURCE_DIR}/source/osn-output.hpp" "${PROJECT_SOURCE_DIR}/source/osn-properties.cpp" @@ -321,6 +323,10 @@ SET(osn-server_SOURCES "${PROJECT_SOURCE_DIR}/source/osn-simple-streaming.hpp" "${PROJECT_SOURCE_DIR}/source/osn-advanced-streaming.cpp" "${PROJECT_SOURCE_DIR}/source/osn-advanced-streaming.hpp" + "${PROJECT_SOURCE_DIR}/source/osn-enhanced-broadcasting-advanced-streaming.cpp" + "${PROJECT_SOURCE_DIR}/source/osn-enhanced-broadcasting-advanced-streaming.hpp" + "${PROJECT_SOURCE_DIR}/source/osn-enhanced-broadcasting-simple-streaming.cpp" + "${PROJECT_SOURCE_DIR}/source/osn-enhanced-broadcasting-simple-streaming.hpp" "${PROJECT_SOURCE_DIR}/source/osn-delay.cpp" "${PROJECT_SOURCE_DIR}/source/osn-delay.hpp" "${PROJECT_SOURCE_DIR}/source/osn-reconnect.cpp" @@ -345,8 +351,6 @@ SET(osn-server_SOURCES "${PROJECT_SOURCE_DIR}/source/osn-file-output.hpp" "${PROJECT_SOURCE_DIR}/source/osn-advanced-replay-buffer.cpp" "${PROJECT_SOURCE_DIR}/source/osn-advanced-replay-buffer.hpp" - "${PROJECT_SOURCE_DIR}/source/osn-output-signals.cpp" - "${PROJECT_SOURCE_DIR}/source/osn-output-signals.hpp" ###### utlity graphics ###### "${PROJECT_SOURCE_DIR}/source/gs-limits.h" diff --git a/obs-studio-server/source/main.cpp b/obs-studio-server/source/main.cpp index 6e7f7b71b..52d02cbaf 100644 --- a/obs-studio-server/source/main.cpp +++ b/obs-studio-server/source/main.cpp @@ -61,6 +61,8 @@ #include "osn-simple-replay-buffer.hpp" #include "osn-advanced-replay-buffer.hpp" #include "osn-file-output.hpp" +#include "osn-enhanced-broadcasting-simple-streaming.hpp" +#include "osn-enhanced-broadcasting-advanced-streaming.hpp" #include "util-crashmanager.h" #include "shared.hpp" @@ -273,6 +275,8 @@ int main(int argc, char *argv[]) osn::ISimpleReplayBuffer::Register(myServer); osn::IAdvancedReplayBuffer::Register(myServer); osn::IFileOutput::Register(myServer); + osn::IEnhancedBroadcastingSimpleStreaming::Register(myServer); + osn::IEnhancedBroadcastingAdvancedStreaming::Register(myServer); OBS_API::CreateCrashHandlerExitPipe(); diff --git a/obs-studio-server/source/nodeobs_service.cpp b/obs-studio-server/source/nodeobs_service.cpp index cbab155e0..e1fa6779b 100644 --- a/obs-studio-server/source/nodeobs_service.cpp +++ b/obs-studio-server/source/nodeobs_service.cpp @@ -28,9 +28,7 @@ #include #include "osn-vcam.hpp" -#include "osn-multitrack-video-configuration.hpp" -#include "osn-audio-bitrate.hpp" -#include "osn-multitrack-video-output.hpp" +#include "osn-multitrack-video.hpp" #ifdef __APPLE__ #include @@ -92,13 +90,7 @@ std::mutex signalMutex; std::queue outputSignal; std::thread releaseWorker; -struct EnhancedBroadcastOutputObjects { - OBSOutputAutoRelease obsOutput; - std::shared_ptr videoEncoderGroup; - std::vector audioEncoders; - OBSServiceAutoRelease multitrackVideoService; -}; -static std::optional enhancedBroadcastContext; +static std::optional enhancedBroadcastContext; OBS_service::OBS_service() {} OBS_service::~OBS_service() {} @@ -1266,18 +1258,6 @@ const char *OBS_service::getStreamOutputType(const obs_service_t *service) return nullptr; } -static int GetAudioBitrate() -{ - const char *audio_encoder_id = config_get_string(ConfigManager::getInstance().getBasic(), "SimpleOutput", "StreamAudioEncoder"); - - const int bitrate = (int)config_get_uint(ConfigManager::getInstance().getBasic(), "SimpleOutput", "ABitrate"); - - if (audio_encoder_id && strcmp(audio_encoder_id, "opus") == 0) - return osn::FindClosestAvailableSimpleOpusBitrate(bitrate); - - return osn::FindClosestAvailableSimpleAACBitrate(bitrate); -} - static inline bool ServiceSupportsVodTrack(const char *service) { static const char *vodTrackServices[] = {"Twitch"}; @@ -1307,11 +1287,6 @@ static bool IsVodTrackEnabled(obs_service_t *service) return vodTrackEnabledAdv && ServiceSupportsVodTrack(name); } -static bool IsMultitrackVideoEnabled() -{ - return config_get_bool(ConfigManager::getInstance().getBasic(), "EnhancedBroadcasting", "EnableMultitrackVideo"); -} - bool OBS_service::startSingleTrackStreaming(StreamServiceId serviceId) { const char *type = getStreamOutputType(services[serviceId]); @@ -1398,13 +1373,23 @@ bool OBS_service::startMultiTrackStreaming(StreamServiceId serviceId, bool dualS auto vod_track_mixer = IsVodTrackEnabled(services[serviceId]) ? std::optional{vodTrackIndex} : std::nullopt; - auto go_live_post = osn::constructGoLivePost(serviceId, dualStreamingMode, key, std::nullopt, std::nullopt, vod_track_mixer.has_value()); + std::vector canvases; + canvases.push_back(videoInfo[serviceId]); + if (dualStreamingMode) { + if (serviceId == StreamServiceId::Main) { + canvases.push_back(videoInfo[StreamServiceId::Second]); + } else if (serviceId == StreamServiceId::Second) { + canvases.push_back(videoInfo[StreamServiceId::Main]); + } + } + + auto go_live_post = osn::constructGoLivePost(canvases, key, std::nullopt, std::nullopt, vod_track_mixer.has_value()); std::optional go_live_config = osn::DownloadGoLiveConfig(auto_config_url, go_live_post); if (!go_live_config.has_value()) { throw std::runtime_error("startStreaming - go live config is empty"); } - const auto audio_bitrate = GetAudioBitrate(); + const auto audio_bitrate = osn::GetMultitrackAudioBitrate(); const auto audio_encoder_id = osn::GetSimpleAACEncoderForBitrate(audio_bitrate); std::vector audio_encoders; @@ -1429,7 +1414,7 @@ bool OBS_service::startMultiTrackStreaming(StreamServiceId serviceId, bool dualS isStreaming[serviceId] = obs_output_start(output); - enhancedBroadcastContext.emplace(EnhancedBroadcastOutputObjects{ + enhancedBroadcastContext.emplace(osn::EnhancedBroadcastOutputObjects{ std::move(output), video_encoder_group, std::move(audio_encoders), @@ -1447,7 +1432,7 @@ bool OBS_service::startStreaming(StreamServiceId serviceId, bool dualStreamingMo } try { - if (isTwitchStream(serviceId) && (IsMultitrackVideoEnabled() || dualStreamingMode)) { + if (isTwitchStream(serviceId) && (osn::IsMultitrackVideoEnabled() || dualStreamingMode)) { return startMultiTrackStreaming(serviceId, dualStreamingMode); } @@ -1634,7 +1619,7 @@ bool OBS_service::updateRecordingEncoders(bool isSimpleMode, StreamServiceId ser bool simpleUsesStream = false; bool advancedUsesStream = false; - if (!IsMultitrackVideoEnabled()) { + if (!osn::IsMultitrackVideoEnabled()) { simpleUsesStream = isSimpleMode && simpleQuality.compare("Stream") == 0; advancedUsesStream = !isSimpleMode && (advancedQuality.compare("") == 0 || advancedQuality.compare("none") == 0); } @@ -1766,7 +1751,7 @@ void OBS_service::stopStreaming(bool forceStop, StreamServiceId serviceId) obs_output_stop(streamingOutput[serviceId]); /* Unregister the BPM (Broadcast Performance Metrics) callback and destroy the allocated metrics data. */ - if (isTwitchStream(serviceId) && IsMultitrackVideoEnabled()) { + if (isTwitchStream(serviceId) && osn::IsMultitrackVideoEnabled()) { obs_output_remove_packet_callback(streamingOutput[serviceId], bpm_inject, NULL); bpm_destroy(streamingOutput[serviceId]); } diff --git a/obs-studio-server/source/osn-advanced-recording.cpp b/obs-studio-server/source/osn-advanced-recording.cpp index a4a949849..beb1d3f6b 100644 --- a/obs-studio-server/source/osn-advanced-recording.cpp +++ b/obs-studio-server/source/osn-advanced-recording.cpp @@ -186,9 +186,9 @@ bool osn::AdvancedRecording::UpdateEncoders() return false; if (obs_get_multiple_rendering()) { - obs_encoder_set_video_mix(videoEncoder, obs_video_mix_get(canvas, OBS_RECORDING_VIDEO_RENDERING)); + obs_encoder_set_video_mix(videoEncoder, obs_video_mix_get(this->GetCanvas(), OBS_RECORDING_VIDEO_RENDERING)); } else { - obs_encoder_set_video_mix(videoEncoder, obs_video_mix_get(canvas, OBS_MAIN_VIDEO_RENDERING)); + obs_encoder_set_video_mix(videoEncoder, obs_video_mix_get(this->GetCanvas(), OBS_MAIN_VIDEO_RENDERING)); } return true; @@ -201,10 +201,10 @@ void osn::IAdvancedRecording::Start(void *data, const int64_t id, const std::vec PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Simple recording reference is not valid."); } - if (!recording->output) - recording->createOutput("ffmpeg_muxer", "recording"); + if (!recording->GetOutput()) + recording->CreateOutput("ffmpeg_muxer", "recording"); - if (!recording->output) { + if (!recording->GetOutput()) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Error while creating the recording output."); } @@ -213,9 +213,9 @@ void osn::IAdvancedRecording::Start(void *data, const int64_t id, const std::vec osn::AudioTrack *audioTrack = osn::IAudioTrack::audioTracks[i]; if ((recording->mixer & (1 << i)) != 0 && audioTrack && audioTrack->audioEnc) { obs_encoder_set_audio(audioTrack->audioEnc, obs_get_audio()); - obs_output_set_audio_encoder(recording->output, audioTrack->audioEnc, idx); + obs_output_set_audio_encoder(recording->GetOutput(), audioTrack->audioEnc, idx); - obs_encoder_set_video_mix(audioTrack->audioEnc, obs_video_mix_get(recording->canvas, OBS_RECORDING_VIDEO_RENDERING)); + obs_encoder_set_video_mix(audioTrack->audioEnc, obs_video_mix_get(recording->GetCanvas(), OBS_RECORDING_VIDEO_RENDERING)); idx++; } } @@ -224,7 +224,7 @@ void osn::IAdvancedRecording::Start(void *data, const int64_t id, const std::vec PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid video encoder."); } - obs_output_set_video_encoder(recording->output, recording->videoEncoder); + obs_output_set_video_encoder(recording->GetOutput(), recording->videoEncoder); std::string path = recording->path; @@ -232,8 +232,8 @@ void osn::IAdvancedRecording::Start(void *data, const int64_t id, const std::vec if (lastChar != '/' && lastChar != '\\') path += "/"; - path += GenerateSpecifiedFilename(recording->format, recording->noSpace, recording->fileFormat, recording->canvas->base_width, - recording->canvas->base_height); + path += GenerateSpecifiedFilename(recording->format, recording->noSpace, recording->fileFormat, recording->GetCanvas()->base_width, + recording->GetCanvas()->base_height); if (!recording->overwrite) FindBestFilename(path, recording->noSpace); @@ -241,13 +241,13 @@ void osn::IAdvancedRecording::Start(void *data, const int64_t id, const std::vec obs_data_t *settings = obs_data_create(); obs_data_set_string(settings, "path", path.c_str()); obs_data_set_string(settings, "muxer_settings", recording->muxerSettings.c_str()); - obs_output_update(recording->output, settings); + obs_output_update(recording->GetOutput(), settings); obs_data_release(settings); if (recording->enableFileSplit) recording->ConfigureRecFileSplitting(); - recording->startOutput(); + recording->StartOutput(); rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); AUTO_DEBUG; @@ -260,7 +260,7 @@ void osn::IAdvancedRecording::Stop(void *data, const int64_t id, const std::vect PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Simple recording reference is not valid."); } - obs_output_stop(recording->output); + obs_output_stop(recording->GetOutput()); rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); AUTO_DEBUG; diff --git a/obs-studio-server/source/osn-advanced-replay-buffer.cpp b/obs-studio-server/source/osn-advanced-replay-buffer.cpp index 1d8a7ee5d..79439f2ea 100644 --- a/obs-studio-server/source/osn-advanced-replay-buffer.cpp +++ b/obs-studio-server/source/osn-advanced-replay-buffer.cpp @@ -123,15 +123,15 @@ void osn::IAdvancedReplayBuffer::Start(void *data, const int64_t id, const std:: PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Simple replay buffer reference is not valid."); } - if (!replayBuffer->output) - replayBuffer->createOutput("replay_buffer", "replay-buffer"); + if (!replayBuffer->GetOutput()) + replayBuffer->CreateOutput("replay_buffer", "replay-buffer"); int idx = 0; for (int i = 0; i < MAX_AUDIO_MIXES; i++) { osn::AudioTrack *audioTrack = osn::IAudioTrack::audioTracks[i]; if ((replayBuffer->mixer & (1 << i)) != 0 && audioTrack && audioTrack->audioEnc) { obs_encoder_set_audio(audioTrack->audioEnc, obs_get_audio()); - obs_output_set_audio_encoder(replayBuffer->output, audioTrack->audioEnc, idx); + obs_output_set_audio_encoder(replayBuffer->GetOutput(), audioTrack->audioEnc, idx); idx++; } } @@ -154,7 +154,7 @@ void osn::IAdvancedReplayBuffer::Start(void *data, const int64_t id, const std:: PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid video encoder."); } - obs_output_set_video_encoder(replayBuffer->output, videoEncoder); + obs_output_set_video_encoder(replayBuffer->GetOutput(), videoEncoder); if (!replayBuffer->path.size()) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid recording path."); @@ -185,10 +185,10 @@ void osn::IAdvancedReplayBuffer::Start(void *data, const int64_t id, const std:: obs_data_set_bool(settings, "allow_spaces", !replayBuffer->noSpace); obs_data_set_int(settings, "max_time_sec", replayBuffer->duration); obs_data_set_int(settings, "max_size_mb", rbSize); - obs_output_update(replayBuffer->output, settings); + obs_output_update(replayBuffer->GetOutput(), settings); obs_data_release(settings); - replayBuffer->startOutput(); + replayBuffer->StartOutput(); rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); AUTO_DEBUG; @@ -200,11 +200,11 @@ void osn::IAdvancedReplayBuffer::Stop(void *data, const int64_t id, const std::v if (!replayBuffer) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Simple replay buffer reference is not valid."); } - if (!replayBuffer->output) { + if (!replayBuffer->GetOutput()) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid replay buffer output."); } - obs_output_stop(replayBuffer->output); + obs_output_stop(replayBuffer->GetOutput()); rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); AUTO_DEBUG; diff --git a/obs-studio-server/source/osn-advanced-streaming.cpp b/obs-studio-server/source/osn-advanced-streaming.cpp index 265ac9d49..e01fc209d 100644 --- a/obs-studio-server/source/osn-advanced-streaming.cpp +++ b/obs-studio-server/source/osn-advanced-streaming.cpp @@ -241,8 +241,8 @@ static bool setAudioEncoder(osn::AdvancedStreaming *streaming) return false; obs_encoder_set_audio(audioTrack->audioEnc, obs_get_audio()); - obs_output_set_audio_encoder(streaming->output, audioTrack->audioEnc, 0); - obs_encoder_set_video_mix(audioTrack->audioEnc, obs_video_mix_get(streaming->canvas, OBS_STREAMING_VIDEO_RENDERING)); + obs_output_set_audio_encoder(streaming->GetOutput(), audioTrack->audioEnc, 0); + obs_encoder_set_video_mix(audioTrack->audioEnc, obs_video_mix_get(streaming->GetCanvas(), OBS_STREAMING_VIDEO_RENDERING)); return true; } @@ -289,8 +289,8 @@ static void SetupTwitchSoundtrackAudio(osn::AdvancedStreaming *streaming) obs_encoder_set_audio(streaming->streamArchive, obs_get_audio()); } - obs_output_set_audio_encoder(streaming->output, streaming->streamArchive, kSoundtrackArchiveEncoderIdx); - obs_encoder_set_video_mix(streaming->streamArchive, obs_video_mix_get(streaming->canvas, OBS_STREAMING_VIDEO_RENDERING)); + obs_output_set_audio_encoder(streaming->GetOutput(), streaming->streamArchive, kSoundtrackArchiveEncoderIdx); + obs_encoder_set_video_mix(streaming->streamArchive, obs_video_mix_get(streaming->GetCanvas(), OBS_STREAMING_VIDEO_RENDERING)); osn::AudioTrack *audioTrack = osn::IAudioTrack::audioTracks[streaming->twitchTrack]; if (!audioTrack) @@ -356,9 +356,9 @@ void osn::AdvancedStreaming::UpdateEncoders() obs_data_release(settings); if (obs_get_multiple_rendering()) { - obs_encoder_set_video_mix(videoEncoder, obs_video_mix_get(canvas, OBS_STREAMING_VIDEO_RENDERING)); + obs_encoder_set_video_mix(videoEncoder, obs_video_mix_get(this->GetCanvas(), OBS_STREAMING_VIDEO_RENDERING)); } else { - obs_encoder_set_video_mix(videoEncoder, obs_video_mix_get(canvas, OBS_MAIN_VIDEO_RENDERING)); + obs_encoder_set_video_mix(videoEncoder, obs_video_mix_get(this->GetCanvas(), OBS_MAIN_VIDEO_RENDERING)); } } @@ -366,34 +366,34 @@ void osn::IAdvancedStreaming::Start(void *data, const int64_t id, const std::vec { AdvancedStreaming *streaming = static_cast(osn::IAdvancedStreaming::Manager::GetInstance().find(args[0].value_union.ui64)); if (!streaming) { - PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Simple streaming reference is not valid."); + PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Advanced streaming reference is not valid."); + } + + if (!streaming->service) { + PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid service."); } if (!streaming->videoEncoder) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid video encoder."); } - streaming->UpdateEncoders(); - - if (!streaming->service) { - PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid service."); + if (!streaming->GetCanvas()) { + PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid main canvas."); } + streaming->UpdateEncoders(); + const char *type = OBS_service::getStreamOutputType(streaming->service); if (!type) type = "rtmp_output"; - if (!streaming->output || strcmp(obs_output_get_id(streaming->output), type) != 0) - streaming->createOutput(type, "stream"); + if (!streaming->GetOutput() || strcmp(obs_output_get_id(streaming->GetOutput()), type) != 0) + streaming->CreateOutput(type, "stream"); - if (!streaming->output) { + if (!streaming->GetOutput()) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Error while creating the streaming output."); } - if (!streaming->videoEncoder) { - PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Error while creating the video encoder."); - } - if (!setAudioEncoder(streaming)) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Error while creating the audio encoder."); } @@ -401,7 +401,7 @@ void osn::IAdvancedStreaming::Start(void *data, const int64_t id, const std::vec if (streaming->rescaling) obs_encoder_set_scaled_size(streaming->videoEncoder, streaming->outputWidth, streaming->outputHeight); - obs_output_set_video_encoder(streaming->output, streaming->videoEncoder); + obs_output_set_video_encoder(streaming->GetOutput(), streaming->videoEncoder); if (streaming->enableTwitchVOD) { streaming->twitchVODSupported = streaming->isTwitchVODSupported(); @@ -409,19 +409,19 @@ void osn::IAdvancedStreaming::Start(void *data, const int64_t id, const std::vec SetupTwitchSoundtrackAudio(streaming); } - obs_output_set_service(streaming->output, streaming->service); + obs_output_set_service(streaming->GetOutput(), streaming->service); if (!streaming->delay) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid delay."); } - obs_output_set_delay(streaming->output, streaming->delay->enabled ? uint32_t(streaming->delay->delaySec) : 0, + obs_output_set_delay(streaming->GetOutput(), streaming->delay->enabled ? uint32_t(streaming->delay->delaySec) : 0, streaming->delay->preserveDelay ? OBS_OUTPUT_DELAY_PRESERVE : 0); if (!streaming->reconnect) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid reconnect."); } uint32_t maxReties = streaming->reconnect->enabled ? streaming->reconnect->maxRetries : 0; - obs_output_set_reconnect_settings(streaming->output, maxReties, streaming->reconnect->retryDelay); + obs_output_set_reconnect_settings(streaming->GetOutput(), maxReties, streaming->reconnect->retryDelay); if (!streaming->network) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid network."); @@ -432,10 +432,10 @@ void osn::IAdvancedStreaming::Start(void *data, const int64_t id, const std::vec obs_data_set_bool(settings, "dyn_bitrate", streaming->network->enableDynamicBitrate); obs_data_set_bool(settings, "new_socket_loop_enabled", streaming->network->enableOptimizations); obs_data_set_bool(settings, "low_latency_mode_enabled", streaming->network->enableLowLatency); - obs_output_update(streaming->output, settings); + obs_output_update(streaming->GetOutput(), settings); obs_data_release(settings); - streaming->startOutput(); + streaming->StartOutput(); rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); AUTO_DEBUG; @@ -443,21 +443,22 @@ void osn::IAdvancedStreaming::Start(void *data, const int64_t id, const std::vec void osn::IAdvancedStreaming::Stop(void *data, const int64_t id, const std::vector &args, std::vector &rval) { + blog(LOG_INFO, "IAdvancedStreaming::Stop"); Streaming *streaming = osn::IStreaming::Manager::GetInstance().find(args[0].value_union.ui64); if (!streaming) { - PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Simple streaming reference is not valid."); + PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Streaming reference is not valid."); } - if (!streaming->output) { + if (!streaming->GetOutput()) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid streaming output."); } bool force = args[1].value_union.ui32; if (force) - obs_output_force_stop(streaming->output); + obs_output_force_stop(streaming->GetOutput()); else - obs_output_stop(streaming->output); + obs_output_stop(streaming->GetOutput()); rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); AUTO_DEBUG; diff --git a/obs-studio-server/source/osn-enhanced-broadcasting-advanced-streaming.cpp b/obs-studio-server/source/osn-enhanced-broadcasting-advanced-streaming.cpp new file mode 100644 index 000000000..ec5e3e202 --- /dev/null +++ b/obs-studio-server/source/osn-enhanced-broadcasting-advanced-streaming.cpp @@ -0,0 +1,177 @@ +/****************************************************************************** + Copyright (C) 2016-2022 by Streamlabs (General Workings Inc) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +******************************************************************************/ + +#include "osn-enhanced-broadcasting-advanced-streaming.hpp" +#include "osn-video-encoder.hpp" +#include "osn-service.hpp" +#include "osn-error.hpp" +#include "shared.hpp" +#include "nodeobs_audio_encoders.h" +#include "osn-audio-track.hpp" +#include + +void osn::IEnhancedBroadcastingAdvancedStreaming::Register(ipc::server &srv) +{ + std::shared_ptr cls = std::make_shared("EnhancedBroadcastingAdvancedStreaming"); + cls->register_function(std::make_shared("Create", std::vector{}, Create)); + cls->register_function(std::make_shared("Destroy", std::vector{ipc::type::UInt64}, Destroy)); + cls->register_function(std::make_shared("GetService", std::vector{ipc::type::UInt64}, GetService)); + cls->register_function(std::make_shared("SetService", std::vector{ipc::type::UInt64, ipc::type::UInt64}, SetService)); + cls->register_function(std::make_shared("GetVideoEncoder", std::vector{ipc::type::UInt64}, GetVideoEncoder)); + cls->register_function( + std::make_shared("SetVideoEncoder", std::vector{ipc::type::UInt64, ipc::type::UInt64}, SetVideoEncoder)); + cls->register_function(std::make_shared("GetVideoCanvas", std::vector{ipc::type::UInt64}, GetVideoCanvas)); + cls->register_function(std::make_shared("SetVideoCanvas", std::vector{ipc::type::UInt64, ipc::type::UInt64}, SetVideoCanvas)); + cls->register_function(std::make_shared("GetEnforceServiceBirate", std::vector{ipc::type::UInt64}, GetEnforceServiceBirate)); + cls->register_function(std::make_shared("SetEnforceServiceBirate", std::vector{ipc::type::UInt64, ipc::type::UInt32}, + SetEnforceServiceBirate)); + cls->register_function(std::make_shared("GetEnableTwitchVOD", std::vector{ipc::type::UInt64}, GetEnableTwitchVOD)); + cls->register_function( + std::make_shared("SetEnableTwitchVOD", std::vector{ipc::type::UInt64, ipc::type::UInt32}, SetEnableTwitchVOD)); + cls->register_function(std::make_shared("GetAudioTrack", std::vector{ipc::type::UInt64}, GetAudioTrack)); + cls->register_function(std::make_shared("SetAudioTrack", std::vector{ipc::type::UInt64, ipc::type::UInt32}, SetAudioTrack)); + cls->register_function(std::make_shared("GetTwitchTrack", std::vector{ipc::type::UInt64}, GetTwitchTrack)); + cls->register_function(std::make_shared("SetTwitchTrack", std::vector{ipc::type::UInt64, ipc::type::UInt32}, SetTwitchTrack)); + cls->register_function(std::make_shared("GetRescaling", std::vector{ipc::type::UInt64}, GetRescaling)); + cls->register_function(std::make_shared("SetRescaling", std::vector{ipc::type::UInt64, ipc::type::UInt32}, SetRescaling)); + cls->register_function(std::make_shared("GetOutputWidth", std::vector{ipc::type::UInt64}, GetOutputWidth)); + cls->register_function(std::make_shared("SetOutputWidth", std::vector{ipc::type::UInt64, ipc::type::UInt32}, SetOutputWidth)); + cls->register_function(std::make_shared("GetOutputHeight", std::vector{ipc::type::UInt64}, GetOutputHeight)); + cls->register_function( + std::make_shared("SetOutputHeight", std::vector{ipc::type::UInt64, ipc::type::UInt32}, SetOutputHeight)); + cls->register_function(std::make_shared("GetDelay", std::vector{ipc::type::UInt64}, GetDelay)); + cls->register_function(std::make_shared("SetDelay", std::vector{ipc::type::UInt64, ipc::type::UInt64}, SetDelay)); + cls->register_function(std::make_shared("GetReconnect", std::vector{ipc::type::UInt64}, GetReconnect)); + cls->register_function(std::make_shared("SetReconnect", std::vector{ipc::type::UInt64, ipc::type::UInt64}, SetReconnect)); + cls->register_function(std::make_shared("GetNetwork", std::vector{ipc::type::UInt64}, GetNetwork)); + cls->register_function(std::make_shared("SetNetwork", std::vector{ipc::type::UInt64, ipc::type::UInt64}, SetNetwork)); + cls->register_function(std::make_shared("Start", std::vector{ipc::type::UInt64}, Start)); + cls->register_function(std::make_shared("Stop", std::vector{ipc::type::UInt64, ipc::type::UInt32}, Stop)); + cls->register_function(std::make_shared("Query", std::vector{ipc::type::UInt64}, Query)); + cls->register_function(std::make_shared("GetLegacySettings", std::vector{}, GetLegacySettings)); + cls->register_function(std::make_shared("SetLegacySettings", std::vector{ipc::type::UInt64}, SetLegacySettings)); + cls->register_function(std::make_shared("GetDroppedFrames", std::vector{ipc::type::UInt64}, GetDroppedFrames)); + cls->register_function(std::make_shared("GetTotalFrames", std::vector{ipc::type::UInt64}, GetTotalFrames)); + cls->register_function(std::make_shared("GetKBitsPerSec", std::vector{ipc::type::UInt64}, GetKBitsPerSec)); + cls->register_function(std::make_shared("GetDataOutput", std::vector{ipc::type::UInt64}, GetDataOutput)); + + cls->register_function( + std::make_shared("GetAdditionalVideoCanvas", std::vector{ipc::type::UInt64}, GetAdditionalVideoCanvas)); + cls->register_function(std::make_shared("SetAdditionalVideoCanvas", std::vector{ipc::type::UInt64, ipc::type::UInt64}, + SetAdditionalVideoCanvas)); + + srv.register_collection(cls); +} + +void osn::IEnhancedBroadcastingAdvancedStreaming::Create(void *data, const int64_t id, const std::vector &args, std::vector &rval) +{ + uint64_t uid = osn::IEnhancedBroadcastingAdvancedStreaming::Manager::GetInstance().allocate(new EnhancedBroadcastingAdvancedStreaming()); + if (uid == UINT64_MAX) { + PRETTY_ERROR_RETURN(ErrorCode::CriticalError, "Index list is full."); + } + + rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); + rval.push_back(ipc::value(uid)); + AUTO_DEBUG; +} + +void osn::IEnhancedBroadcastingAdvancedStreaming::Destroy(void *data, const int64_t id, const std::vector &args, std::vector &rval) +{ + EnhancedBroadcastingAdvancedStreaming *streaming = static_cast( + osn::IEnhancedBroadcastingAdvancedStreaming::Manager::GetInstance().find(args[0].value_union.ui64)); + if (!streaming) { + PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Streaming reference is not valid."); + } + + osn::IEnhancedBroadcastingAdvancedStreaming::Manager::GetInstance().free(streaming); + delete streaming; + + rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); + AUTO_DEBUG; +} + +void osn::IEnhancedBroadcastingAdvancedStreaming::Start(void *data, const int64_t id, const std::vector &args, std::vector &rval) +{ + EnhancedBroadcastingAdvancedStreaming *streaming = static_cast( + osn::IEnhancedBroadcastingAdvancedStreaming::Manager::GetInstance().find(args[0].value_union.ui64)); + if (!streaming) { + PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Streaming reference is not valid."); + } + + if (!streaming->service) { + PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid service."); + } + + auto vod_track_mixer = (streaming->twitchVODSupported && streaming->enableTwitchVOD) ? std::optional{streaming->twitchTrack} : std::nullopt; + streaming->StartEnhancedBroadcastingStream(vod_track_mixer); + + rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); + AUTO_DEBUG; +} + +void osn::IEnhancedBroadcastingAdvancedStreaming::Stop(void *data, const int64_t id, const std::vector &args, std::vector &rval) +{ + EnhancedBroadcastingAdvancedStreaming *streaming = static_cast( + osn::IEnhancedBroadcastingAdvancedStreaming::Manager::GetInstance().find(args[0].value_union.ui64)); + if (!streaming) { + PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Streaming reference is not valid."); + } + + streaming->StopEnhancedBroadcastingStream(); + + IAdvancedStreaming::Stop(data, id, args, rval); + + AUTO_DEBUG; +} + +void osn::IEnhancedBroadcastingAdvancedStreaming::GetAdditionalVideoCanvas(void *data, const int64_t id, const std::vector &args, + std::vector &rval) +{ + EnhancedBroadcastingAdvancedStreaming *streaming = static_cast( + osn::IEnhancedBroadcastingAdvancedStreaming::Manager::GetInstance().find(args[0].value_union.ui64)); + if (!streaming) { + PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Streaming reference is not valid."); + } + + const uint64_t uid = osn::Video::Manager::GetInstance().find(streaming->GetAdditionalVideoCanvas()); + + rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); + rval.push_back(ipc::value(uid)); + + AUTO_DEBUG; +} + +void osn::IEnhancedBroadcastingAdvancedStreaming::SetAdditionalVideoCanvas(void *data, const int64_t id, const std::vector &args, + std::vector &rval) +{ + EnhancedBroadcastingAdvancedStreaming *streaming = static_cast( + osn::IEnhancedBroadcastingAdvancedStreaming::Manager::GetInstance().find(args[0].value_union.ui64)); + if (!streaming) { + PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Streaming reference is not valid."); + } + + obs_video_info *canvas = osn::Video::Manager::GetInstance().find(args[1].value_union.ui64); + if (!canvas) { + PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Canvas reference is not valid."); + } + + streaming->SetAdditionalVideoCanvas(canvas); + + rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); + AUTO_DEBUG; +} diff --git a/obs-studio-server/source/osn-enhanced-broadcasting-advanced-streaming.hpp b/obs-studio-server/source/osn-enhanced-broadcasting-advanced-streaming.hpp new file mode 100644 index 000000000..b5400dc39 --- /dev/null +++ b/obs-studio-server/source/osn-enhanced-broadcasting-advanced-streaming.hpp @@ -0,0 +1,54 @@ +/****************************************************************************** + Copyright (C) 2016-2022 by Streamlabs (General Workings Inc) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +******************************************************************************/ + +#pragma once +#include +#include "utility.hpp" +#include "osn-delay.hpp" +#include "osn-advanced-streaming.hpp" +#include "osn-reconnect.hpp" +#include "osn-network.hpp" +#include "osn-output.hpp" +#include "osn-video-encoder.hpp" +#include "osn-multitrack-video.hpp" +#include "osn-enhanced-broadcasting.hpp" + +#include "nodeobs_configManager.hpp" + +namespace osn { + +class EnhancedBroadcastingAdvancedStreaming : public EnhancedBroadcasting { +public: + EnhancedBroadcastingAdvancedStreaming() : EnhancedBroadcasting() {} + ~EnhancedBroadcastingAdvancedStreaming() {} +}; + +class IEnhancedBroadcastingAdvancedStreaming : public IAdvancedStreaming { +public: + static void Register(ipc::server &); + + static void Create(void *data, const int64_t id, const std::vector &args, std::vector &rval); + static void Destroy(void *data, const int64_t id, const std::vector &args, std::vector &rval); + + static void Start(void *data, const int64_t id, const std::vector &args, std::vector &rval); + static void Stop(void *data, const int64_t id, const std::vector &args, std::vector &rval); + + static void GetAdditionalVideoCanvas(void *data, const int64_t id, const std::vector &args, std::vector &rval); + static void SetAdditionalVideoCanvas(void *data, const int64_t id, const std::vector &args, std::vector &rval); +}; +} diff --git a/obs-studio-server/source/osn-enhanced-broadcasting-simple-streaming.cpp b/obs-studio-server/source/osn-enhanced-broadcasting-simple-streaming.cpp new file mode 100644 index 000000000..681470add --- /dev/null +++ b/obs-studio-server/source/osn-enhanced-broadcasting-simple-streaming.cpp @@ -0,0 +1,174 @@ +/****************************************************************************** + Copyright (C) 2016-2022 by Streamlabs (General Workings Inc) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +******************************************************************************/ + +#include "osn-enhanced-broadcasting-simple-streaming.hpp" +#include "osn-video-encoder.hpp" +#include "osn-service.hpp" +#include "osn-error.hpp" +#include "shared.hpp" +#include "nodeobs_audio_encoders.h" +#include "osn-audio-track.hpp" +#include + +void osn::IEnhancedBroadcastingSimpleStreaming::Register(ipc::server &srv) +{ + std::shared_ptr cls = std::make_shared("EnhancedBroadcastingSimpleStreaming"); + cls->register_function(std::make_shared("Create", std::vector{}, Create)); + cls->register_function(std::make_shared("Destroy", std::vector{ipc::type::UInt64}, Destroy)); + cls->register_function(std::make_shared("GetService", std::vector{ipc::type::UInt64}, GetService)); + cls->register_function(std::make_shared("SetService", std::vector{ipc::type::UInt64, ipc::type::UInt64}, SetService)); + cls->register_function(std::make_shared("GetVideoEncoder", std::vector{ipc::type::UInt64}, GetVideoEncoder)); + cls->register_function( + std::make_shared("SetVideoEncoder", std::vector{ipc::type::UInt64, ipc::type::UInt64}, SetVideoEncoder)); + cls->register_function(std::make_shared("GetVideoCanvas", std::vector{ipc::type::UInt64}, GetVideoCanvas)); + cls->register_function(std::make_shared("SetVideoCanvas", std::vector{ipc::type::UInt64, ipc::type::UInt64}, SetVideoCanvas)); + cls->register_function(std::make_shared("GetAudioEncoder", std::vector{ipc::type::UInt64}, GetAudioEncoder)); + cls->register_function( + std::make_shared("SetAudioEncoder", std::vector{ipc::type::UInt64, ipc::type::UInt64}, SetAudioEncoder)); + cls->register_function(std::make_shared("GetUseAdvanced", std::vector{ipc::type::UInt64}, GetUseAdvanced)); + cls->register_function(std::make_shared("SetUseAdvanced", std::vector{ipc::type::UInt64, ipc::type::UInt32}, SetUseAdvanced)); + cls->register_function(std::make_shared("GetCustomEncSettings", std::vector{ipc::type::UInt64}, GetCustomEncSettings)); + cls->register_function( + std::make_shared("SetCustomEncSettings", std::vector{ipc::type::UInt64, ipc::type::String}, SetCustomEncSettings)); + cls->register_function(std::make_shared("GetEnforceServiceBirate", std::vector{ipc::type::UInt64}, GetEnforceServiceBirate)); + cls->register_function(std::make_shared("SetEnforceServiceBirate", std::vector{ipc::type::UInt64, ipc::type::UInt32}, + SetEnforceServiceBirate)); + cls->register_function(std::make_shared("GetEnableTwitchVOD", std::vector{ipc::type::UInt64}, GetEnableTwitchVOD)); + cls->register_function( + std::make_shared("SetEnableTwitchVOD", std::vector{ipc::type::UInt64, ipc::type::UInt32}, SetEnableTwitchVOD)); + cls->register_function(std::make_shared("GetDelay", std::vector{ipc::type::UInt64}, GetDelay)); + cls->register_function(std::make_shared("SetDelay", std::vector{ipc::type::UInt64, ipc::type::UInt64}, SetDelay)); + cls->register_function(std::make_shared("GetReconnect", std::vector{ipc::type::UInt64}, GetReconnect)); + cls->register_function(std::make_shared("SetReconnect", std::vector{ipc::type::UInt64, ipc::type::UInt64}, SetReconnect)); + cls->register_function(std::make_shared("GetNetwork", std::vector{ipc::type::UInt64}, GetNetwork)); + cls->register_function(std::make_shared("SetNetwork", std::vector{ipc::type::UInt64, ipc::type::UInt64}, SetNetwork)); + cls->register_function(std::make_shared("Start", std::vector{ipc::type::UInt64}, Start)); + cls->register_function(std::make_shared("Stop", std::vector{ipc::type::UInt64, ipc::type::UInt32}, Stop)); + cls->register_function(std::make_shared("Query", std::vector{ipc::type::UInt64}, Query)); + cls->register_function(std::make_shared("GetLegacySettings", std::vector{}, GetLegacySettings)); + cls->register_function(std::make_shared("SetLegacySettings", std::vector{ipc::type::UInt64}, SetLegacySettings)); + cls->register_function(std::make_shared("GetDroppedFrames", std::vector{ipc::type::UInt64}, GetDroppedFrames)); + cls->register_function(std::make_shared("GetTotalFrames", std::vector{ipc::type::UInt64}, GetTotalFrames)); + cls->register_function(std::make_shared("GetKBitsPerSec", std::vector{ipc::type::UInt64}, GetKBitsPerSec)); + cls->register_function(std::make_shared("GetDataOutput", std::vector{ipc::type::UInt64}, GetDataOutput)); + + cls->register_function( + std::make_shared("GetAdditionalVideoCanvas", std::vector{ipc::type::UInt64}, GetAdditionalVideoCanvas)); + cls->register_function(std::make_shared("SetAdditionalVideoCanvas", std::vector{ipc::type::UInt64, ipc::type::UInt64}, + SetAdditionalVideoCanvas)); + + srv.register_collection(cls); +} + +void osn::IEnhancedBroadcastingSimpleStreaming::Create(void *data, const int64_t id, const std::vector &args, std::vector &rval) +{ + uint64_t uid = osn::IEnhancedBroadcastingSimpleStreaming::Manager::GetInstance().allocate(new EnhancedBroadcastingSimpleStreaming()); + if (uid == UINT64_MAX) { + PRETTY_ERROR_RETURN(ErrorCode::CriticalError, "Index list is full."); + } + + rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); + rval.push_back(ipc::value(uid)); + AUTO_DEBUG; +} + +void osn::IEnhancedBroadcastingSimpleStreaming::Destroy(void *data, const int64_t id, const std::vector &args, std::vector &rval) +{ + EnhancedBroadcastingSimpleStreaming *streaming = static_cast( + osn::IEnhancedBroadcastingSimpleStreaming::Manager::GetInstance().find(args[0].value_union.ui64)); + if (!streaming) { + PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Streaming reference is not valid."); + } + + osn::IEnhancedBroadcastingSimpleStreaming::Manager::GetInstance().free(streaming); + delete streaming; + + rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); + AUTO_DEBUG; +} + +void osn::IEnhancedBroadcastingSimpleStreaming::Start(void *data, const int64_t id, const std::vector &args, std::vector &rval) +{ + EnhancedBroadcastingSimpleStreaming *streaming = static_cast( + osn::IEnhancedBroadcastingSimpleStreaming::Manager::GetInstance().find(args[0].value_union.ui64)); + if (!streaming) { + PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Streaming reference is not valid."); + } + + if (!streaming->service) { + PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid service."); + } + + // Note: unlike advanced mode, there is no Twitch VOD track for simple mode + streaming->StartEnhancedBroadcastingStream(); + + rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); + AUTO_DEBUG; +} + +void osn::IEnhancedBroadcastingSimpleStreaming::Stop(void *data, const int64_t id, const std::vector &args, std::vector &rval) +{ + EnhancedBroadcastingSimpleStreaming *streaming = static_cast( + osn::IEnhancedBroadcastingSimpleStreaming::Manager::GetInstance().find(args[0].value_union.ui64)); + if (!streaming) { + PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Streaming reference is not valid."); + } + + streaming->StopEnhancedBroadcastingStream(); + + ISimpleStreaming::Stop(data, id, args, rval); + + AUTO_DEBUG; +} + +void osn::IEnhancedBroadcastingSimpleStreaming::GetAdditionalVideoCanvas(void *data, const int64_t id, const std::vector &args, + std::vector &rval) +{ + EnhancedBroadcastingSimpleStreaming *streaming = static_cast( + osn::IEnhancedBroadcastingSimpleStreaming::Manager::GetInstance().find(args[0].value_union.ui64)); + if (!streaming) { + PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Streaming reference is not valid."); + } + + const uint64_t uid = osn::Video::Manager::GetInstance().find(streaming->GetAdditionalVideoCanvas()); + + rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); + rval.push_back(ipc::value(uid)); + + AUTO_DEBUG; +} + +void osn::IEnhancedBroadcastingSimpleStreaming::SetAdditionalVideoCanvas(void *data, const int64_t id, const std::vector &args, + std::vector &rval) +{ + EnhancedBroadcastingSimpleStreaming *streaming = static_cast( + osn::IEnhancedBroadcastingSimpleStreaming::Manager::GetInstance().find(args[0].value_union.ui64)); + if (!streaming) { + PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Streaming reference is not valid."); + } + + obs_video_info *canvas = osn::Video::Manager::GetInstance().find(args[1].value_union.ui64); + if (!canvas) { + PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Canvas reference is not valid."); + } + + streaming->SetAdditionalVideoCanvas(canvas); + + rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); + AUTO_DEBUG; +} diff --git a/obs-studio-server/source/osn-enhanced-broadcasting-simple-streaming.hpp b/obs-studio-server/source/osn-enhanced-broadcasting-simple-streaming.hpp new file mode 100644 index 000000000..4320d366a --- /dev/null +++ b/obs-studio-server/source/osn-enhanced-broadcasting-simple-streaming.hpp @@ -0,0 +1,54 @@ +/****************************************************************************** + Copyright (C) 2016-2022 by Streamlabs (General Workings Inc) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +******************************************************************************/ + +#pragma once +#include +#include "utility.hpp" +#include "osn-delay.hpp" +#include "osn-simple-streaming.hpp" +#include "osn-reconnect.hpp" +#include "osn-network.hpp" +#include "osn-output.hpp" +#include "osn-video-encoder.hpp" +#include "osn-multitrack-video.hpp" +#include "osn-enhanced-broadcasting.hpp" + +#include "nodeobs_configManager.hpp" + +namespace osn { + +class EnhancedBroadcastingSimpleStreaming : public EnhancedBroadcasting { +public: + EnhancedBroadcastingSimpleStreaming() : EnhancedBroadcasting() {} + ~EnhancedBroadcastingSimpleStreaming() {} +}; + +class IEnhancedBroadcastingSimpleStreaming : public ISimpleStreaming { +public: + static void Register(ipc::server &); + + static void Create(void *data, const int64_t id, const std::vector &args, std::vector &rval); + static void Destroy(void *data, const int64_t id, const std::vector &args, std::vector &rval); + + static void Start(void *data, const int64_t id, const std::vector &args, std::vector &rval); + static void Stop(void *data, const int64_t id, const std::vector &args, std::vector &rval); + + static void GetAdditionalVideoCanvas(void *data, const int64_t id, const std::vector &args, std::vector &rval); + static void SetAdditionalVideoCanvas(void *data, const int64_t id, const std::vector &args, std::vector &rval); +}; +} diff --git a/obs-studio-server/source/osn-enhanced-broadcasting.hpp b/obs-studio-server/source/osn-enhanced-broadcasting.hpp new file mode 100644 index 000000000..2cb43493b --- /dev/null +++ b/obs-studio-server/source/osn-enhanced-broadcasting.hpp @@ -0,0 +1,142 @@ +/****************************************************************************** + Copyright (C) 2016-2022 by Streamlabs (General Workings Inc) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +******************************************************************************/ + +#pragma once +#include + +#include +#include + +namespace osn { + +template class EnhancedBroadcasting : public BaseStreaming { +public: + EnhancedBroadcasting() : BaseStreaming() {} + + virtual ~EnhancedBroadcasting() {} + + void StartEnhancedBroadcastingStream(std::optional vod_track_mixer = std::nullopt) + { + blog(LOG_INFO, "StartEnhancedBroadcastingStream - service id: %s", obs_service_get_id(this->service)); + + if (vod_track_mixer.has_value()) { + blog(LOG_INFO, "vod_track_mixer: %d", vod_track_mixer.value()); + } + + const bool is_custom = strncmp("rtmp_custom", obs_service_get_type(this->service), 11) == 0; + + OBSDataAutoRelease settings = obs_service_get_settings(this->service); + const std::string key = obs_data_get_string(settings, "key"); + + const char *service_name = ""; + if (is_custom && obs_data_has_user_value(settings, "service_name")) { + service_name = obs_data_get_string(settings, "service_name"); + } else if (!is_custom) { + service_name = obs_data_get_string(settings, "service"); + } + + std::optional custom_rtmp_url; + auto server = obs_data_get_string(settings, "server"); + if (strcmp(server, "auto") != 0) { + custom_rtmp_url = server; + } + + auto service_custom_server = obs_data_get_bool(settings, "using_custom_server"); + if (custom_rtmp_url.has_value()) { + blog(LOG_INFO, "Using %s server '%s'", service_custom_server ? "custom " : "", custom_rtmp_url->c_str()); + } + + auto auto_config_url = osn::MultitrackVideoAutoConfigURL(this->service); + blog(LOG_INFO, "Auto config URL: %s", auto_config_url.c_str()); + + std::vector canvases{this->GetCanvas()}; + if (this->GetAdditionalVideoCanvas()) { + canvases.push_back(this->GetAdditionalVideoCanvas()); + } + + auto go_live_post = osn::constructGoLivePost(canvases, key, std::nullopt, std::nullopt, vod_track_mixer.has_value()); + std::optional go_live_config = osn::DownloadGoLiveConfig(auto_config_url, go_live_post); + if (!go_live_config.has_value()) { + throw std::runtime_error("startStreaming - go live config is empty"); + } + + const auto audio_bitrate = osn::GetMultitrackAudioBitrate(); + const auto audio_encoder_id = osn::GetSimpleAACEncoderForBitrate(audio_bitrate); + + std::vector audio_encoders; + std::shared_ptr video_encoder_group; + auto output = osn::SetupOBSOutput("Enhanced Broadcasting", go_live_config.value(), audio_encoders, video_encoder_group, audio_encoder_id, 0, + vod_track_mixer); + if (!output) { + throw std::runtime_error("startStreaming - failed to create multitrack output"); + } + + // Stream key is defined by config from Twitch + auto multitrack_video_service = osn::create_service(*go_live_config, std::nullopt, ""); + if (!multitrack_video_service) { + throw std::runtime_error("startStreaming - failed to create multitrack video service"); + } + + this->SetOutput(output.Get()); + obs_output_set_service(output, multitrack_video_service); + + // Register the BPM (Broadcast Performance Metrics) callback + obs_output_add_packet_callback(output, bpm_inject, NULL); + + this->StartOutput(); + + enhancedBroadcastingContext.emplace(EnhancedBroadcastOutputObjects{ + std::move(output), + video_encoder_group, + std::move(audio_encoders), + std::move(multitrack_video_service), + }); + } + + void StopEnhancedBroadcastingStream() + { + blog(LOG_INFO, "StopEnhancedBroadcastingStream - service id: %s", obs_service_get_id(this->service)); + + auto output = this->GetOutput(); + if (!output) { + blog(LOG_WARNING, "StopEnhancedBroadcastingStream - empty output"); + return; + } + + obs_output_remove_packet_callback(output, bpm_inject, NULL); + bpm_destroy(output); + } + + obs_video_info *GetAdditionalVideoCanvas() { return additionalVideoContext; } + + void SetAdditionalVideoCanvas(obs_video_info *video) { additionalVideoContext = video; } + + void DeleteOutput() override + { + BaseStreaming::DeleteOutput(); + enhancedBroadcastingContext.reset(); + } + +private: + std::optional enhancedBroadcastingContext; + + // If set, this context makes enhanced broadcasting stream the dual streaming modde + obs_video_info *additionalVideoContext = nullptr; +}; + +} \ No newline at end of file diff --git a/obs-studio-server/source/osn-file-output.cpp b/obs-studio-server/source/osn-file-output.cpp index 483637d6e..90b74947c 100644 --- a/obs-studio-server/source/osn-file-output.cpp +++ b/obs-studio-server/source/osn-file-output.cpp @@ -75,7 +75,7 @@ void osn::IFileOutput::GetVideoCanvas(void *data, const int64_t id, const std::v PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "File output reference is not valid."); } - uint64_t uid = osn::Video::Manager::GetInstance().find(fileOutput->canvas); + uint64_t uid = osn::Video::Manager::GetInstance().find(fileOutput->GetCanvas()); rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); rval.push_back(ipc::value(uid)); @@ -94,7 +94,7 @@ void osn::IFileOutput::SetVideoCanvas(void *data, const int64_t id, const std::v PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Canvas reference is not valid."); } - fileOutput->canvas = canvas; + fileOutput->SetCanvas(canvas); rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); AUTO_DEBUG; @@ -233,7 +233,7 @@ void osn::IFileOutput::GetLastFile(void *data, const int64_t id, const std::vect } calldata_t cd = {0}; - proc_handler_t *ph = obs_output_get_proc_handler(fileOutput->output); + proc_handler_t *ph = obs_output_get_proc_handler(fileOutput->GetOutput()); proc_handler_call(ph, "get_last_file", &cd); const char *path = calldata_string(&cd, "path"); path = path ? path : ""; diff --git a/obs-studio-server/source/osn-file-output.hpp b/obs-studio-server/source/osn-file-output.hpp index 89c77c817..4697d461c 100644 --- a/obs-studio-server/source/osn-file-output.hpp +++ b/obs-studio-server/source/osn-file-output.hpp @@ -19,12 +19,12 @@ #pragma once #include #include "utility.hpp" -#include "osn-output-signals.hpp" +#include "osn-output.hpp" namespace osn { -class FileOutput : public OutputSignals { +class FileOutput : public Output { public: - FileOutput() : OutputSignals() + FileOutput(const std::vector &signals) : Output(signals) { path = ""; format = "mp4"; diff --git a/obs-studio-server/source/osn-multitrack-video-configuration.cpp b/obs-studio-server/source/osn-multitrack-video-configuration.cpp index 577f2903b..a8d366ce4 100644 --- a/obs-studio-server/source/osn-multitrack-video-configuration.cpp +++ b/obs-studio-server/source/osn-multitrack-video-configuration.cpp @@ -218,7 +218,7 @@ std::string MultitrackVideoAutoConfigURL(obs_service_t *service) return url; } -PostData constructGoLivePost(StreamServiceId serviceId, bool dualStreamingMode, std::string streamKey, const std::optional &maximum_aggregate_bitrate, +PostData constructGoLivePost(std::vector canvases, std::string streamKey, const std::optional &maximum_aggregate_bitrate, const std::optional &maximum_video_tracks, bool vod_track_enabled) { PostData post_data{}; @@ -255,23 +255,13 @@ PostData constructGoLivePost(StreamServiceId serviceId, bool dualStreamingMode, if (obs_get_video_info(&ovi)) preferences.composition_gpu_index = ovi.adapter; - const size_t contexts = obs_get_video_info_count(); - for (size_t i = 0; i < contexts; i++) { - if (obs_get_video_info_by_index(i, &ovi)) { - const bool isHorizontalCanvas = ovi.base_width >= ovi.base_height; - if (!dualStreamingMode && isHorizontalCanvas && serviceId != StreamServiceId::Main) { - blog(LOG_INFO, "constructGoLivePost - skipping horizontal canvas"); - continue; - } - - if (!dualStreamingMode && !isHorizontalCanvas && serviceId != StreamServiceId::Second) { - blog(LOG_INFO, "constructGoLivePost - skipping vertical canvas"); - continue; - } - - preferences.canvases.emplace_back( - Canvas{ovi.output_width, ovi.output_height, ovi.base_width, ovi.base_height, {ovi.fps_num, ovi.fps_den}}); + for (const auto &c : canvases) { + if (!c) { + blog(LOG_WARNING, "constructGoLivePost - empty canvas, skipping"); + continue; } + + preferences.canvases.emplace_back(Canvas{c->output_width, c->output_height, c->base_width, c->base_height, {c->fps_num, c->fps_den}}); } obs_audio_info2 oai2; diff --git a/obs-studio-server/source/osn-multitrack-video-configuration.hpp b/obs-studio-server/source/osn-multitrack-video-configuration.hpp index 3741694bb..4662a6744 100644 --- a/obs-studio-server/source/osn-multitrack-video-configuration.hpp +++ b/obs-studio-server/source/osn-multitrack-video-configuration.hpp @@ -7,6 +7,7 @@ #include #include +#include namespace osn { @@ -14,7 +15,7 @@ std::string MultitrackVideoAutoConfigURL(obs_service_t *service); Config DownloadGoLiveConfig(std::string url, const PostData &post_data); -PostData constructGoLivePost(StreamServiceId serviceId, bool dualStreamingMode, std::string streamKey, const std::optional &maximum_aggregate_bitrate, +PostData constructGoLivePost(std::vector canvases, std::string streamKey, const std::optional &maximum_aggregate_bitrate, const std::optional &maximum_video_tracks, bool vod_track_enabled); } \ No newline at end of file diff --git a/obs-studio-server/source/osn-multitrack-video-system-info.cpp b/obs-studio-server/source/osn-multitrack-video-system-info.cpp index dd74c229d..04167a41b 100644 --- a/obs-studio-server/source/osn-multitrack-video-system-info.cpp +++ b/obs-studio-server/source/osn-multitrack-video-system-info.cpp @@ -241,7 +241,6 @@ void system_info(Capabilities &capabilities) system_data.build = ver.build; system_data.release = win_release_id; system_data.revision = std::to_string(ver.revis); - ; system_data.bits = is_64_bit_windows() ? 64 : 32; system_data.arm = is_arm64_windows(); system_data.armEmulation = os_get_emulation_status(); diff --git a/obs-studio-server/source/osn-multitrack-video.cpp b/obs-studio-server/source/osn-multitrack-video.cpp new file mode 100644 index 000000000..c68e3dd95 --- /dev/null +++ b/obs-studio-server/source/osn-multitrack-video.cpp @@ -0,0 +1,26 @@ +#include "osn-multitrack-video.hpp" + +#include "osn-audio-bitrate.hpp" + +#include "nodeobs_configManager.hpp" +#include + +namespace osn { + +bool IsMultitrackVideoEnabled() +{ + return config_get_bool(ConfigManager::getInstance().getBasic(), "EnhancedBroadcasting", "EnableMultitrackVideo"); +} + +int GetMultitrackAudioBitrate() +{ + const char *audio_encoder_id = config_get_string(ConfigManager::getInstance().getBasic(), "SimpleOutput", "StreamAudioEncoder"); + const int bitrate = (int)config_get_uint(ConfigManager::getInstance().getBasic(), "SimpleOutput", "ABitrate"); + + if (audio_encoder_id && strcmp(audio_encoder_id, "opus") == 0) + return osn::FindClosestAvailableSimpleOpusBitrate(bitrate); + + return osn::FindClosestAvailableSimpleAACBitrate(bitrate); +} + +} \ No newline at end of file diff --git a/obs-studio-server/source/osn-multitrack-video.hpp b/obs-studio-server/source/osn-multitrack-video.hpp new file mode 100644 index 000000000..b81ab8005 --- /dev/null +++ b/obs-studio-server/source/osn-multitrack-video.hpp @@ -0,0 +1,22 @@ +#pragma once + +#include "osn-multitrack-video-configuration.hpp" +#include "osn-audio-bitrate.hpp" +#include "osn-multitrack-video-output.hpp" + +#include "obs.hpp" + +namespace osn { + +struct EnhancedBroadcastOutputObjects { + OBSOutputAutoRelease obsOutput; + std::shared_ptr videoEncoderGroup; + std::vector audioEncoders; + OBSServiceAutoRelease multitrackVideoService; +}; + +bool IsMultitrackVideoEnabled(); + +int GetMultitrackAudioBitrate(); + +} \ No newline at end of file diff --git a/obs-studio-server/source/osn-output-signals.cpp b/obs-studio-server/source/osn-output-signals.cpp deleted file mode 100644 index 5f52c7eac..000000000 --- a/obs-studio-server/source/osn-output-signals.cpp +++ /dev/null @@ -1,116 +0,0 @@ -/****************************************************************************** - Copyright (C) 2016-2022 by Streamlabs (General Workings Inc) - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 2 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . - -******************************************************************************/ - -#include "osn-output-signals.hpp" -#include "nodeobs_api.h" - -void osn::OutputSignals::createOutput(const std::string &type, const std::string &name) -{ - deleteOutput(); - output = obs_output_create(type.c_str(), name.c_str(), nullptr, nullptr); - - auto onStopped = [](void *data, calldata_t *) { - osn::OutputSignals *context = reinterpret_cast(data); - std::unique_lock lock(context->mtxOutputStop); - context->cvStop.notify_one(); - }; - - signal_handler *sh = obs_output_get_signal_handler(output); - signal_handler_connect(sh, "stop", onStopped, this); - - ConnectSignals(); -} - -void osn::OutputSignals::deleteOutput() -{ - if (!output) - return; - - if (obs_output_active(output)) { - obs_output_stop(output); - std::unique_lock lock(mtxOutputStop); - cvStop.wait_for(lock, std::chrono::seconds(20)); - } - obs_output_release(output); - output = nullptr; -} - -static void callback(void *data, calldata_t *params) -{ - auto info = reinterpret_cast(data); - - if (!info) - return; - - std::string signal = info->signal; - auto outputClass = info->outputClass; - - if (!outputClass->output) - return; - - const char *error = obs_output_get_last_error(outputClass->output); - - std::unique_lock ulock(outputClass->signalsMtx); - outputClass->signalsReceived.push({signal, (int)calldata_int(params, "code"), error ? std::string(error) : ""}); -} - -void osn::OutputSignals::ConnectSignals() -{ - if (!output) - return; - - signal_handler *handler = obs_output_get_signal_handler(output); - for (const auto &signal : this->signals) { - osn::cbData *cd = new cbData(); - cd->signal = signal; - cd->outputClass = this; - signal_handler_connect(handler, signal.c_str(), callback, cd); - } -} - -void osn::OutputSignals::startOutput() -{ - if (!output) - return; - - outdated_driver_error::instance()->set_active(true); - bool result = obs_output_start(output); - outdated_driver_error::instance()->set_active(false); - - if (result) - return; - - int code = 0; - std::string errorMessage = ""; - std::string outdated_driver_error = outdated_driver_error::instance()->get_error(); - - if (outdated_driver_error.size() != 0) { - errorMessage = outdated_driver_error; - code = OBS_OUTPUT_OUTDATED_DRIVER; - } else { - const char *error = obs_output_get_last_error(output); - if (error) { - errorMessage = error; - blog(LOG_INFO, "Last streaming error: %s", error); - } - code = OBS_OUTPUT_ERROR; - } - - std::unique_lock ulock(signalsMtx); - signalsReceived.push({"stop", code, errorMessage}); -} \ No newline at end of file diff --git a/obs-studio-server/source/osn-output.cpp b/obs-studio-server/source/osn-output.cpp index 4d82e05db..24b479c77 100644 --- a/obs-studio-server/source/osn-output.cpp +++ b/obs-studio-server/source/osn-output.cpp @@ -17,3 +17,166 @@ ******************************************************************************/ #include "osn-Output.hpp" + +#include "nodeobs_api.h" + +namespace { + +struct CallbackData { + std::string signal; + osn::Output *outputClass; +}; + +} // namespace + +osn::Output::Output(const std::vector &signals) : m_signals(signals) {} + +osn::Output::~Output() {} + +void osn::Output::InitOutput(obs_output_t *output) +{ + auto onStopped = [](void *data, calldata_t *) { + osn::Output *context = reinterpret_cast(data); + std::unique_lock lock(context->m_mtxOutputStop); + context->m_cvStop.notify_one(); + }; + + signal_handler *sh = obs_output_get_signal_handler(output); + signal_handler_connect(sh, "stop", onStopped, this); + + ConnectSignals(); +} + +void osn::Output::CreateOutput(const std::string &type, const std::string &name) +{ + DeleteOutput(); + m_output = obs_output_create(type.c_str(), name.c_str(), nullptr, nullptr); + + InitOutput(m_output); +} + +void osn::Output::SetOutput(obs_output_t *output) +{ + DeleteOutput(); + m_output = obs_output_get_ref(output); + InitOutput(m_output); +} + +void osn::Output::DeleteOutput() +{ + if (!m_output) + return; + + blog(LOG_INFO, "osn::Output::DeleteOutput"); + + if (obs_output_active(m_output)) { + obs_output_stop(m_output); + std::unique_lock lock(m_mtxOutputStop); + m_cvStop.wait_for(lock, std::chrono::seconds(20)); + } + obs_output_release(m_output); + m_output = nullptr; +} + +void osn::OutputSignalCallback(void *data, calldata_t *params) +{ + auto info = reinterpret_cast(data); + + if (!info) + return; + + std::string signal = info->signal; + auto outputClass = info->outputClass; + + if (!outputClass->m_output) + return; + + const char *error = obs_output_get_last_error(outputClass->m_output); + + std::unique_lock ulock(outputClass->m_signalsMtx); + outputClass->m_signalsReceived.push({signal, (int)calldata_int(params, "code"), error ? std::string(error) : ""}); +} + +void osn::Output::ConnectSignals() +{ + if (!m_output) + return; + + signal_handler *handler = obs_output_get_signal_handler(m_output); + for (const auto &signal : m_signals) { + auto *cd = new CallbackData(); + cd->signal = signal; + cd->outputClass = this; + signal_handler_connect(handler, signal.c_str(), osn::OutputSignalCallback, cd); + } +} + +void osn::Output::StartOutput() +{ + if (!m_output) + return; + + outdated_driver_error::instance()->set_active(true); + bool result = obs_output_start(m_output); + outdated_driver_error::instance()->set_active(false); + + if (result) + return; + + int code = 0; + std::string errorMessage = ""; + std::string outdated_driver_error = outdated_driver_error::instance()->get_error(); + + if (outdated_driver_error.size() != 0) { + errorMessage = outdated_driver_error; + code = OBS_OUTPUT_OUTDATED_DRIVER; + } else { + const char *error = obs_output_get_last_error(m_output); + if (error) { + errorMessage = error; + blog(LOG_INFO, "Last streaming error: %s", error); + } + code = OBS_OUTPUT_ERROR; + } + + std::unique_lock ulock(m_signalsMtx); + m_signalsReceived.push({"stop", code, errorMessage}); +} + +std::optional osn::Output::PopReceivedSignal() +{ + std::unique_lock ulock(m_signalsMtx); + + if (m_signalsReceived.empty()) { + return {}; + } + + const auto result = m_signalsReceived.front(); + m_signalsReceived.pop(); + return result; +} + +void osn::Output::SetCanvas(obs_video_info *canvas) +{ + m_canvas = canvas; +} + +obs_video_info *osn::Output::GetCanvas() +{ + return m_canvas; +} + +const obs_video_info *osn::Output::GetCanvas() const +{ + return m_canvas; +} + +obs_output_t *osn::Output::GetOutput() +{ + return m_output; +} + +const obs_output_t *osn::Output::GetOutput() const +{ + return m_output; +} \ No newline at end of file diff --git a/obs-studio-server/source/osn-output.hpp b/obs-studio-server/source/osn-output.hpp index 13250cfb6..f417dd68d 100644 --- a/obs-studio-server/source/osn-output.hpp +++ b/obs-studio-server/source/osn-output.hpp @@ -17,3 +17,59 @@ ******************************************************************************/ #pragma once + +#include + +#include +#include +#include +#include + +namespace osn { + +class Output { +public: + struct SignalInfo { + std::string signal; + int code = 0; + std::string errorMessage; + }; + +public: + Output(const std::vector &signals); + virtual ~Output(); + + void ConnectSignals(); + void CreateOutput(const std::string &type, const std::string &name); + void SetOutput(obs_output_t *output); + virtual void DeleteOutput(); + void StartOutput(); + + // If no signal, will return an empty optional. Thread safe. + std::optional PopReceivedSignal(); + + void SetCanvas(obs_video_info *canvas); + obs_video_info *GetCanvas(); + const obs_video_info *GetCanvas() const; + + obs_output_t *GetOutput(); + const obs_output_t *GetOutput() const; + +private: + friend void OutputSignalCallback(void *data, calldata_t *params); + + void InitOutput(obs_output_t *output); + + obs_video_info *m_canvas = nullptr; + obs_output_t *m_output = nullptr; + + std::mutex m_signalsMtx; + std::queue m_signalsReceived; + + std::condition_variable m_cvStop; + std::mutex m_mtxOutputStop; + + const std::vector m_signals; +}; + +} \ No newline at end of file diff --git a/obs-studio-server/source/osn-recording.cpp b/obs-studio-server/source/osn-recording.cpp index 77da3582d..7723eede5 100644 --- a/obs-studio-server/source/osn-recording.cpp +++ b/obs-studio-server/source/osn-recording.cpp @@ -26,7 +26,7 @@ extern char *osn_generate_formatted_filename(const char *extension, bool space, osn::Recording::~Recording() { - deleteOutput(); + DeleteOutput(); } void osn::IRecording::GetVideoEncoder(void *data, const int64_t id, const std::vector &args, std::vector &rval) @@ -68,22 +68,18 @@ void osn::IRecording::Query(void *data, const int64_t id, const std::vector ulock(recording->signalsMtx); - if (recording->signalsReceived.empty()) { + auto signalOpt = recording->PopReceivedSignal(); + if (!signalOpt.has_value()) { rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); AUTO_DEBUG; return; } rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); - - auto signal = recording->signalsReceived.front(); rval.push_back(ipc::value("recording")); - rval.push_back(ipc::value(signal.signal)); - rval.push_back(ipc::value(signal.code)); - rval.push_back(ipc::value(signal.errorMessage)); - - recording->signalsReceived.pop(); + rval.push_back(ipc::value(signalOpt.value().signal)); + rval.push_back(ipc::value(signalOpt.value().code)); + rval.push_back(ipc::value(signalOpt.value().errorMessage)); AUTO_DEBUG; } @@ -153,13 +149,13 @@ obs_encoder_t *osn::IRecording::duplicate_encoder(obs_encoder_t *src, uint64_t t void osn::IRecording::SplitFile(void *data, const int64_t id, const std::vector &args, std::vector &rval) { Recording *recording = static_cast(osn::IFileOutput::Manager::GetInstance().find(args[0].value_union.ui64)); - if (!recording || !recording->output) { + if (!recording || !recording->GetOutput()) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Recording reference is not valid."); } calldata_t cd = {0}; - proc_handler_t *ph = obs_output_get_proc_handler(recording->output); + proc_handler_t *ph = obs_output_get_proc_handler(recording->GetOutput()); proc_handler_call(ph, "split_file", &cd); calldata_free(&cd); @@ -310,6 +306,6 @@ void osn::Recording::ConfigureRecFileSplitting() obs_data_set_bool(settings, "reset_timestamps", fileResetTimestamps); - obs_output_update(output, settings); + obs_output_update(this->GetOutput(), settings); obs_data_release(settings); } diff --git a/obs-studio-server/source/osn-recording.hpp b/obs-studio-server/source/osn-recording.hpp index 5a5f0930d..27afc8231 100644 --- a/obs-studio-server/source/osn-recording.hpp +++ b/obs-studio-server/source/osn-recording.hpp @@ -27,10 +27,10 @@ enum SplitFileType : uint32_t { TIME, SIZE, MANUAL }; class Recording : public FileOutput { public: - Recording() : FileOutput() + Recording() : FileOutput({"start", "stop", "stopping", "wrote"}) { videoEncoder = nullptr; - signals = {"start", "stop", "stopping", "wrote"}; + //signals = {"start", "stop", "stopping", "wrote"}; enableFileSplit = false; splitType = SplitFileType::TIME; splitTime = 15; diff --git a/obs-studio-server/source/osn-replay-buffer.cpp b/obs-studio-server/source/osn-replay-buffer.cpp index 3a4b55d89..c72d034d7 100644 --- a/obs-studio-server/source/osn-replay-buffer.cpp +++ b/obs-studio-server/source/osn-replay-buffer.cpp @@ -24,7 +24,7 @@ osn::ReplayBuffer::~ReplayBuffer() { - deleteOutput(); + DeleteOutput(); } void osn::IReplayBuffer::GetDuration(void *data, const int64_t id, const std::vector &args, std::vector &rval) @@ -134,22 +134,18 @@ void osn::IReplayBuffer::Query(void *data, const int64_t id, const std::vector ulock(replayBuffer->signalsMtx); - if (replayBuffer->signalsReceived.empty()) { + auto signalOpt = replayBuffer->PopReceivedSignal(); + if (!signalOpt.has_value()) { rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); AUTO_DEBUG; return; } rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); - - auto signal = replayBuffer->signalsReceived.front(); rval.push_back(ipc::value("replay-buffer")); - rval.push_back(ipc::value(signal.signal)); - rval.push_back(ipc::value(signal.code)); - rval.push_back(ipc::value(signal.errorMessage)); - - replayBuffer->signalsReceived.pop(); + rval.push_back(ipc::value(signalOpt.value().signal)); + rval.push_back(ipc::value(signalOpt.value().code)); + rval.push_back(ipc::value(signalOpt.value().errorMessage)); AUTO_DEBUG; } diff --git a/obs-studio-server/source/osn-replay-buffer.hpp b/obs-studio-server/source/osn-replay-buffer.hpp index a296b5f32..8dbf1087d 100644 --- a/obs-studio-server/source/osn-replay-buffer.hpp +++ b/obs-studio-server/source/osn-replay-buffer.hpp @@ -25,13 +25,13 @@ namespace osn { class ReplayBuffer : public FileOutput { public: - ReplayBuffer() + ReplayBuffer() : FileOutput({"start", "stop", "stopping", "writing", "wrote", "writing_error"}) { duration = 20; prefix = "Replay"; suffix = ""; usesStream = false; - signals = {"start", "stop", "stopping", "writing", "wrote", "writing_error"}; + //signals = {"start", "stop", "stopping", "writing", "wrote", "writing_error"}; } virtual ~ReplayBuffer(); diff --git a/obs-studio-server/source/osn-simple-recording.cpp b/obs-studio-server/source/osn-simple-recording.cpp index 27addc6d3..42bd29b46 100644 --- a/obs-studio-server/source/osn-simple-recording.cpp +++ b/obs-studio-server/source/osn-simple-recording.cpp @@ -153,8 +153,8 @@ static void LoadLosslessPreset(osn::Recording *recording) obs_data_set_string(settings, "video_encoder", "utvideo"); obs_data_set_string(settings, "audio_encoder", "pcm_s16le"); - obs_output_set_mixers(recording->output, 1); - obs_output_update(recording->output, settings); + obs_output_set_mixers(recording->GetOutput(), 1); + obs_output_update(recording->GetOutput(), settings); obs_data_release(settings); } @@ -293,9 +293,9 @@ static void UpdateRecordingSettings_crf(enum osn::RecQuality quality, osn::Simpl if (!settings) return; if (obs_get_multiple_rendering()) { - obs_encoder_set_video_mix(recording->videoEncoder, obs_video_mix_get(recording->canvas, OBS_STREAMING_VIDEO_RENDERING)); + obs_encoder_set_video_mix(recording->videoEncoder, obs_video_mix_get(recording->GetCanvas(), OBS_STREAMING_VIDEO_RENDERING)); } else { - obs_encoder_set_video_mix(recording->videoEncoder, obs_video_mix_get(recording->canvas, OBS_MAIN_VIDEO_RENDERING)); + obs_encoder_set_video_mix(recording->videoEncoder, obs_video_mix_get(recording->GetCanvas(), OBS_MAIN_VIDEO_RENDERING)); } obs_encoder_update(recording->videoEncoder, settings); obs_data_release(settings); @@ -344,10 +344,10 @@ void osn::ISimpleRecording::Start(void *data, const int64_t id, const std::vecto } const char *ffmpegMuxer = "ffmpeg_muxer"; - if (!recording->output || strcmp(obs_output_get_id(recording->output), ffmpegMuxer) == 0) - recording->createOutput("ffmpeg_muxer", "recording"); + if (!recording->GetOutput() || strcmp(obs_output_get_id(recording->GetOutput()), ffmpegMuxer) == 0) + recording->CreateOutput("ffmpeg_muxer", "recording"); - if (!recording->output) { + if (!recording->GetOutput()) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Error while creating the recording output."); } @@ -355,7 +355,7 @@ void osn::ISimpleRecording::Start(void *data, const int64_t id, const std::vecto std::string pathProperty = "path"; if (recording->quality == RecQuality::Lossless) { - recording->createOutput("ffmpeg_output", "recording"); + recording->CreateOutput("ffmpeg_output", "recording"); LoadLosslessPreset(recording); format = "avi"; pathProperty = "url"; @@ -371,10 +371,10 @@ void osn::ISimpleRecording::Start(void *data, const int64_t id, const std::vecto } obs_encoder_set_audio(recording->audioEncoder, obs_get_audio()); - obs_output_set_audio_encoder(recording->output, recording->audioEncoder, 0); - obs_encoder_set_video_mix(recording->audioEncoder, obs_video_mix_get(recording->canvas, OBS_RECORDING_VIDEO_RENDERING)); + obs_output_set_audio_encoder(recording->GetOutput(), recording->audioEncoder, 0); + obs_encoder_set_video_mix(recording->audioEncoder, obs_video_mix_get(recording->GetCanvas(), OBS_RECORDING_VIDEO_RENDERING)); - obs_output_set_video_encoder(recording->output, recording->videoEncoder); + obs_output_set_video_encoder(recording->GetOutput(), recording->videoEncoder); } if (!recording->path.size()) { @@ -387,7 +387,8 @@ void osn::ISimpleRecording::Start(void *data, const int64_t id, const std::vecto if (lastChar != '/' && lastChar != '\\') path += "/"; - path += GenerateSpecifiedFilename(format, recording->noSpace, recording->fileFormat, recording->canvas->base_width, recording->canvas->base_height); + path += GenerateSpecifiedFilename(format, recording->noSpace, recording->fileFormat, recording->GetCanvas()->base_width, + recording->GetCanvas()->base_height); if (!recording->overwrite) FindBestFilename(path, recording->noSpace); @@ -395,13 +396,13 @@ void osn::ISimpleRecording::Start(void *data, const int64_t id, const std::vecto obs_data_t *settings = obs_data_create(); obs_data_set_string(settings, pathProperty.c_str(), path.c_str()); obs_data_set_string(settings, "muxer_settings", recording->muxerSettings.c_str()); - obs_output_update(recording->output, settings); + obs_output_update(recording->GetOutput(), settings); obs_data_release(settings); if (recording->enableFileSplit) recording->ConfigureRecFileSplitting(); - recording->startOutput(); + recording->StartOutput(); rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); AUTO_DEBUG; @@ -413,11 +414,11 @@ void osn::ISimpleRecording::Stop(void *data, const int64_t id, const std::vector if (!recording) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Simple recording reference is not valid."); } - if (!recording->output) { + if (!recording->GetOutput()) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid recording output."); } - obs_output_stop(recording->output); + obs_output_stop(recording->GetOutput()); rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); AUTO_DEBUG; diff --git a/obs-studio-server/source/osn-simple-replay-buffer.cpp b/obs-studio-server/source/osn-simple-replay-buffer.cpp index 30af1d273..de2a24dbc 100644 --- a/obs-studio-server/source/osn-simple-replay-buffer.cpp +++ b/obs-studio-server/source/osn-simple-replay-buffer.cpp @@ -95,8 +95,8 @@ void osn::ISimpleReplayBuffer::Start(void *data, const int64_t id, const std::ve PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Simple replay buffer reference is not valid."); } - if (!replayBuffer->output) - replayBuffer->createOutput("replay_buffer", "replay-buffer"); + if (!replayBuffer->GetOutput()) + replayBuffer->CreateOutput("replay_buffer", "replay-buffer"); obs_encoder_t *audioEncoder = nullptr; obs_encoder_t *videoEncoder = nullptr; @@ -120,13 +120,13 @@ void osn::ISimpleReplayBuffer::Start(void *data, const int64_t id, const std::ve } obs_encoder_set_audio(audioEncoder, obs_get_audio()); - obs_output_set_audio_encoder(replayBuffer->output, audioEncoder, 0); + obs_output_set_audio_encoder(replayBuffer->GetOutput(), audioEncoder, 0); if (!videoEncoder) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid video encoder."); } - obs_output_set_video_encoder(replayBuffer->output, videoEncoder); + obs_output_set_video_encoder(replayBuffer->GetOutput(), videoEncoder); if (!replayBuffer->path.size()) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid recording path."); @@ -157,10 +157,10 @@ void osn::ISimpleReplayBuffer::Start(void *data, const int64_t id, const std::ve obs_data_set_bool(settings, "allow_spaces", !replayBuffer->noSpace); obs_data_set_int(settings, "max_time_sec", replayBuffer->duration); obs_data_set_int(settings, "max_size_mb", rbSize); - obs_output_update(replayBuffer->output, settings); + obs_output_update(replayBuffer->GetOutput(), settings); obs_data_release(settings); - replayBuffer->startOutput(); + replayBuffer->StartOutput(); rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); AUTO_DEBUG; @@ -172,11 +172,11 @@ void osn::ISimpleReplayBuffer::Stop(void *data, const int64_t id, const std::vec if (!replayBuffer) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Simple replay buffer reference is not valid."); } - if (!replayBuffer->output) { + if (!replayBuffer->GetOutput()) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid replay buffer output."); } - obs_output_stop(replayBuffer->output); + obs_output_stop(replayBuffer->GetOutput()); rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); AUTO_DEBUG; diff --git a/obs-studio-server/source/osn-simple-streaming.cpp b/obs-studio-server/source/osn-simple-streaming.cpp index a50e3bbcc..a5874fb51 100644 --- a/obs-studio-server/source/osn-simple-streaming.cpp +++ b/obs-studio-server/source/osn-simple-streaming.cpp @@ -218,8 +218,8 @@ static void SetupTwitchSoundtrackAudio(osn::SimpleStreaming *streaming) obs_encoder_set_audio(streaming->streamArchive, obs_get_audio()); } - obs_output_set_audio_encoder(streaming->output, streaming->streamArchive, kSoundtrackArchiveEncoderIdx); - obs_encoder_set_video_mix(streaming->streamArchive, obs_video_mix_get(streaming->canvas, OBS_STREAMING_VIDEO_RENDERING)); + obs_output_set_audio_encoder(streaming->GetOutput(), streaming->streamArchive, kSoundtrackArchiveEncoderIdx); + obs_encoder_set_video_mix(streaming->streamArchive, obs_video_mix_get(streaming->GetCanvas(), OBS_STREAMING_VIDEO_RENDERING)); obs_data_t *settings = obs_data_create(); @@ -317,9 +317,9 @@ void osn::SimpleStreaming::UpdateEncoders() obs_data_release(audioEncSettings); if (obs_get_multiple_rendering()) { - obs_encoder_set_video_mix(videoEncoder, obs_video_mix_get(canvas, OBS_STREAMING_VIDEO_RENDERING)); + obs_encoder_set_video_mix(videoEncoder, obs_video_mix_get(this->GetCanvas(), OBS_STREAMING_VIDEO_RENDERING)); } else { - obs_encoder_set_video_mix(videoEncoder, obs_video_mix_get(canvas, OBS_MAIN_VIDEO_RENDERING)); + obs_encoder_set_video_mix(videoEncoder, obs_video_mix_get(this->GetCanvas(), OBS_MAIN_VIDEO_RENDERING)); } } @@ -338,10 +338,10 @@ void osn::ISimpleStreaming::Start(void *data, const int64_t id, const std::vecto if (!type) type = "rtmp_output"; - if (!streaming->output || strcmp(obs_output_get_id(streaming->output), type) != 0) - streaming->createOutput(type, "stream"); + if (!streaming->GetOutput() || strcmp(obs_output_get_id(streaming->GetOutput()), type) != 0) + streaming->CreateOutput(type, "stream"); - if (!streaming->output) { + if (!streaming->GetOutput()) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Error while creating the streaming output."); } @@ -353,12 +353,16 @@ void osn::ISimpleStreaming::Start(void *data, const int64_t id, const std::vecto PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid audio encoder."); } + if (!streaming->GetCanvas()) { + PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid main canvas."); + } + streaming->UpdateEncoders(); obs_encoder_set_audio(streaming->audioEncoder, obs_get_audio()); - obs_output_set_audio_encoder(streaming->output, streaming->audioEncoder, 0); - obs_encoder_set_video_mix(streaming->audioEncoder, obs_video_mix_get(streaming->canvas, OBS_STREAMING_VIDEO_RENDERING)); + obs_output_set_audio_encoder(streaming->GetOutput(), streaming->audioEncoder, 0); + obs_encoder_set_video_mix(streaming->audioEncoder, obs_video_mix_get(streaming->GetCanvas(), OBS_STREAMING_VIDEO_RENDERING)); - obs_output_set_video_encoder(streaming->output, streaming->videoEncoder); + obs_output_set_video_encoder(streaming->GetOutput(), streaming->videoEncoder); if (streaming->enableTwitchVOD) { streaming->twitchVODSupported = streaming->isTwitchVODSupported(); @@ -366,19 +370,19 @@ void osn::ISimpleStreaming::Start(void *data, const int64_t id, const std::vecto SetupTwitchSoundtrackAudio(streaming); } - obs_output_set_service(streaming->output, streaming->service); + obs_output_set_service(streaming->GetOutput(), streaming->service); if (!streaming->delay) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid delay."); } - obs_output_set_delay(streaming->output, streaming->delay->enabled ? uint32_t(streaming->delay->delaySec) : 0, + obs_output_set_delay(streaming->GetOutput(), streaming->delay->enabled ? uint32_t(streaming->delay->delaySec) : 0, streaming->delay->preserveDelay ? OBS_OUTPUT_DELAY_PRESERVE : 0); if (!streaming->reconnect) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid reconnect."); } uint32_t maxReties = streaming->reconnect->enabled ? streaming->reconnect->maxRetries : 0; - obs_output_set_reconnect_settings(streaming->output, maxReties, streaming->reconnect->retryDelay); + obs_output_set_reconnect_settings(streaming->GetOutput(), maxReties, streaming->reconnect->retryDelay); if (!streaming->network) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid network."); @@ -389,10 +393,10 @@ void osn::ISimpleStreaming::Start(void *data, const int64_t id, const std::vecto obs_data_set_bool(settings, "dyn_bitrate", streaming->network->enableDynamicBitrate); obs_data_set_bool(settings, "new_socket_loop_enabled", streaming->network->enableOptimizations); obs_data_set_bool(settings, "low_latency_mode_enabled", streaming->network->enableLowLatency); - obs_output_update(streaming->output, settings); + obs_output_update(streaming->GetOutput(), settings); obs_data_release(settings); - streaming->startOutput(); + streaming->StartOutput(); rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); AUTO_DEBUG; @@ -405,16 +409,16 @@ void osn::ISimpleStreaming::Stop(void *data, const int64_t id, const std::vector PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Simple streaming reference is not valid."); } - if (!streaming->output) { + if (!streaming->GetOutput()) { PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Invalid streaming output."); } bool force = args[1].value_union.ui32; if (force) - obs_output_force_stop(streaming->output); + obs_output_force_stop(streaming->GetOutput()); else - obs_output_stop(streaming->output); + obs_output_stop(streaming->GetOutput()); rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); AUTO_DEBUG; diff --git a/obs-studio-server/source/osn-streaming.cpp b/obs-studio-server/source/osn-streaming.cpp index f447c28c3..9bb37756f 100644 --- a/obs-studio-server/source/osn-streaming.cpp +++ b/obs-studio-server/source/osn-streaming.cpp @@ -26,13 +26,18 @@ osn::Streaming::~Streaming() { - deleteOutput(); + DeleteOutput(); if (streamArchive && !obs_encoder_active(streamArchive)) { obs_encoder_release(streamArchive); streamArchive = nullptr; } } +void osn::Streaming::DeleteOutput() +{ + Output::DeleteOutput(); +} + void osn::IStreaming::GetService(void *data, const int64_t id, const std::vector &args, std::vector &rval) { Streaming *streaming = osn::IStreaming::Manager::GetInstance().find(args[0].value_union.ui64); @@ -72,7 +77,7 @@ void osn::IStreaming::GetVideoCanvas(void *data, const int64_t id, const std::ve PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Streaming reference is not valid."); } - uint64_t uid = osn::Video::Manager::GetInstance().find(streaming->canvas); + uint64_t uid = osn::Video::Manager::GetInstance().find(streaming->GetCanvas()); rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); rval.push_back(ipc::value(uid)); @@ -93,7 +98,7 @@ void osn::IStreaming::SetVideoCanvas(void *data, const int64_t id, const std::ve blog(LOG_INFO, "IStreaming::SetVideoCanvas - canvas: 0x%" PRIXPTR ", uid: %d", (uintptr_t)canvas, (int)args[1].value_union.ui64); - streaming->canvas = canvas; + streaming->SetCanvas(canvas); rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); AUTO_DEBUG; @@ -299,22 +304,18 @@ void osn::IStreaming::Query(void *data, const int64_t id, const std::vector ulock(streaming->signalsMtx); - if (streaming->signalsReceived.empty()) { + auto signalOpt = streaming->PopReceivedSignal(); + if (!signalOpt.has_value()) { rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); AUTO_DEBUG; return; } rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); - - auto signal = streaming->signalsReceived.front(); rval.push_back(ipc::value("streaming")); - rval.push_back(ipc::value(signal.signal)); - rval.push_back(ipc::value(signal.code)); - rval.push_back(ipc::value(signal.errorMessage)); - - streaming->signalsReceived.pop(); + rval.push_back(ipc::value(signalOpt.value().signal)); + rval.push_back(ipc::value(signalOpt.value().code)); + rval.push_back(ipc::value(signalOpt.value().errorMessage)); AUTO_DEBUG; } @@ -393,8 +394,8 @@ void osn::IStreaming::GetDroppedFrames(void *data, const int64_t id, const std:: int totalDropped = 0; - if (streaming->output && obs_output_active(streaming->output)) { - totalDropped = obs_output_get_frames_dropped(streaming->output); + if (streaming->GetOutput() && obs_output_active(streaming->GetOutput())) { + totalDropped = obs_output_get_frames_dropped(streaming->GetOutput()); } rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); @@ -411,8 +412,8 @@ void osn::IStreaming::GetTotalFrames(void *data, const int64_t id, const std::ve int totalFrames = 0; - if (streaming->output && obs_output_active(streaming->output)) { - totalFrames = obs_output_get_total_frames(streaming->output); + if (streaming->GetOutput() && obs_output_active(streaming->GetOutput())) { + totalFrames = obs_output_get_total_frames(streaming->GetOutput()); } rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); @@ -429,9 +430,9 @@ void osn::IStreaming::GetKBitsPerSec(void *data, const int64_t id, const std::ve double kbitsPerSec = 0; - if (streaming->output && obs_output_active(streaming->output)) { + if (streaming->GetOutput() && obs_output_active(streaming->GetOutput())) { - uint64_t bytesSent = obs_output_get_total_bytes(streaming->output); + uint64_t bytesSent = obs_output_get_total_bytes(streaming->GetOutput()); uint64_t bytesSentTime = os_gettime_ns(); if (bytesSent < streaming->lastBytesSent) @@ -466,9 +467,9 @@ void osn::IStreaming::GetDataOutput(void *data, const int64_t id, const std::vec double dataOutput = 0; - if (streaming->output && obs_output_active(streaming->output)) { + if (streaming->GetOutput() && obs_output_active(streaming->GetOutput())) { - uint64_t bytesSent = obs_output_get_total_bytes(streaming->output); + uint64_t bytesSent = obs_output_get_total_bytes(streaming->GetOutput()); uint64_t bytesSentTime = os_gettime_ns(); if (bytesSent < streaming->lastBytesSent) @@ -486,4 +487,4 @@ void osn::IStreaming::GetDataOutput(void *data, const int64_t id, const std::vec rval.push_back(ipc::value((uint64_t)ErrorCode::Ok)); rval.push_back(ipc::value(dataOutput)); AUTO_DEBUG; -} +} \ No newline at end of file diff --git a/obs-studio-server/source/osn-streaming.hpp b/obs-studio-server/source/osn-streaming.hpp index e1b0366fb..b94109ec7 100644 --- a/obs-studio-server/source/osn-streaming.hpp +++ b/obs-studio-server/source/osn-streaming.hpp @@ -22,15 +22,18 @@ #include "osn-delay.hpp" #include "osn-reconnect.hpp" #include "osn-network.hpp" -#include "osn-output-signals.hpp" +#include "osn-output.hpp" #include "osn-video-encoder.hpp" +#include "osn-multitrack-video.hpp" #include "nodeobs_configManager.hpp" +#include + namespace osn { -class Streaming : public OutputSignals { +class Streaming : public Output { public: - Streaming() + Streaming() : Output({"start", "stop", "starting", "stopping", "activate", "deactivate", "reconnect", "reconnect_success"}) { videoEncoder = nullptr; streamArchive = nullptr; @@ -40,7 +43,6 @@ class Streaming : public OutputSignals { twitchVODSupported = false; oldMixer_desktopSource1 = 0; oldMixer_desktopSource2 = 0; - signals = {"start", "stop", "starting", "stopping", "activate", "deactivate", "reconnect", "reconnect_success"}; delay = new Delay(); reconnect = new Reconnect(); network = new Network(); @@ -49,6 +51,8 @@ class Streaming : public OutputSignals { } virtual ~Streaming(); + void DeleteOutput() override; + public: obs_encoder_t *videoEncoder; obs_encoder_t *streamArchive; diff --git a/tests/osn-tests/media/bigbuckbunny.mp4 b/tests/osn-tests/media/bigbuckbunny.mp4 new file mode 100644 index 000000000..c70addbfd Binary files /dev/null and b/tests/osn-tests/media/bigbuckbunny.mp4 differ diff --git a/tests/osn-tests/src/test_osn_advanced_streaming.ts b/tests/osn-tests/src/test_osn_advanced_streaming.ts index 8c1ffea18..938e90a07 100644 --- a/tests/osn-tests/src/test_osn_advanced_streaming.ts +++ b/tests/osn-tests/src/test_osn_advanced_streaming.ts @@ -6,13 +6,17 @@ import { ETestErrorMsg, GetErrorMessage } from '../util/error_messages'; import { OBSHandler } from '../util/obs_handler' import { deleteConfigFiles, sleep } from '../util/general'; import { EOBSInputTypes, EOBSOutputSignal, EOBSOutputType } from '../util/obs_enums'; -import { EFPSType } from '../osn'; +import * as inputSettings from '../util/input_settings'; + +import path = require('path'); const testName = 'osn-advanced-streaming'; describe(testName, () => { let obs: OBSHandler; let hasTestFailed: boolean = false; + const mediaPath = path.join(path.normalize(__dirname), '..', 'media'); + // Initialize OBS process before(async() => { logInfo(testName, 'Starting ' + testName + ' tests'); @@ -95,6 +99,63 @@ describe(testName, () => { osn.AdvancedStreamingFactory.destroy(stream); }); + it('Stream with missing video encoder', async function() { + if (obs.isDarwin()) { + this.skip(); + } + const stream = osn.AdvancedStreamingFactory.create(); + stream.service = osn.ServiceFactory.legacySettings; + stream.video = obs.defaultVideoContext; + const track1 = osn.AudioTrackFactory.create(160, 'track1'); + osn.AudioTrackFactory.setAtIndex(track1, 1); + stream.signalHandler = (signal) => {obs.signals.push(signal)}; + + expect(() => { + stream.start(); + }).throw('Invalid video encoder'); + + + osn.AdvancedStreamingFactory.destroy(stream); + }); + + it('Stream with missing service', async function() { + if (obs.isDarwin()) { + this.skip(); + } + const stream = osn.AdvancedStreamingFactory.create(); + stream.videoEncoder = osn.VideoEncoderFactory.create('obs_x264', 'video-encoder'); + stream.video = obs.defaultVideoContext; + const track1 = osn.AudioTrackFactory.create(160, 'track1'); + osn.AudioTrackFactory.setAtIndex(track1, 1); + stream.signalHandler = (signal) => {obs.signals.push(signal)}; + + expect(() => { + stream.start(); + }).throw('Invalid service'); + + + osn.AdvancedStreamingFactory.destroy(stream); + }); + + it('Stream with missing canvas', async function() { + if (obs.isDarwin()) { + this.skip(); + } + const stream = osn.AdvancedStreamingFactory.create(); + stream.service = osn.ServiceFactory.legacySettings; + stream.videoEncoder = osn.VideoEncoderFactory.create('obs_x264', 'video-encoder'); + const track1 = osn.AudioTrackFactory.create(160, 'track1'); + osn.AudioTrackFactory.setAtIndex(track1, 1); + + stream.signalHandler = (signal) => {obs.signals.push(signal)}; + + expect(() => { + stream.start(); + }).throw('Invalid main canvas'); + + osn.AdvancedStreamingFactory.destroy(stream); + }); + it('Start streaming', async function() { if (obs.isDarwin()) { this.skip(); @@ -218,7 +279,7 @@ describe(testName, () => { EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); expect(signalInfo.signal).to.equal( EOBSOutputSignal.Stop, GetErrorMessage(ETestErrorMsg.StreamOutput)); - expect(signalInfo.code).to.equal(-3, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.code).to.equal(-3, GetErrorMessage(ETestErrorMsg.StreamOutput)); stream.service.update({ key: obs.userStreamKey }); diff --git a/tests/osn-tests/src/test_osn_enhanced_broadcasting_advanced_streaming.ts b/tests/osn-tests/src/test_osn_enhanced_broadcasting_advanced_streaming.ts new file mode 100644 index 000000000..127ce4cb5 --- /dev/null +++ b/tests/osn-tests/src/test_osn_enhanced_broadcasting_advanced_streaming.ts @@ -0,0 +1,282 @@ +import 'mocha' +import { expect } from 'chai' +import * as osn from '../osn'; +import { logInfo, logEmptyLine } from '../util/logger'; +import { ETestErrorMsg, GetErrorMessage } from '../util/error_messages'; +import { OBSHandler } from '../util/obs_handler' +import { deleteConfigFiles, sleep } from '../util/general'; +import { EOBSInputTypes, EOBSOutputSignal, EOBSOutputType } from '../util/obs_enums'; +import * as inputSettings from '../util/input_settings'; + +import path = require('path'); + +const testName = 'osn-enhanced-broadcasting-advanced-streaming'; + +describe(testName, () => { + let obs: OBSHandler; + let hasTestFailed: boolean = false; + const mediaPath = path.join(path.normalize(__dirname), '..', 'media'); + let secondContext: osn.IVideo = null; + + // Initialize OBS process + before(async() => { + logInfo(testName, 'Starting ' + testName + ' tests'); + deleteConfigFiles(); + obs = new OBSHandler(testName); + obs.instantiateUserPool(testName); + + // Reserving user from pool + await obs.reserveUser(); + + secondContext = osn.VideoFactory.create(); + const secondVideoInfo: osn.IVideoInfo = { + fpsNum: 60, + fpsDen: 2, + baseWidth: 720, + baseHeight: 1280, + outputWidth: 720, + outputHeight: 1280, + outputFormat: osn.EVideoFormat.NV12, + colorspace: osn.EColorSpace.CS709, + range: osn.ERangeType.Full, + scaleType: osn.EScaleType.Lanczos, + fpsType: osn.EFPSType.Fractional + }; + secondContext.video = secondVideoInfo; + }); + + // Shutdown OBS process + after(async function() { + // Releasing user got from pool + await obs.releaseUser(); + + secondContext.destroy(); + obs.shutdown(); + + if (hasTestFailed === true) { + logInfo(testName, 'One or more test cases failed. Uploading cache'); + await obs.uploadTestCache(); + } + + obs = null; + deleteConfigFiles(); + logInfo(testName, 'Finished ' + testName + ' tests'); + logEmptyLine(); + }); + + afterEach(function() { + if (this.currentTest.state == 'failed') { + hasTestFailed = true; + } + }); + + // TODO: more tests: + // - vertical primary canvas + + it('Enhanced Broadcasting Advanced Streaming Single Canvas', async function() { + if (obs.isDarwin()) { + this.skip(); + } + + if (obs.isCI()) { + // Skipping this test because CI server doesn't have GPU, but you can run it locally + this.skip(); + } + + const stream = osn.EnhancedBroadcastingAdvancedStreamingFactory.create(); + expect(stream).to.not.be.null; + stream.service = osn.ServiceFactory.legacySettings; + // Note: no video encoder set, because it is automatically created by the enhanced broadcasting + stream.delay = osn.DelayFactory.create(); + stream.reconnect = osn.ReconnectFactory.create(); + stream.network = osn.NetworkFactory.create(); + stream.video = obs.defaultVideoContext; + const track1 = osn.AudioTrackFactory.create(160, 'track1'); + osn.AudioTrackFactory.setAtIndex(track1, 1); + stream.signalHandler = (signal) => {obs.signals.push(signal)}; + + stream.start(); + + let signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Starting); + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Starting, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Activate); + + if (signalInfo.signal == EOBSOutputSignal.Stop) { + throw Error(GetErrorMessage(ETestErrorMsg.StreamOutputDidNotStart, signalInfo.code.toString())); + } + + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Activate, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Start); + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Start, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + // Scene setup + const scene = osn.SceneFactory.create('my_scene'); + expect(scene).to.not.be.null; + osn.Global.setOutputSource(0, scene); + + let settings = inputSettings.ffmpegSource; + settings['volume'] = 100; + settings['local_file'] = path.join(mediaPath, "bigbuckbunny.mp4"); + settings['looping'] = true; + const videoSource = osn.InputFactory.create(EOBSInputTypes.FFMPEGSource, 'video_source', settings); + expect(videoSource).to.not.be.null; + + const sceneItem = scene.add(videoSource); + expect(sceneItem).to.not.be.null; + + sceneItem.video = obs.defaultVideoContext; + sceneItem.visible = true; + sceneItem.position = { x: 0, y: 0 }; + + await sleep(1 * 1000); + + expect(stream.droppedFrames).to.not.equal(undefined, "Undefined droppedFrames"); + expect(stream.totalFrames).to.not.equal(undefined, "Undefined totalFrames"); + expect(stream.kbitsPerSec).to.not.equal(undefined, "Undefined kbitsPerSec"); + expect(stream.dataOutput).to.not.equal(undefined, "Undefined dataOutput"); + + stream.stop(); + + // Scene cleanup + osn.Global.setOutputSource(0, null); + sceneItem.remove(); + videoSource.release(); + scene.release(); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Stopping); + + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Stopping, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Stop); + + if (signalInfo.code != 0) { + throw Error(GetErrorMessage( + ETestErrorMsg.StreamOutputStoppedWithError, + signalInfo.code.toString(), signalInfo.error)); + } + + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Stop, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Deactivate); + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Deactivate, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + osn.EnhancedBroadcastingAdvancedStreamingFactory.destroy(stream); + }); + + it('Enhanced Broadcasting Advanced Streaming Dual Canvas', async function() { + if (obs.isDarwin()) { + this.skip(); + } + + if (obs.isCI()) { + // Skipping this test because CI server doesn't have GPU, but you can run it locally + this.skip(); + } + + const stream = osn.EnhancedBroadcastingAdvancedStreamingFactory.create(); + expect(stream).to.not.be.null; + stream.service = osn.ServiceFactory.legacySettings; + // Note: no video encoder set, because it is automatically created by the enhanced broadcasting + stream.delay = osn.DelayFactory.create(); + stream.reconnect = osn.ReconnectFactory.create(); + stream.network = osn.NetworkFactory.create(); + stream.video = obs.defaultVideoContext; + stream.additionalVideo = secondContext; + const track1 = osn.AudioTrackFactory.create(160, 'track1'); + osn.AudioTrackFactory.setAtIndex(track1, 1); + stream.signalHandler = (signal) => {obs.signals.push(signal)}; + + stream.start(); + + let signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Starting); + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Starting, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Activate); + + if (signalInfo.signal == EOBSOutputSignal.Stop) { + throw Error(GetErrorMessage(ETestErrorMsg.StreamOutputDidNotStart, signalInfo.code.toString())); + } + + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Activate, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Start); + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Start, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + // Scene setup + const scene = osn.SceneFactory.create('my_scene'); + expect(scene).to.not.be.null; + osn.Global.setOutputSource(0, scene); + + let settings = inputSettings.ffmpegSource; + settings['volume'] = 100; + settings['local_file'] = path.join(mediaPath, "bigbuckbunny.mp4"); + settings['looping'] = true; + const videoSource = osn.InputFactory.create(EOBSInputTypes.FFMPEGSource, 'video_source', settings); + expect(videoSource).to.not.be.null; + + // Item on the horizontal canvas + const sceneItem1 = scene.add(videoSource); + expect(sceneItem1).to.not.be.null; + sceneItem1.video = obs.defaultVideoContext; + sceneItem1.visible = true; + sceneItem1.position = { x: 0, y: 0 }; + + // Item on the vertical canvas + const sceneItem2 = scene.add(videoSource); + expect(sceneItem2).to.not.be.null; + sceneItem2.video = secondContext; + sceneItem2.visible = true; + sceneItem2.position = { x: 20, y: 20 }; + sceneItem2.scale = {x: 0.5, y: 0.5}; + + await sleep(1 * 1000); + + expect(stream.droppedFrames).to.not.equal(undefined, "Undefined droppedFrames"); + expect(stream.totalFrames).to.not.equal(undefined, "Undefined totalFrames"); + expect(stream.kbitsPerSec).to.not.equal(undefined, "Undefined kbitsPerSec"); + expect(stream.dataOutput).to.not.equal(undefined, "Undefined dataOutput"); + + stream.stop(); + + // Scene cleanup + osn.Global.setOutputSource(0, null); + sceneItem1.remove(); + sceneItem2.remove(); + videoSource.release(); + scene.release(); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Stopping); + + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Stopping, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Stop); + + if (signalInfo.code != 0) { + throw Error(GetErrorMessage( + ETestErrorMsg.StreamOutputStoppedWithError, + signalInfo.code.toString(), signalInfo.error)); + } + + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Stop, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Deactivate); + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Deactivate, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + osn.EnhancedBroadcastingAdvancedStreamingFactory.destroy(stream); + }); +}); + diff --git a/tests/osn-tests/src/test_osn_enhanced_broadcasting_simple_streaming.ts b/tests/osn-tests/src/test_osn_enhanced_broadcasting_simple_streaming.ts new file mode 100644 index 000000000..776a87750 --- /dev/null +++ b/tests/osn-tests/src/test_osn_enhanced_broadcasting_simple_streaming.ts @@ -0,0 +1,276 @@ +import 'mocha' +import { expect } from 'chai' +import * as osn from '../osn'; +import { logInfo, logEmptyLine } from '../util/logger'; +import { ETestErrorMsg, GetErrorMessage } from '../util/error_messages'; +import { OBSHandler } from '../util/obs_handler' +import { deleteConfigFiles, sleep } from '../util/general'; +import { EOBSInputTypes, EOBSOutputSignal, EOBSOutputType } from '../util/obs_enums'; +import * as inputSettings from '../util/input_settings'; + +import path = require('path'); + +const testName = 'osn-enhanced-broadcasting-simple-streaming'; + +describe(testName, () => { + let obs: OBSHandler; + let hasTestFailed: boolean = false; + const mediaPath = path.join(path.normalize(__dirname), '..', 'media'); + let secondContext: osn.IVideo = null; + + // Initialize OBS process + before(async() => { + logInfo(testName, 'Starting ' + testName + ' tests'); + deleteConfigFiles(); + obs = new OBSHandler(testName); + + obs.instantiateUserPool(testName); + + // Reserving user from pool + await obs.reserveUser(); + + secondContext = osn.VideoFactory.create(); + const secondVideoInfo: osn.IVideoInfo = { + fpsNum: 60, + fpsDen: 2, + baseWidth: 720, + baseHeight: 1280, + outputWidth: 720, + outputHeight: 1280, + outputFormat: osn.EVideoFormat.NV12, + colorspace: osn.EColorSpace.CS709, + range: osn.ERangeType.Full, + scaleType: osn.EScaleType.Lanczos, + fpsType: osn.EFPSType.Fractional + }; + secondContext.video = secondVideoInfo; + }); + + // Shutdown OBS process + after(async function() { + // Releasing user got from pool + await obs.releaseUser(); + + secondContext.destroy(); + obs.shutdown(); + + if (hasTestFailed === true) { + logInfo(testName, 'One or more test cases failed. Uploading cache'); + await obs.uploadTestCache(); + } + + obs = null; + deleteConfigFiles(); + logInfo(testName, 'Finished ' + testName + ' tests'); + logEmptyLine(); + }); + + afterEach(function() { + if (this.currentTest.state == 'failed') { + hasTestFailed = true; + } + }); + + it('Enhanced Broadcasting Simple Streaming Single Canvas', async function() { + if (obs.isDarwin()) { + this.skip(); + } + + if (obs.isCI()) { + // Skipping this test because CI server doesn't have GPU, but you can run it locally + this.skip(); + } + + const stream = osn.EnhancedBroadcastingSimpleStreamingFactory.create(); + // Note: no video encoder set, because it is automatically created by the enhanced broadcasting + stream.service = osn.ServiceFactory.legacySettings; + stream.delay = osn.DelayFactory.create(); + stream.reconnect = osn.ReconnectFactory.create(); + stream.network = osn.NetworkFactory.create(); + stream.video = obs.defaultVideoContext; + stream.audioEncoder = osn.AudioEncoderFactory.create(); + stream.signalHandler = (signal) => {obs.signals.push(signal)}; + + stream.start(); + + let signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Starting); + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Starting, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Activate); + + if (signalInfo.signal == EOBSOutputSignal.Stop) { + throw Error(GetErrorMessage( + ETestErrorMsg.StreamOutputDidNotStart, signalInfo.code.toString(), signalInfo.error)); + } + + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Activate, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Start); + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Start, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + // Scene setup + const scene = osn.SceneFactory.create('my_scene'); + expect(scene).to.not.be.null; + osn.Global.setOutputSource(0, scene); + + let settings = inputSettings.ffmpegSource; + settings['volume'] = 100; + settings['local_file'] = path.join(mediaPath, "bigbuckbunny.mp4"); + settings['looping'] = true; + const videoSource = osn.InputFactory.create(EOBSInputTypes.FFMPEGSource, 'video_source', settings); + expect(videoSource).to.not.be.null; + + const sceneItem = scene.add(videoSource); + expect(sceneItem).to.not.be.null; + sceneItem.video = obs.defaultVideoContext; + sceneItem.visible = true; + sceneItem.position = { x: 0, y: 0 }; + + await sleep(1 * 1000); + + expect(stream.droppedFrames).to.not.equal(undefined, "Undefined droppedFrames"); + expect(stream.totalFrames).to.not.equal(undefined, "Undefined totalFrames"); + expect(stream.kbitsPerSec).to.not.equal(undefined, "Undefined kbitsPerSec"); + expect(stream.dataOutput).to.not.equal(undefined, "Undefined dataOutput"); + + stream.stop(); + + // Scene cleanup + osn.Global.setOutputSource(0, null); + sceneItem.remove(); + videoSource.release(); + scene.release(); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Stopping); + + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Stopping, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Stop); + + if (signalInfo.code != 0) { + throw Error(GetErrorMessage( + ETestErrorMsg.StreamOutputStoppedWithError, + signalInfo.code.toString(), signalInfo.error)); + } + + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Stop, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Deactivate); + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Deactivate, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + osn.EnhancedBroadcastingSimpleStreamingFactory.destroy(stream); + }); + + it('Enhanced Broadcasting Simple Streaming Dual Canvas', async function() { + if (obs.isDarwin()) { + this.skip(); + } + + if (obs.isCI()) { + // Skipping this test because CI server doesn't have GPU, but you can run it locally + this.skip(); + } + + const stream = osn.EnhancedBroadcastingSimpleStreamingFactory.create(); + expect(stream).to.not.be.null; + stream.service = osn.ServiceFactory.legacySettings; + // Note: no video encoder set, because it is automatically created by the enhanced broadcasting + stream.delay = osn.DelayFactory.create(); + stream.reconnect = osn.ReconnectFactory.create(); + stream.network = osn.NetworkFactory.create(); + stream.video = obs.defaultVideoContext; + stream.additionalVideo = secondContext; + stream.audioEncoder = osn.AudioEncoderFactory.create(); + stream.signalHandler = (signal) => {obs.signals.push(signal)}; + + stream.start(); + + let signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Starting); + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Starting, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Activate); + + if (signalInfo.signal == EOBSOutputSignal.Stop) { + throw Error(GetErrorMessage(ETestErrorMsg.StreamOutputDidNotStart, signalInfo.code.toString())); + } + + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Activate, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Start); + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Start, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + // Scene setup + const scene = osn.SceneFactory.create('my_scene'); + expect(scene).to.not.be.null; + osn.Global.setOutputSource(0, scene); + + let settings = inputSettings.ffmpegSource; + settings['volume'] = 100; + settings['local_file'] = path.join(mediaPath, "bigbuckbunny.mp4"); + settings['looping'] = true; + const videoSource = osn.InputFactory.create(EOBSInputTypes.FFMPEGSource, 'video_source', settings); + expect(videoSource).to.not.be.null; + + // Item on the horizontal canvas + const sceneItem1 = scene.add(videoSource); + expect(sceneItem1).to.not.be.null; + sceneItem1.video = obs.defaultVideoContext; + sceneItem1.visible = true; + sceneItem1.position = { x: 0, y: 0 }; + + // Item on the vertical canvas + const sceneItem2 = scene.add(videoSource); + expect(sceneItem2).to.not.be.null; + sceneItem2.video = secondContext; + sceneItem2.visible = true; + sceneItem2.position = { x: 20, y: 20 }; + sceneItem2.scale = {x: 0.5, y: 0.5}; + + await sleep(1 * 1000); + + expect(stream.droppedFrames).to.not.equal(undefined, "Undefined droppedFrames"); + expect(stream.totalFrames).to.not.equal(undefined, "Undefined totalFrames"); + expect(stream.kbitsPerSec).to.not.equal(undefined, "Undefined kbitsPerSec"); + expect(stream.dataOutput).to.not.equal(undefined, "Undefined dataOutput"); + + stream.stop(); + + // Scene cleanup + osn.Global.setOutputSource(0, null); + sceneItem1.remove(); + sceneItem2.remove(); + videoSource.release(); + scene.release(); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Stopping); + + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Stopping, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Stop); + + if (signalInfo.code != 0) { + throw Error(GetErrorMessage( + ETestErrorMsg.StreamOutputStoppedWithError, + signalInfo.code.toString(), signalInfo.error)); + } + + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Stop, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + signalInfo = await obs.getNextSignalInfo(EOBSOutputType.Streaming, EOBSOutputSignal.Deactivate); + expect(signalInfo.type).to.equal(EOBSOutputType.Streaming, GetErrorMessage(ETestErrorMsg.StreamOutput)); + expect(signalInfo.signal).to.equal(EOBSOutputSignal.Deactivate, GetErrorMessage(ETestErrorMsg.StreamOutput)); + + osn.EnhancedBroadcastingSimpleStreamingFactory.destroy(stream); + }); +}); diff --git a/tests/osn-tests/src/test_osn_simple_streaming.ts b/tests/osn-tests/src/test_osn_simple_streaming.ts index 97471ddd0..21e262a06 100644 --- a/tests/osn-tests/src/test_osn_simple_streaming.ts +++ b/tests/osn-tests/src/test_osn_simple_streaming.ts @@ -5,13 +5,16 @@ import { logInfo, logEmptyLine } from '../util/logger'; import { ETestErrorMsg, GetErrorMessage } from '../util/error_messages'; import { OBSHandler } from '../util/obs_handler' import { deleteConfigFiles, sleep } from '../util/general'; -import { EOBSInputTypes, EOBSOutputSignal, EOBSOutputType } from '../util/obs_enums'; +import { EOBSOutputSignal, EOBSOutputType } from '../util/obs_enums'; + +import path = require('path'); const testName = 'osn-simple-streaming'; describe(testName, () => { let obs: OBSHandler; let hasTestFailed: boolean = false; + const mediaPath = path.join(path.normalize(__dirname), '..', 'media'); // Initialize OBS process before(async() => { @@ -81,6 +84,77 @@ describe(testName, () => { osn.SimpleStreamingFactory.destroy(stream); }); + it('Stream with missing video encoder', async function() { + if (obs.isDarwin()) { + this.skip(); + } + const stream = osn.SimpleStreamingFactory.create(); + stream.service = osn.ServiceFactory.legacySettings; + stream.video = obs.defaultVideoContext; + stream.audioEncoder = osn.AudioEncoderFactory.create(); + stream.signalHandler = (signal) => {obs.signals.push(signal)}; + + expect(() => { + stream.start(); + }).throw('Invalid video encoder'); + + + osn.SimpleStreamingFactory.destroy(stream); + }); + + it('Stream with missing audio encoder', async function() { + if (obs.isDarwin()) { + this.skip(); + } + const stream = osn.SimpleStreamingFactory.create(); + stream.videoEncoder = osn.VideoEncoderFactory.create('obs_x264', 'video-encoder'); + stream.service = osn.ServiceFactory.legacySettings; + stream.video = obs.defaultVideoContext; + stream.signalHandler = (signal) => {obs.signals.push(signal)}; + + expect(() => { + stream.start(); + }).throw('Invalid audio encoder'); + + + osn.SimpleStreamingFactory.destroy(stream); + }); + + it('Stream with missing service', async function() { + if (obs.isDarwin()) { + this.skip(); + } + const stream = osn.SimpleStreamingFactory.create(); + stream.videoEncoder = osn.VideoEncoderFactory.create('obs_x264', 'video-encoder'); + stream.video = obs.defaultVideoContext; + stream.audioEncoder = osn.AudioEncoderFactory.create(); + stream.signalHandler = (signal) => {obs.signals.push(signal)}; + + expect(() => { + stream.start(); + }).throw('Invalid service'); + + + osn.SimpleStreamingFactory.destroy(stream); + }); + + it('Stream with missing canvas', async function() { + if (obs.isDarwin()) { + this.skip(); + } + const stream = osn.SimpleStreamingFactory.create(); + stream.videoEncoder = osn.VideoEncoderFactory.create('obs_x264', 'video-encoder'); + stream.service = osn.ServiceFactory.legacySettings; + stream.audioEncoder = osn.AudioEncoderFactory.create(); + stream.signalHandler = (signal) => {obs.signals.push(signal)}; + + expect(() => { + stream.start(); + }).throw('Invalid main canvas'); + + osn.SimpleStreamingFactory.destroy(stream); + }); + it('Start streaming', async function() { if (obs.isDarwin()) { this.skip(); diff --git a/tests/osn-tests/util/obs_handler.ts b/tests/osn-tests/util/obs_handler.ts index 4f2a4bb3b..947e074c8 100644 --- a/tests/osn-tests/util/obs_handler.ts +++ b/tests/osn-tests/util/obs_handler.ts @@ -82,6 +82,7 @@ export class OBSHandler { filterTypes: string[]; transitionTypes: string[]; os: string; + ci: boolean; userStreamKey: string; defaultVideoContext: osn.IVideo; @@ -90,6 +91,7 @@ export class OBSHandler { this.os = process.platform; this.osnTestName = testName; this.cacheUploader = new CacheUploader(testName, this.obsPath); + this.ci = process.env.CI === 'true'; this.startup(); if (needDefaultVideoContext) { this.createDefaultVideoContext(); @@ -314,7 +316,7 @@ export class OBSHandler { skipSource(inputType: string) { if (process.platform === 'darwin') { - if (inputType === 'browser_source' || + if (inputType === 'browser_source' || inputType === 'window_capture' || inputType === 'monitor_capture' || inputType === 'display_capture' || @@ -342,4 +344,10 @@ export class OBSHandler { // Wrapped this in a function- just incase we want to add more conditions later or disable only within the build agent. return this.os === 'darwin'; } + + // is the build server environment + isCI() + { + return this.ci; + } }