gramps/LlamaCasty
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

alert ticker: draw it inside the Stream Alerts box, not as a top-edge bar

Browse Source 
Creator 2026-09-26: "the ticker should appear over the stream alerts video, not over
the entire preview window". It was a GLOBAL 1920x48 bar blitted last at a hardcoded
(0, 0) -- it covered the whole preview width, not the alert video.

The strip is now rendered at the alert box's own size and the box's origin travels on
the frame in a new VideoFrame.Placement ((int X, int Y)?). OriginX/OriginY default to
0 when Placement is null, so every full-canvas overlay (the branding flash) is
unaffected. Every ticker blit site now reads tickerFrame.OriginX/OriginY instead of a
literal 0, 0 -- SceneCompositor x2 and FramePump's static-bake Overlay path -- and
PreviewPane.xaml's AlertTickerElement binds the same rect (AlertTickerLeft/Top/
Width/Height), so the preview cannot drift from the recording the creator is judging.

Why the position rides on the frame rather than in a full-canvas frame: a 1920x1080
overlay is 8.3MB of large-object-heap garbage per tick, ~2.5GB churned over one 10s
alert at 30fps. A box-sized strip is ~370KB. The branding flash does render
full-canvas but RECYCLES one 8MB buffer and bumps Epoch, so it never allocates per
frame; the ticker allocates per call, so it has to stay small.

Also fixed: CopyStrip now clips ROWS to the target height. The pill rasterises at its
natural 48px, so an alert box shorter than that would have written past the end of the
target buffer once the strip became box-sized.

No alert box in the scene now means no ticker at all -- there is no global position
left for it, and this is the guard against the old bar quietly coming back.

Tests (3 new facts, 27 in the file):
  ComposedOutput_PutsTheTickerInsideTheAlertBox_NotAtTheTopEdge -- renders through
    the real SceneCompositor and asserts the pixels land at (620, 430) and NOT at the
    top-left corner. The creator is judging compositing from local recordings, so the
    OUTPUT side is the side that needed proving.
  ASceneWithNoAlertBox_PublishesNoTicker
  ABoxShorterThanTheStrip_ClipsRowsInsteadOfOverrunning
Updated AlertLayer_PublishesARealTickerFrameToThePreviewSink, which asserted the old
1920 width from a box with no geometry (defaulted to 1px); it now uses the product's
own default box (680x200 at 620,430, MainViewModel.Sources.cs:54-57) and pins the
frame size and origin.

Full suite 367/367.
This commit is contained in:
Llama Chile Shop
2026-09-27 09:43:26 -07:00
parent 9761b1d4be
commit 938c5b3de4
11 changed files with 293 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Services/Compositor/AlertTickerRenderer.cs
+29 -17
View File
@@ -45,12 +45,19 @@ public static class AlertTickerRenderer
/// <paramref name="readsPerAlert"/> over <paramref name="alertSeconds"/> rather
/// than a fixed pixels-per-second: the old constant (140px/s ≈ a 17s pass) meant
/// a 10s alert showed the text barely once, entering from the right and never
/// crossing. The creator's target is three readable passes per alert.</para></summary>
/// crossing. The creator's target is three readable passes per alert.</para>
/// <para><paramref name="width"/>/<paramref name="height"/> default to the
/// full-master strip. They are parameters because the ticker now renders INTO the
/// Stream Alerts box (creator ruling 2026-09-26) and therefore has to be the box's
/// size: a 1920-wide strip clipped to an 800px box would hide the announcement
/// off the right edge for most of its pass, which is the opposite of readable.</para></summary>
public static VideoFrame? Render(string? text, double elapsedSeconds,
AlertDisplayMethod method = AlertDisplayMethod.TickerScroll,
double alertSeconds = 0.0, int readsPerAlert = 3)
double alertSeconds = 0.0, int readsPerAlert = 3,
int width = Width, int height = Height)
{
if (string.IsNullOrWhiteSpace(text)) return null;
if (width <= 0 || height <= 0) return null;
var strip = GetStrip(text!);
if (strip == null) return null;
@@ -59,14 +66,14 @@ public static class AlertTickerRenderer
return null; // off half of the pulse
var x = method == AlertDisplayMethod.TickerScroll
? ScrollX(strip.Width, elapsedSeconds, alertSeconds, readsPerAlert)
: (Width - strip.Width) / 2; // Solid + Flash: centred, still
? ScrollX(strip.Width, width, elapsedSeconds, alertSeconds, readsPerAlert)
: (width - strip.Width) / 2; // Solid + Flash: centred, still
var pixels = new byte[Width * Height * 4];
CopyStrip(pixels, strip, x);
var pixels = new byte[width * height * 4];
CopyStrip(pixels, width, height, strip, x);
if (method == AlertDisplayMethod.TickerScroll && x + strip.Width <= 0)
CopyStrip(pixels, strip, x + Width + RepeatGap); // wrapped tail enters from the right
return new VideoFrame(Width, Height, pixels);
CopyStrip(pixels, width, height, strip, x + width + RepeatGap); // wrapped tail enters
return new VideoFrame(width, height, pixels);
}
/// <summary>Left edge of the pill for a marquee that must complete
@@ -75,26 +82,31 @@ public static class AlertTickerRenderer
/// <para>The run is phase-started half a frame in, so the very first frame of an
/// alert already shows the announcement instead of a blank strip sitting exactly
/// off the right edge.</para></summary>
private static int ScrollX(int stripWidth, double elapsedSeconds, double alertSeconds, int readsPerAlert)
private static int ScrollX(int stripWidth, int width, double elapsedSeconds,
double alertSeconds, int readsPerAlert)
{
var cycle = Width + stripWidth + RepeatGap;
var cycle = width + stripWidth + RepeatGap;
var pass = Math.Max(0.5, alertSeconds) / Math.Max(1, readsPerAlert);
var speed = cycle / pass;
var pos = (Width / 2 + (int)(elapsedSeconds * speed)) % cycle;
return Width - pos;
var pos = (width / 2 + (int)(elapsedSeconds * speed)) % cycle;
return width - pos;
}
private static void CopyStrip(byte[] dst, VideoFrame strip, int dstX)
private static void CopyStrip(byte[] dst, int dstW, int dstH, VideoFrame strip, int dstX)
{
if (dstX >= Width || dstX + strip.Width <= 0) return;
if (dstX >= dstW || dstX + strip.Width <= 0) return;
var x0 = Math.Max(0, dstX);
var x1 = Math.Min(Width, dstX + strip.Width);
var x1 = Math.Min(dstW, dstX + strip.Width);
var sx0 = x0 - dstX;
var copyBytes = (x1 - x0) * 4;
var sw = strip.Width;
for (var y = 0; y < strip.Height; y++)
Buffer.BlockCopy(strip.BgraPixels, (y * sw + sx0) * 4, dst, (y * Width + x0) * 4, copyBytes);
// The strip is rasterised at its natural 48px; the target box can be shorter,
// and copying strip.Height rows into a shorter dst would run off the end of the
// array. Clip the rows, not the buffer.
var rows = Math.Min(strip.Height, dstH);
for (var y = 0; y < rows; y++)
Buffer.BlockCopy(strip.BgraPixels, (y * sw + sx0) * 4, dst, (y * dstW + x0) * 4, copyBytes);
}
private static VideoFrame? GetStrip(string text)
Services/Compositor/SceneCompositor.cs
+6 -4
View File
@@ -37,8 +37,10 @@ public sealed class SceneCompositor
/// front): live background (the scene's <c>IsBackground</c> source) → background image →
/// visible elements (z-order = <c>Elements</c> order, mirroring the XAML DataTemplate) →
/// branding flash → social bar (a global overlay; spans the master width at
/// <paramref name="socialBarTop"/>) → stream-alert ticker (a global overlay pinned to
/// the very top, TASK 47). Transparent regions read opaque black.
/// <paramref name="socialBarTop"/>) → stream-alert ticker (drawn INSIDE the Stream
/// Alerts box, at the origin the frame carries on <see cref="VideoFrame.Placement"/>;
/// creator ruling 2026-09-26 — it used to be a global bar pinned to the very top).
/// Transparent regions read opaque black.
/// </summary>
public VideoFrame Render(
Scene scene,
@@ -140,7 +142,7 @@ public sealed class SceneCompositor
BlitOverlay(buffer, cropW, cropH, options, socialBarFrame, 0, socialBarTop);
if (tickerFrame != null && tickerFrame.Width > 0 && tickerFrame.Height > 0)
BlitOverlay(buffer, cropW, cropH, options, tickerFrame, 0, 0);
BlitOverlay(buffer, cropW, cropH, options, tickerFrame, tickerFrame.OriginX, tickerFrame.OriginY);
return StretchMath.BilinearScale(
new VideoFrame(cropW, cropH, buffer), options.OutputWidth, options.OutputHeight);
@@ -258,7 +260,7 @@ public sealed class SceneCompositor
}
if (tickerFrame != null && tickerFrame.Width > 0 && tickerFrame.Height > 0)
BlitOverlay(buffer, cropW, cropH, options, tickerFrame, 0, 0);
BlitOverlay(buffer, cropW, cropH, options, tickerFrame, tickerFrame.OriginX, tickerFrame.OriginY);
return StretchMath.BilinearScale(new VideoFrame(cropW, cropH, buffer), options.OutputWidth, options.OutputHeight);
}