Mimic Twitch dual stream display coercion for YouTube dual stream. (#6178)

* Fix dual stream display coercion and enhanced broadcasting disabling.

* Fix title persistence.

* Remove redundant if

* YouTube mirror Twitch dual stream coercion.

* Add missing streaming view changes.

* Update youtube.ts

---------

Co-authored-by: mhoyer-streamlabs <mhoyer@logitech.com>

Author: michelinewu

app/components-react/windows/go-live/useGoLiveSettings.ts

@@ -644,8 +644,7 @@ export class GoLiveSettingsModule {
     // Go Live window.
     const willDualStream = this.state.enabledPlatforms.some(
       (platform: TPlatform) =>
-        this.state.getCanDualStream(platform) &&
-        this.state.settings.platforms[platform]?.display === 'both',
+        this.state.getCanDualStream(platform) && this.state.isDualStreaming(platform),
     );
 
     const numTargets =
@@ -946,9 +945,7 @@ export class GoLiveSettingsModule {
   get nonPrimeBothDisplayPlatform(): TPlatform | null {
     if (this.isPrime) return null;
     return (
-      this.state.enabledPlatforms.find(
-        platform => this.state.settings.platforms[platform]?.display === 'both',
-      ) ?? null
+      this.state.enabledPlatforms.find(platform => this.state.isDualStreaming(platform)) ?? null
     );
   }
 

app/services/platforms/twitch.ts

@@ -246,7 +246,7 @@ export class TwitchService
     // depends on whether this stream is an enhanced broadcast — deciding afterwards means the
     // check answers for the previous stream instead of this one.
     if (channelInfo) {
-      if (this.streamingService.views.isLiveOutputEditingEnabled) {
+      if (goLiveSettings?.liveOutputEditing) {
         await this.setupLiveOutputStream(goLiveSettings);
       } else if (channelInfo.display === 'both') {
         await this.setupDualStream(goLiveSettings);

app/services/platforms/youtube.ts

@@ -37,15 +37,6 @@ interface IYoutubeServiceState extends IPlatformState {
   broadcastStatus: TBroadcastLifecycleStatus | '';
   settings: IYoutubeStartStreamOptions;
   categories: IYoutubeCategory[];
-  backupStreamSettings?: IBackUpStreamSettings;
-}
-
-interface IBackUpStreamSettings {
-  service: string;
-  key: string;
-  server: string;
-  streamType: 'rtmp_common' | 'rtmp_custom' | 'whip_custom';
-  context: TDisplayType;
 }
 
 export interface IYoutubeStartStreamOptions extends IExtraBroadcastSettings {
@@ -488,7 +479,29 @@ export class YoutubeService
     this.setPlatformContext('youtube');
   }
 
+  /**
+   * Prepare the stream for live output editing
+   * @remark Live output editing cannot dual stream. As a safety measure, if there is
+   * any local vertical broadcast data on state, clear it
+   */
+  async setupLiveOutputStream(options?: IGoLiveSettings): Promise<void> {
+    if (!this.state.verticalStreamKey && !this.state.verticalBroadcast.id) return;
+
+    const destinations = this.streamingService.views.customDestinations.filter(
+      dest => dest.streamKey !== this.state.verticalStreamKey,
+    );
+
+    this.SET_VERTICAL_BROADCAST({} as IYoutubeLiveBroadcast);
+    this.SET_VERTICAL_STREAM_KEY('');
+    this.streamSettingsService.setGoLiveSettings({ customDestinations: destinations });
+  }
+
   async setupDualStream(goLiveSettings: IGoLiveSettings) {
+    // Live output editing currently cannot use dual stream so guard against it
+    if (goLiveSettings.liveOutputEditing) {
+      return;
+    }
+
     const ytSettings = getDefined(goLiveSettings.platforms.youtube);
     const title = makeVerticalTitle(ytSettings.title);
 
@@ -602,17 +615,6 @@ export class YoutubeService
     // setup key and platform type in the OBS settings
     const streamKey = stream.cdn.ingestionInfo.streamName;
 
-    //save user's current rtmp_common settings to restore after Go Live since they are overwritten here
-    const currentSettings = this.streamSettingsService.settings;
-    if (!this.state.backupStreamSettings) {
-      this.state.backupStreamSettings = {} as IBackUpStreamSettings;
-    }
-    this.state.backupStreamSettings.service = currentSettings.service;
-    this.state.backupStreamSettings.key = currentSettings.key;
-    this.state.backupStreamSettings.server = currentSettings.server;
-    this.state.backupStreamSettings.streamType = currentSettings.streamType;
-    this.state.backupStreamSettings.context = !context ? 'horizontal' : context;
-
     if (!this.streamingService.views.isMultiplatformMode) {
       // Note: This was previously changed to `rtmp_custom` for dual streaming but
       // it now works with `rtmp_common` as well.
@@ -627,7 +629,10 @@ export class YoutubeService
       );
     }
 
-    if (ytSettings.display === 'both') {
+    // Live output editing is checked first so dual stream is never set up when live output editing is enabled.
+    if (goLiveSettings.liveOutputEditing) {
+      await this.setupLiveOutputStream(goLiveSettings);
+    } else if (ytSettings.display === 'both') {
       try {
         // Prevent rate limit errors by delaying the dual stream setup by 1 second
         await new Promise<void>(resolve => {
@@ -684,20 +689,6 @@ export class YoutubeService
     this.SET_VERTICAL_BROADCAST({} as IYoutubeLiveBroadcast);
     this.SET_VERTICAL_STREAM_KEY('');
     this.streamSettingsService.setGoLiveSettings({ customDestinations: destinations });
-
-    //restore user's previous settings in case they were overwritten on Go Live
-    if (this.state.backupStreamSettings) {
-      this.streamSettingsService.setSettings(
-        {
-          platform: 'youtube',
-          service: this.state.backupStreamSettings.service,
-          key: this.state.backupStreamSettings.key,
-          streamType: this.state.backupStreamSettings.streamType,
-          server: this.state.backupStreamSettings.server,
-        },
-        this.state.backupStreamSettings.context,
-      );
-    }
   }
 
   /**

app/services/streaming/streaming-view.ts

@@ -195,9 +195,21 @@ export class StreamInfoView<T extends Object> extends ViewHandler<T> {
     );
   }
 
+  /**
+   * Whether a platform is set to dual stream to both displays
+   * @remark The saved `both` display is deliberately left intact in `getSavedPlatformSettings`
+   * because reassigning it would destroy the user's dual stream choice.
+   * @param platform - The platform to check
+   */
+  isDualStreaming(platform: TPlatform): boolean {
+    if (this.isLiveOutputEditingEnabled) return false;
+    return this.settings.platforms[platform]?.display === 'both';
+  }
+
   get isTwitchDualStreamEnabled() {
     // Twitch dual stream requires enhanced broadcasting, which is not available with live output editing
     // because enhanced broadcasting cannot use restream service due to api requirements
+    // Note: redundant with the guard inside `isDualStreaming`, kept as defence in depth
     if (this.isLiveOutputEditingEnabled) {
       return false;
     }
@@ -209,7 +221,7 @@ export class StreamInfoView<T extends Object> extends ViewHandler<T> {
     return (
       this.settings.platforms?.twitch &&
       this.enabledPlatforms.includes('twitch') &&
-      this.settings.platforms?.twitch.display === 'both'
+      this.isDualStreaming('twitch')
     );
   }
 
@@ -221,7 +233,7 @@ export class StreamInfoView<T extends Object> extends ViewHandler<T> {
     return (
       this.settings.platforms?.youtube &&
       this.enabledPlatforms.includes('youtube') &&
-      this.settings.platforms?.youtube?.display === 'both'
+      this.isDualStreaming('youtube')
     );
   }
 
@@ -473,7 +485,7 @@ export class StreamInfoView<T extends Object> extends ViewHandler<T> {
 
         // if the platform is set to 'both' display, add it to both horizontal and vertical
         // for analytics purposes
-        if (this.settings.platforms[platform]?.display === 'both') {
+        if (this.isDualStreaming(platform)) {
           displayPlatforms.vertical.push(platform);
         }
 
@@ -577,8 +589,7 @@ export class StreamInfoView<T extends Object> extends ViewHandler<T> {
   get hasDualStream() {
     return this.enabledPlatforms.some(
       (platform: TPlatform) =>
-        this.supports('dualStream', [platform]) &&
-        this.settings.platforms[platform]?.display === 'both',
+        this.supports('dualStream', [platform]) && this.isDualStreaming(platform),
     );
   }
 

app/services/streaming/streaming.ts

@@ -973,13 +973,13 @@ export class StreamingService
     }
 
     // send analytics for YouTube
-    if (settings.platforms.youtube?.enabled && settings.platforms.youtube.display === 'both') {
+    if (settings.platforms.youtube?.enabled && this.views.isDualStreaming('youtube')) {
       this.usageStatisticsService.recordFeatureUsage('StreamToYouTubeBothOutputs');
     }
 
     // send analytics for Twitch
     if (settings.platforms.twitch?.enabled) {
-      if (settings.platforms.twitch.display === 'both') {
+      if (this.views.isDualStreaming('twitch')) {
         this.usageStatisticsService.recordFeatureUsage('StreamToTwitchBothOutputs');
       } else if (this.state.enhancedBroadcasting) {
         // Note: use the service state because the Twitch settings stores the user's enhanced broadcasting setting