gramps
70fcf89f9e
Build 730 (creator): - Left pill while recording: solid #2ECC71 dot pulsing 1.0 <-> 0.2 on the existing one-second timer, and "REC: hh:mm:ss" in Consolas so the digits cannot jitter the pill's width. Idle face unchanged. - Right pill while recording: a stop square and "Stop Recording"; clicking it runs the normal stop, which halts and resets the clock and returns the pair to "Local MP4" / "Start Recording". - The separate reality line (dot + REC/LIVE + elapsed + End) is now LIVE-ONLY: a recording would otherwise print the same three facts twice. RunningVisible is IsLive, and ShowOutputStage no longer hides itself for a recording (it must be on screen to carry the clock and the stop). Two rules collided and are now separated rather than merged: a creator's Stop on a recording restores the Local MP4 pair (build 730), while a pipeline FAILURE still clears both pills (the 2026-09-01 zombie rule). StopStream(afterFailure:) carries the difference, and the pump-failure path passes it. RealAppHost.Run was rethrowing with `throw failure;`, which destroyed the original stack — a failing assertion inside the action reported the wrapper's line instead of its own. ExceptionDispatchInfo now preserves it; that is how the two failures above were located in one pass instead of five. 680 pass (one audio-pipe instance flake under full-suite load, passes alone), 0 warnings. Scope justification: Assets/starting-background.jpg is outside this unit — the creator's replacement art, still awaiting their visual check.
563 lines
24 KiB
C#
563 lines
24 KiB
C#
using System.Collections.ObjectModel;
|
||
using System.Windows;
|
||
using System.Windows.Input;
|
||
using System.Windows.Threading;
|
||
using ytLive.Helpers;
|
||
using ytLive.Models;
|
||
using ytLive.Services;
|
||
using ytLive.Services.Encoder;
|
||
|
||
namespace ytLive.ViewModels;
|
||
|
||
public partial class MainViewModel : ViewModelBase
|
||
{
|
||
|
||
private readonly DispatcherTimer _liveTimer;
|
||
private readonly DispatcherTimer _healthPollTimer;
|
||
|
||
private StreamStatus _streamStatus = StreamStatus.Offline;
|
||
private StreamHealth _currentHealth = new();
|
||
private string _streamTitle = string.Empty;
|
||
private string _streamDescription = string.Empty;
|
||
private string _streamVisibility = "Private";
|
||
private string? _currentBroadcastId;
|
||
/// <summary>Latches once the broadcast reaches live so the per-poll broadcast
|
||
/// diagnostic stops logging (2026-10-04). Reset at broadcast creation.</summary>
|
||
private bool _broadcastSeenLive;
|
||
private bool _youtubeBroadcastLive;
|
||
private string? _reusableStreamUrl;
|
||
private ReusableStream? _reusableStream;
|
||
private string? _healthIssueBanner;
|
||
private string _healthIssueBackground = "Transparent";
|
||
private string _windowTitle = "LlamaCasty";
|
||
private string _topBarBackground = ThemeBrush.Hex("Brush.SurfaceContainer");
|
||
private string _previewGlowBrush = "Transparent";
|
||
private Thickness _previewGlowThickness = new(0);
|
||
private string _liveElapsedText = "00:00:00";
|
||
private double _recDotPulse = 1.0;
|
||
private TimeSpan _liveElapsed;
|
||
|
||
// ─── Recording (TASK 18): REC / ON-AIR pills — the pills are intent;
|
||
// ─── IsRecording / IsLive are reality. ON-AIR needs a sign-in, and the
|
||
// ─── pills are radio-exclusive (record-OR-live, creator ruling 2026-09-01):
|
||
// ─── arming one clears the other.
|
||
// Local MP4 is the armed output at launch (creator ruling 2026-11-12: "pos = ON (default)").
|
||
// Before that both were unarmed, so the output stage opened with nothing selected.
|
||
private bool _recordPillOn = true;
|
||
private bool _onAirPillOn;
|
||
private bool _isRecording;
|
||
|
||
/// <summary>TASK 41: the current session is a private TEST broadcast — the real
|
||
/// go-live pipeline runs (broadcast create, reusable stream, RTMP push, chat
|
||
/// poll), but the visuals say TEST (top-bar gold + badge), no "last live" stamp
|
||
/// is written, and the Test drawer is open. One flag flips the whole face of the
|
||
/// session; cleared on stop / rollback.</summary>
|
||
private bool _isTestStream;
|
||
|
||
/// <summary>Resolved record folder — the configured choice, or Downloads (0th case).</summary>
|
||
|
||
|
||
private readonly FramePump _framePump;
|
||
|
||
public StreamStatus StreamStatus
|
||
{
|
||
get => _streamStatus;
|
||
set
|
||
{
|
||
if (SetProperty(ref _streamStatus, value))
|
||
{
|
||
_youtubeBroadcastLive = false;
|
||
OnPropertyChanged(nameof(IsOffline));
|
||
OnPropertyChanged(nameof(CanChangeQuality));
|
||
OnPropertyChanged(nameof(IsLive));
|
||
OnPropertyChanged(nameof(IsEditMode));
|
||
OnPropertyChanged(nameof(RecDotBrush));
|
||
OnPropertyChanged(nameof(RecTextBrush));
|
||
OnPropertyChanged(nameof(RecDotOpacity));
|
||
OnPropertyChanged(nameof(OnAirBrush));
|
||
OnPropertyChanged(nameof(IsLivePrivate));
|
||
OnPropertyChanged(nameof(ShowPrimaryStartButton));
|
||
OnPropertyChanged(nameof(PrimaryStartKind));
|
||
OnPropertyChanged(nameof(PrimaryStartButtonLabel));
|
||
OnPropertyChanged(nameof(PrimaryStartCommand));
|
||
OnPropertyChanged(nameof(ShowEndStreamButton));
|
||
OnPropertyChanged(nameof(EndButtonText));
|
||
OnPropertyChanged(nameof(ShowTestButton));
|
||
OnPropertyChanged(nameof(AccountStatusLightToolTip));
|
||
OnPropertyChanged(nameof(ShowChatInactiveMessage));
|
||
OnPropertyChanged(nameof(ShowPreviewPlaceholder));
|
||
RaiseTopBarModes();
|
||
UpdateLiveVisuals();
|
||
}
|
||
}
|
||
}
|
||
|
||
public bool IsOffline => StreamStatus == StreamStatus.Offline;
|
||
public bool IsLive => StreamStatus == StreamStatus.Streaming;
|
||
public bool CanChangeQuality => IsOffline && !IsRecording;
|
||
public bool IsLivePrivate => IsLive && string.Equals(StreamVisibility, "Private", StringComparison.OrdinalIgnoreCase);
|
||
public string RecDotBrush => !IsRecording
|
||
? ThemeBrush.Hex("Brush.OnSurfaceDisabled")
|
||
: ThemeBrush.Hex("Brush.Primary");
|
||
public string RecTextBrush => (IsLive || IsRecording)
|
||
? ThemeBrush.Hex("Brush.OnSurface")
|
||
: ThemeBrush.Hex("Brush.OnSurfaceDisabled");
|
||
public double RecDotOpacity => IsRecording ? _recDotPulse : 0.55;
|
||
public string OnAirBrush => !IsLive
|
||
? ThemeBrush.Hex("Brush.OnSurfaceDisabled")
|
||
: IsLivePrivate
|
||
? ThemeBrush.Hex("Brush.Positive")
|
||
: ThemeBrush.Hex("Brush.Primary");
|
||
|
||
// ─── REC / ON-AIR pills (TASK 18) ───
|
||
public bool RecordPillOn
|
||
{
|
||
get => _recordPillOn;
|
||
set
|
||
{
|
||
if (!SetProperty(ref _recordPillOn, value)) return;
|
||
if (value && _onAirPillOn) OnAirPillOn = false; // record-OR-live — arming REC drops ON-AIR
|
||
RaiseOutputStage();
|
||
OnPropertyChanged(nameof(ShowPrimaryStartButton));
|
||
OnPropertyChanged(nameof(PrimaryStartKind));
|
||
OnPropertyChanged(nameof(PrimaryStartButtonLabel));
|
||
OnPropertyChanged(nameof(PrimaryStartCommand));
|
||
OnPropertyChanged(nameof(CanStartSession));
|
||
RaiseTopBarModes();
|
||
}
|
||
}
|
||
|
||
public bool OnAirPillOn
|
||
{
|
||
get => _onAirPillOn;
|
||
set
|
||
{
|
||
// Armable signed-out (creator ruling 2026-09-20: a greyed pill was a
|
||
// dead end — intent must be able to light while offline). The pill is
|
||
// intent, not reality; the Start face turns this into a sign-in.
|
||
if (!SetProperty(ref _onAirPillOn, value)) return;
|
||
if (value && _recordPillOn) RecordPillOn = false; // record-OR-live — arming ON-AIR drops REC
|
||
RaiseOutputStage();
|
||
OnPropertyChanged(nameof(ShowPrimaryStartButton));
|
||
OnPropertyChanged(nameof(PrimaryStartKind));
|
||
OnPropertyChanged(nameof(PrimaryStartButtonLabel));
|
||
OnPropertyChanged(nameof(PrimaryStartCommand));
|
||
OnPropertyChanged(nameof(CanStartSession));
|
||
RaiseTopBarModes();
|
||
}
|
||
}
|
||
|
||
/// <summary>Whether the session is actively recording — the REC status light
|
||
/// turns green only when this is true (the pill is intent, this is reality).
|
||
/// Internal setter is a test seam (same pattern as LayoutPathOverride) so the
|
||
/// failure-rollback path can be exercised without running the real pipeline.</summary>
|
||
public bool IsRecording
|
||
{
|
||
get => _isRecording;
|
||
internal set
|
||
{
|
||
if (!SetProperty(ref _isRecording, value)) return;
|
||
OnPropertyChanged(nameof(CanChangeQuality));
|
||
OnPropertyChanged(nameof(RecDotBrush));
|
||
OnPropertyChanged(nameof(RecTextBrush));
|
||
OnPropertyChanged(nameof(RecDotOpacity));
|
||
OnPropertyChanged(nameof(IsEditMode));
|
||
OnPropertyChanged(nameof(ShowEndStreamButton));
|
||
OnPropertyChanged(nameof(ShowPrimaryStartButton));
|
||
OnPropertyChanged(nameof(PrimaryStartKind));
|
||
OnPropertyChanged(nameof(PrimaryStartButtonLabel));
|
||
OnPropertyChanged(nameof(PrimaryStartCommand));
|
||
OnPropertyChanged(nameof(EndButtonText));
|
||
OnPropertyChanged(nameof(ShowTestButton));
|
||
RaiseTopBarModes();
|
||
UpdateSessionTimer();
|
||
}
|
||
}
|
||
|
||
/// <summary>The primary button is ALWAYS the idle face of the top bar (2026-09-01):
|
||
/// stopping a session used to hide every start affordance (pills clear on stop,
|
||
/// and the old gate needed a sign-in or a lit pill — signed-out creators found a
|
||
/// blank bar). No dead ends: an unarmed Start records (local needs no account);
|
||
/// sign-in lives in the Start context menu.</summary>
|
||
public bool ShowPrimaryStartButton => IsOffline && !IsRecording && !IsOffAirAfterDrop;
|
||
|
||
/// <summary>Either output selected makes the button actionable.</summary>
|
||
public bool CanStartSession => RecordPillOn || OnAirPillOn;
|
||
|
||
/// <summary>Face of the Go button names the armed world (top bar redesign): the
|
||
/// bar renders only ONE world at a time, so the button never has to explain
|
||
/// itself — it says exactly what pressing it will do. A signed-out ON-AIR Start
|
||
/// routes to the sign-in inside StartSession (Start — the account step shows up
|
||
/// beside it as the Sign In button); a signed-out go-live stays the dead-end the
|
||
/// creator ruling 2026-09-20-02 forbids.</summary>
|
||
/// <summary>Creator ruling 2026-10-30: EDIT decides whether the ON-AIR start is the real
|
||
/// livestream or the test one, which is why the separate TEST button is gone.</summary>
|
||
public SessionStartKind PrimaryStartKind =>
|
||
SessionStartDecision.For(RecordPillOn, OnAirPillOn);
|
||
|
||
public string PrimaryStartButtonLabel => SessionStartDecision.LabelFor(PrimaryStartKind);
|
||
|
||
private ICommand? _primaryStartCommand;
|
||
|
||
/// <summary>The button's action follows its label — and a signed-out ON-AIR press starts the
|
||
/// SIGN-IN flow instead of disabling the control (which is what binding straight to
|
||
/// <see cref="StartTestCommand"/> did: its CanExecute needs a connection, so the button the
|
||
/// creator was told to press could not be pressed).</summary>
|
||
public ICommand PrimaryStartCommand =>
|
||
_primaryStartCommand ??= new RelayCommand(_ => StartFromPrimaryButton(), _ => ShowPrimaryStartButton);
|
||
|
||
private void StartFromPrimaryButton()
|
||
{
|
||
switch (SessionStartDecision.RouteFor(PrimaryStartKind, IsConnected))
|
||
{
|
||
case SessionStartDecision.Route.SignIn:
|
||
_ = SignInAsync();
|
||
return;
|
||
case SessionStartDecision.Route.Test:
|
||
BeginTestStream();
|
||
return;
|
||
default:
|
||
StartSession();
|
||
return;
|
||
}
|
||
}
|
||
|
||
/// <summary>The End button shows while recording OR live.</summary>
|
||
public bool ShowEndStreamButton => IsLive || IsRecording;
|
||
|
||
/// <summary>The one button whose label changes: while recording it reads
|
||
/// "Stop Recording", while live "End Stream" — and while a test broadcast runs,
|
||
/// "End Test" so the creator knows exactly what they're stopping.</summary>
|
||
public string EndButtonText =>
|
||
IsRecording && !IsLive ? "Stop Recording"
|
||
: IsTestStream ? "End Test"
|
||
: "End Live Stream";
|
||
|
||
/// <summary>TASK 41 — Test is a child of Stream (creator ruling: "Test should only
|
||
/// proc when we've selected stream"): a dry-run of the livestream, so it exists
|
||
/// ONLY inside the armed ON-AIR world, signed-in and idle. You can't dry-run a
|
||
/// recording, so the Record world never offers it.</summary>
|
||
public bool ShowTestButton => ShowStreamActions && IsConnected;
|
||
|
||
public bool CanStartTest => ShowTestButton;
|
||
|
||
// ─── Top bar worlds / reality line (top bar redesign) ───
|
||
//
|
||
// The bar is ONE surface rendered by the FIRST decision — Record or Stream —
|
||
// and each world is the whole bar. Idle shows the mode switch + the armed
|
||
// world's actions; the account zone exists only inside the Stream world. While
|
||
// running, the switch and the worlds retire and a single reality line
|
||
// (● word elapsed) + End replace them, so nothing mid-session can be re-armed.
|
||
|
||
/// <summary>Idle — the mode switch is present and actionable.</summary>
|
||
public bool ShowIdleWorld => IsOffline && !IsRecording;
|
||
|
||
/// <summary>Running — the reality line (dot + word + elapsed) + End replace the switch.</summary>
|
||
// Live only: a local recording's status lives in the output pill now (creator, build 730), so its
|
||
// separate dot/elapsed/stop cluster would be a second, redundant set of the same facts.
|
||
public bool RunningVisible => IsLive;
|
||
|
||
/// <summary>Record world: the switch sits on REC and Go says "Start Recording".
|
||
/// No Test — YouTube's stream actions don't exist here. The account zone IS
|
||
/// here: it's app-level identity, not a stream-world widget (creator 2026-09-23).</summary>
|
||
public bool ShowRecordAction => ShowIdleWorld && !OnAirPillOn;
|
||
|
||
/// <summary>Stream world: the switch sits on ON-AIR; Go says "Go Live" and Test
|
||
/// appears.</summary>
|
||
public bool ShowStreamActions => ShowIdleWorld && OnAirPillOn;
|
||
|
||
/// <summary>Account zone is WORLD-INDEPENDENT (creator 2026-09-23): Sign In /
|
||
/// avatar stay put in Record and Stream worlds alike, so the right column never
|
||
/// pops in and out — which pins the bar height (no more bounce between worlds).</summary>
|
||
public bool ShowSignInButton => !IsConnected;
|
||
|
||
/// <summary>The avatar — right-click Change Account / Logout. Always visible when
|
||
/// signed in, Record or Stream.</summary>
|
||
public bool ShowAvatarButton => IsConnected;
|
||
|
||
/// <summary>The reality word: TEST while a test broadcast runs, LIVE while on the
|
||
/// air, REC during a local-record session.</summary>
|
||
public string RunningText => IsReconnecting
|
||
? "RECONNECTING"
|
||
: IsTestStream ? "TEST" : IsLive ? "LIVE" : "REC";
|
||
|
||
/// <summary>Measured facts only while reconnecting: how long, and which attempt. No countdown —
|
||
/// YouTube's cutoff is not a constant we can promise (spec revised 2026-11-05).</summary>
|
||
public string ReconnectDetailText => IsReconnecting
|
||
? $"0:{ReconnectElapsedSeconds:00} · attempt {Math.Max(1, ReconnectAttempt)} of {StreamRetryPolicy.Default.Attempts}"
|
||
: string.Empty;
|
||
|
||
/// <summary>Reality dot color, one meaning per mode: gold = test, red = live,
|
||
/// green = recording. The pre-spec pulsing lamp never shipped; the word + bar
|
||
/// color carry the state and the dot just pins it.</summary>
|
||
public string RunningDotBrush => IsReconnecting
|
||
? ThemeBrush.Hex("Brush.Attention")
|
||
: IsTestStream
|
||
? ThemeBrush.Hex("Brush.TestContainer")
|
||
: IsLive
|
||
? ThemeBrush.Hex("Brush.Primary")
|
||
: ThemeBrush.Hex("Brush.Positive");
|
||
|
||
/// <summary>Raises every flag the top bar renders, so any state change re-renders
|
||
/// exactly the world that is now true.</summary>
|
||
private void RaiseTopBarModes()
|
||
{
|
||
OnPropertyChanged(nameof(ShowIdleWorld));
|
||
OnPropertyChanged(nameof(RunningVisible));
|
||
OnPropertyChanged(nameof(ShowRecordAction));
|
||
OnPropertyChanged(nameof(ShowStreamActions));
|
||
OnPropertyChanged(nameof(ShowSignInButton));
|
||
OnPropertyChanged(nameof(ShowAvatarButton));
|
||
OnPropertyChanged(nameof(ShowTestButton));
|
||
OnPropertyChanged(nameof(CanStartTest));
|
||
OnPropertyChanged(nameof(RunningText));
|
||
OnPropertyChanged(nameof(RunningDotBrush));
|
||
OnPropertyChanged(nameof(PrimaryStartButtonLabel));
|
||
}
|
||
|
||
/// <summary>TASK 41 — the current session is a test broadcast (drives the TEST
|
||
/// badge + gold top bar + "End Test" face). Internal setter is a test seam like
|
||
/// IsRecording: <see cref="BeginTestStream"/> flips it before <see cref="StreamStatus"/>
|
||
/// goes Streaming so the visuals initialize amber, and the stop/rollback path
|
||
/// clears it.</summary>
|
||
public bool IsTestStream
|
||
{
|
||
get => _isTestStream;
|
||
internal set
|
||
{
|
||
if (!SetProperty(ref _isTestStream, value)) return;
|
||
OnPropertyChanged(nameof(EndButtonText));
|
||
RaiseTopBarModes();
|
||
UpdateLiveVisuals();
|
||
}
|
||
}
|
||
|
||
public StreamHealth CurrentHealth
|
||
{
|
||
get => _currentHealth;
|
||
set => SetProperty(ref _currentHealth, value);
|
||
}
|
||
|
||
/// <summary>Report-by-exception YouTube health (TASK 5 item 3): non-null only
|
||
/// while a warning/error configuration issue exists — the banner's text.
|
||
/// good/ok/noData keep it null so nothing renders.</summary>
|
||
public string? HealthIssueBanner
|
||
{
|
||
get => _healthIssueBanner;
|
||
private set => SetProperty(ref _healthIssueBanner, value);
|
||
}
|
||
|
||
/// <summary>Banner background: the error surface for an error issue, the warning surface
|
||
/// for a warning (both tokens). Transparent when no banner is shown.</summary>
|
||
public string HealthIssueBackground
|
||
{
|
||
get => _healthIssueBackground;
|
||
private set => SetProperty(ref _healthIssueBackground, value);
|
||
}
|
||
|
||
public string StreamTitle
|
||
{
|
||
get => _streamTitle;
|
||
set => SetProperty(ref _streamTitle, value);
|
||
}
|
||
|
||
public string StreamDescription
|
||
{
|
||
get => _streamDescription;
|
||
set => SetProperty(ref _streamDescription, value);
|
||
}
|
||
|
||
public string StreamVisibility
|
||
{
|
||
get => _streamVisibility;
|
||
set
|
||
{
|
||
if (SetProperty(ref _streamVisibility, value))
|
||
{
|
||
OnPropertyChanged(nameof(RecDotBrush));
|
||
OnPropertyChanged(nameof(RecTextBrush));
|
||
OnPropertyChanged(nameof(OnAirBrush));
|
||
OnPropertyChanged(nameof(IsLivePrivate));
|
||
}
|
||
}
|
||
}
|
||
|
||
public string WindowTitle
|
||
{
|
||
get => _windowTitle;
|
||
set => SetProperty(ref _windowTitle, value);
|
||
}
|
||
|
||
public string TopBarBackground
|
||
{
|
||
get => _topBarBackground;
|
||
set => SetProperty(ref _topBarBackground, value);
|
||
}
|
||
|
||
internal void ApplyBroadcastLifecycleStatus(string? lifeCycleStatus)
|
||
{
|
||
if (!IsLive) return;
|
||
if (!string.Equals(lifeCycleStatus, "live", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
if (!_broadcastSeenLive)
|
||
_healthPollTimer.Interval = TimeSpan.FromSeconds(2);
|
||
return;
|
||
}
|
||
|
||
_broadcastSeenLive = true;
|
||
_youtubeBroadcastLive = true;
|
||
_healthPollTimer.Interval = TimeSpan.FromSeconds(30);
|
||
UpdateLiveVisuals();
|
||
}
|
||
|
||
public string PreviewGlowBrush
|
||
{
|
||
get => _previewGlowBrush;
|
||
set => SetProperty(ref _previewGlowBrush, value);
|
||
}
|
||
|
||
public Thickness PreviewGlowThickness
|
||
{
|
||
get => _previewGlowThickness;
|
||
set => SetProperty(ref _previewGlowThickness, value);
|
||
}
|
||
|
||
/// <summary>When the current/last streaming session started — the window a session report covers.
|
||
/// Null when no session has run since launch.</summary>
|
||
private DateTime? _sessionStartedAtUtc;
|
||
|
||
public string LiveElapsedText
|
||
{
|
||
get => _liveElapsedText;
|
||
set => SetProperty(ref _liveElapsedText, value);
|
||
}
|
||
|
||
// ─── Broadcast metadata pull-out (the "Text" tab on the Live screen) ───
|
||
|
||
/// <summary>The broadcast id of the current/last session; null until Go Live
|
||
/// succeeds. Gates the pull-out's Update button (nothing remote to patch).</summary>
|
||
public string? CurrentBroadcastId => _currentBroadcastId;
|
||
|
||
public Services.LiveBroadcastFormViewModel BroadcastForm { get; }
|
||
|
||
// ─── Resolution quality dropdown (bottom bar) ───
|
||
// Tiers offered to the creator before going live. First = default. The
|
||
// dropdown is disabled while live because YouTube stream resolution is
|
||
// immutable after stream creation (see TASKS.md compliance notes).
|
||
|
||
// The composition master frame. Every tier is an output rect + target
|
||
// resolution over this frame (see ai.md "Resolution tiers"): 16:9 tiers
|
||
// use the full frame; the vertical tier uses a centered 9:16 window and
|
||
// the preview dims the cropped strips (semi-crop).
|
||
private const double MasterFrameWidth = 1920;
|
||
private const double MasterFrameHeight = 1080;
|
||
|
||
/// <summary>
|
||
/// The shipped ladder. The rate on each tier is the creator-facing target the encoder is asked to
|
||
/// hold (CBR — see <c>FfmpegArgs.AddRateControl</c>), between YouTube's H.264 recommended value
|
||
/// (17 Mbps at 1080p60, 14 at 1080p30, 8 at 720p) and the practitioner sweet spot most guides land
|
||
/// on for YouTube. The old flat 8 Mbps was inherited from TASK 4 as a "mainstream ceiling" — an
|
||
/// unmeasured round number that produced a 5.1 Mbps average. Vertical mirrors its landscape pair:
|
||
/// 1080×1920 is the same pixel count as 1920×1080.
|
||
/// </summary>
|
||
public QualityOption[] QualityOptions { get; } =
|
||
{
|
||
new("1080p60", 60, 12.0, 1920, 1080),
|
||
new("1080p30", 30, 10.0, 1920, 1080),
|
||
new("720p60", 60, 6.0, 1280, 720),
|
||
new("720p30", 30, 6.0, 1280, 720),
|
||
new("Vertical 1080p30", 30, 10.0, 1080, 1920),
|
||
new("Vertical 1080p60", 60, 12.0, 1080, 1920),
|
||
};
|
||
|
||
public string ResolutionHelp { get; } =
|
||
"Pick the highest resolution your upload bandwidth can comfortably sustain. " +
|
||
"Find your upload speed on your ISP plan or with a speed test (e.g. fast.com), " +
|
||
"then choose a tier your upload comfortably exceeds. 1080p60 is the default.";
|
||
|
||
private QualityOption _selectedQuality;
|
||
public QualityOption SelectedQuality
|
||
{
|
||
get => _selectedQuality;
|
||
set
|
||
{
|
||
if (!CanChangeQuality)
|
||
{
|
||
OnPropertyChanged(nameof(SelectedQuality));
|
||
return;
|
||
}
|
||
|
||
if (!HasProOutput && value.RequiresPro)
|
||
{
|
||
OnPropertyChanged(nameof(SelectedQuality));
|
||
return;
|
||
}
|
||
|
||
if (SetProperty(ref _selectedQuality, value))
|
||
{
|
||
ApplyStreamQuality(value);
|
||
OnPropertyChanged(nameof(RatedMbps));
|
||
OnPropertyChanged(nameof(RateHint));
|
||
RefreshRateProposal();
|
||
}
|
||
}
|
||
}
|
||
|
||
// Output frame of the selected tier over the 1920x1080 master. The strips
|
||
// outside it are dimmed in the preview so the cropped area stays visible.
|
||
public double OutputRectX { get; private set; }
|
||
public double OutputRectY { get; private set; }
|
||
public double OutputRectWidth { get; private set; }
|
||
public double OutputRectHeight { get; private set; }
|
||
public bool IsOutputCropped { get; private set; }
|
||
public string ResolutionBadgeText { get; private set; } = string.Empty;
|
||
public ObservableCollection<Rect> DimRects { get; } = new();
|
||
|
||
private void ApplyStreamQuality(QualityOption quality)
|
||
{
|
||
var health = CurrentHealth;
|
||
health.CurrentBitrate = EffectiveQuality(quality).Bitrate;
|
||
health.FPS = quality.Fps;
|
||
OnPropertyChanged(nameof(CurrentHealth));
|
||
|
||
var scale = Math.Min(MasterFrameWidth / quality.Width, MasterFrameHeight / quality.Height);
|
||
var rectW = quality.Width * scale;
|
||
var rectH = quality.Height * scale;
|
||
var rectX = (MasterFrameWidth - rectW) / 2;
|
||
var rectY = (MasterFrameHeight - rectH) / 2;
|
||
|
||
OutputRectX = rectX;
|
||
OutputRectY = rectY;
|
||
OutputRectWidth = rectW;
|
||
OutputRectHeight = rectH;
|
||
|
||
RebuildQualityDimRects();
|
||
|
||
IsOutputCropped = DimRects.Count > 0;
|
||
ResolutionBadgeText = $"{quality.Label} · {quality.Width}×{quality.Height}";
|
||
|
||
OnPropertyChanged(nameof(OutputRectX));
|
||
OnPropertyChanged(nameof(OutputRectY));
|
||
OnPropertyChanged(nameof(OutputRectWidth));
|
||
OnPropertyChanged(nameof(OutputRectHeight));
|
||
OnPropertyChanged(nameof(IsOutputCropped));
|
||
OnPropertyChanged(nameof(ResolutionBadgeText));
|
||
|
||
// TASK 57 (the "vv" feature): the tier decides which camera placement
|
||
// is live — the vertical tier brings each scene's own vertical placement
|
||
// in, 16:9 puts the desktop layout back exactly where it was.
|
||
OnPropertyChanged(nameof(IsVerticalTier));
|
||
OnPropertyChanged(nameof(VerticalBand));
|
||
OnPropertyChanged(nameof(CanToggleClipShape));
|
||
if (ResolveVerticalCameraLayouts(VerticalCameraLayout.IsVerticalTier(quality)))
|
||
ScheduleSave();
|
||
}
|
||
|
||
public ICommand StartStreamCommand { get; }
|
||
public ICommand StartTestCommand { get; }
|
||
public ICommand EndStreamCommand { get; }
|
||
public ICommand SignInCommand { get; }
|
||
public ICommand ChooseRecordFolderCommand { get; }
|
||
public ICommand ResetRecordFolderCommand { get; }
|
||
}
|