Fünf Sekunden Bild ohne Ton — jetzt weiss ich, woher

Deine Angabe war der Schlüssel: du hast **mitten im Film die Tonspur
umgeschaltet**. Dabei baut der Spieler den Strom an der aktuellen Stelle
neu auf, und damit greift der Sprung — den ich gestern nur mit
Spielzeugdateien gemessen hatte.

Also eine Datei gebaut, die einem Film gleicht: 23,976 Bilder je Sekunde,
Schlüsselbild alle fünf Sekunden, zwei Tonspuren, Deutsch als Stereo-AAC
und Englisch als 5.1 in EAC3. Gemessen, erster Zeitstempel je Spur:

| | Bild ab | Ton ab |
|---|---|---|
| Spur 2, ab Sekunde 0 | 0,021 | 0,000 |
| Spur 2, ab 17 (mitten in der Bildgruppe) | 0,000 | **1,964** |
| Spur 2, ab 15 (knapp vor dem Schlüsselbild) | 0,000 | **4,969** |

Fast fünf Sekunden Bild ohne Ton. Zueinander sind beide dabei richtig
getaktet — aber eine solche Lücke am Anfang darf jeder Spieler deuten, wie
er will, und hls.js schiebt den Ton dann nach vorn. Genau das hast du
gehört.

Die Rundung auf das Schlüsselbild, die seit E8GSRE drin ist, nimmt das
weg: dieselbe Datei, Sprung auf 17, gerundet auf 15,015 — **Bild ab 0,000,
Ton ab 0,004**. Du läufst noch auf 5YZ63F; deshalb steht im Protokoll auch
keine ffmpeg-Warnung, die gibt es erst ab E8GSRE.

**Die Tonspur lässt sich jetzt vor dem Start wählen.** Auf der
Detailseite steht neben „Abspielen" ein Knopf „Ton: Deutsch"; das Menü
zeigt alle Spuren der Datei. Gemerkt wird dabei die **Sprache**, nicht die
Spurnummer — welche Nummer Englisch trägt, ist von Film zu Film
verschieden, dass du Englisch willst, ist es nicht. Beim nächsten Film
steht die passende Spur damit schon da, und das Umschalten mitten im Film
entfällt. Wer doch im Spieler wechselt, ändert dieselbe Merkstelle.

**Und ein Fehler aus deinem Protokoll**, der nichts damit zu tun hat:
„UNIQUE constraint failed: Sehtage.UserId, Sehtage.Tag, Sehtage.MovieId".
Das ist ein Wettlauf im Sehprotokoll von vorgestern — der Spieler meldet
alle zehn Sekunden, ein Sprung meldet sofort, und zwei Meldungen können
sich überholen. Dann fanden beide keine Zeile, beide legten eine an. Jetzt
wird in der Datenbank hochgezählt statt im Speicher, und wer dabei zu spät
kommt, zählt beim zweiten Versuch mit. Mit Test.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

server/src/Flaro.Api/Endpoints/PlaybackEndpoints.cs

@@ -552,7 +552,7 @@ public static class PlaybackEndpoints
     /// </remarks>
     private static async Task Mitzaehlen(
         FlaroContext db, Guid benutzer, UserItemState zustand,
-        TimeSpan neueStelle, TimeProvider clock)
+        TimeSpan neueStelle, TimeProvider clock, CancellationToken ct = default)
     {
         if (zustand.MovieId is null && zustand.EpisodeId is null) return;
 
@@ -574,12 +574,22 @@ public static class PlaybackEndpoints
         // Abend getan.
         var tag = DateOnly.FromDateTime(jetzt.ToLocalTime().DateTime);
 
-        var zeile = await db.Sehtage.FirstOrDefaultAsync(z =>
-            z.UserId == benutzer && z.Tag == tag
-            && z.MovieId == zustand.MovieId && z.EpisodeId == zustand.EpisodeId);
+        // **Erhöhen, und nur wenn es die Zeile nicht gibt, anlegen.**
+        //
+        // Vorher stand hier „nachsehen, dann anlegen oder erhöhen" — und das
+        // ist ein Wettlauf: der Spieler meldet alle zehn Sekunden, ein Sprung
+        // meldet sofort, und zwei Meldungen können sich überholen. Dann fanden
+        // beide keine Zeile, beide legten eine an, und die zweite lief in
+        // „UNIQUE constraint failed: Sehtage.UserId, Sehtage.Tag,
+        // Sehtage.MovieId". Gemeldet wurde das als Fehler 500 auf einen
+        // Fortschrittsbericht — für den Zuschauer unsichtbar, im Protokoll ein
+        // Stapelabzug.
+        //
+        // `ExecuteUpdateAsync` rechnet in der Datenbank statt im Speicher und
+        // kann deshalb nicht danebengreifen. Trifft es nichts, wird angelegt;
+        // kommt dabei jemand zuvor, fängt der zweite Versuch es auf.
+        if (await Erhoehen(db, benutzer, tag, zustand, zuwachs, ct) > 0) return;
 
-        if (zeile is null)
-        {
         db.Sehtage.Add(new Sehtag
         {
             UserId = benutzer,
@@ -588,13 +598,31 @@ public static class PlaybackEndpoints
             Tag = tag,
             Sekunden = zuwachs,
         });
-        }
-        else
+
+        try
         {
-            zeile.Sekunden += zuwachs;
+            await db.SaveChangesAsync(ct);
+        }
+        catch (DbUpdateException)
+        {
+            // Jemand war schneller. Die angefangene Zeile wieder vergessen,
+            // sonst versucht der Aufrufer sie beim nächsten Speichern erneut.
+            db.ChangeTracker.Clear();
+            await Erhoehen(db, benutzer, tag, zustand, zuwachs, ct);
         }
     }
 
+    /// <summary>Schreibt die Sekunden an einer vorhandenen Zeile fort.</summary>
+    ///
+    /// <remarks>Gibt zurück, wie viele Zeilen getroffen wurden — 0 oder 1.</remarks>
+    private static Task<int> Erhoehen(
+        FlaroContext db, Guid benutzer, DateOnly tag, UserItemState zustand,
+        double zuwachs, CancellationToken ct) =>
+        db.Sehtage
+            .Where(z => z.UserId == benutzer && z.Tag == tag
+                && z.MovieId == zustand.MovieId && z.EpisodeId == zustand.EpisodeId)
+            .ExecuteUpdateAsync(s => s.SetProperty(z => z.Sekunden, z => z.Sekunden + zuwachs), ct);
+
     private static void Nachfuehren(UserItemState zustand, Wiedergaberegeln regeln) =>
         zustand.InProgress = ProgressRule.BelongsInContinueWatching(zustand, regeln);
 

server/tests/Flaro.Api.Tests/StatistikTests.cs

@@ -230,4 +230,37 @@ public sealed class StatistikTests
             Assert.That(fremde.Recent, Is.Empty);
         });
     }
+
+    /// <summary>Zwei Fortschrittsmeldungen gleichzeitig stürzen nicht ab.</summary>
+    ///
+    /// <remarks>
+    /// <b>Aus dem Protokoll eines laufenden Servers.</b> Der Spieler meldet
+    /// alle zehn Sekunden, ein Sprung meldet sofort — zwei Meldungen können
+    /// sich überholen. Vorher fanden dann beide keine Zeile im Sehprotokoll,
+    /// beide legten eine an, und die zweite lief in „UNIQUE constraint failed:
+    /// Sehtage.UserId, Sehtage.Tag, Sehtage.MovieId". Der Zuschauer merkte
+    /// nichts, im Protokoll stand ein Stapelabzug.
+    /// </remarks>
+    [Test]
+    public async Task Zwei_Meldungen_gleichzeitig_zaehlen_beide()
+    {
+        Datei("Gleichzeitig (2024)/Gleichzeitig (2024).mkv");
+        using var server = MitUhr();
+        var client = await Eingelesen(server);
+        var film = await ErsterFilm(client);
+
+        // Den Nullpunkt setzen, dann Zeit vergehen lassen — sonst greift der
+        // Deckel und es gäbe ohnehin nichts gutzuschreiben.
+        await Melden(client, film, 0, 7200);
+        _uhr.Weiter(TimeSpan.FromMinutes(5));
+
+        var beide = await Task.WhenAll(
+            client.PostAsJsonAsync($"/api/v1/items/{film}/progress", new ProgressRequest(60, 7200, null)),
+            client.PostAsJsonAsync($"/api/v1/items/{film}/progress", new ProgressRequest(90, 7200, null)));
+
+        Assert.That(beide.Select(a => (int)a.StatusCode), Has.All.LessThan(400),
+            "Eine Fortschrittsmeldung darf nie an einem Wettlauf scheitern.");
+        Assert.That((await Statistik(client))!.LoggedSeconds, Is.GreaterThan(0),
+            "und mitgezählt werden muss sie auch.");
+    }
 }

web/app/src/spieler.ts

@@ -116,6 +116,22 @@ function versatzMerken(datei: string, wert: number): void {
   } catch { /* Privates Fenster — dann gilt er eben nur für diesen Film. */ }
 }
 
+/** Welche Tonsprache zuletzt gewählt wurde.
+ *
+ * **Eine Sprache, keine Spurnummer.** Welche Nummer die englische Spur trägt,
+ * ist von Film zu Film verschieden; dass jemand Englisch will, ist es nicht.
+ * Hier steht deshalb eine Sprache, und die Detailseite sucht damit die
+ * passende Spur. */
+const SPRACHSCHLUESSEL = 'flaro.tonsprache';
+
+export function tonsprache(): string | null {
+  try { return localStorage.getItem(SPRACHSCHLUESSEL); } catch { return null; }
+}
+
+export function tonspracheMerken(sprache: string): void {
+  try { localStorage.setItem(SPRACHSCHLUESSEL, sprache); } catch { /* Privates Fenster. */ }
+}
+
 /** „läuft mit", „200 ms später", „300 ms früher". */
 function versatzWort(ms: number): string {
   if (ms === 0) return 'läuft mit dem Bild';
@@ -141,6 +157,8 @@ export type Spieleranfrage = {
    * kennt nur den Rest ab dem Einstiegspunkt und machte aus einem
    * Zweistünder ab Minute 90 einen Halbstünder. */
   laenge: number | null;
+  /** Mit welcher Tonspur gestartet wird — gewählt auf der Detailseite. */
+  tonspur?: number | null;
   danach: () => void;
 };
 
@@ -187,7 +205,7 @@ export function spieler(anfrage: Spieleranfrage): void {
 
   /** Die gewählte Stufe und Spuren — sie überleben einen Neustart des Stroms. */
   let stufe: number | null = null;
-  let tonspur: number | null = null;
+  let tonspur: number | null = anfrage.tonspur ?? null;
   let untertitel: number | null = null;
 
   /** Ob der Server umkodieren soll, egal was das Profil sagt.
@@ -620,7 +638,12 @@ export function spieler(anfrage: Spieleranfrage): void {
     const spuren = toene.length > 0
       ? toene.map(s => ({
         text: s.label, gewaehlt: s.index === tonspur,
-        tun: () => { tonspur = s.index; void stromAufbauen(filmzeit()); },
+        tun: () => {
+          tonspur = s.index;
+          // Wer hier wechselt, meint es auch beim nächsten Film so.
+          if (s.language) tonspracheMerken(s.language);
+          void stromAufbauen(filmzeit());
+        },
       }))
       : [{ text: 'Diese Datei hat keinen Ton.', gewaehlt: false, tun: () => {} }];
 

web/app/src/views/detail.ts

@@ -2,7 +2,7 @@ import { ApiFehler,
   film as filmLaden, serie as serieLaden, folgen, lieferung, downloadAdresse,
   vorschlaege, zuordnen, bildAdresse, istAdmin, gesehen, favorit, weglegen,
   type Film, type Serie, type Folge, type Datei, type Lieferung, type Stand,
-  type Mitwirkender, aehnliche,
+  type Mitwirkender, type Spur, aehnliche,
 } from '../api';
 import {
   esc, dauer, groesse, knopf, feld, fehlerzeile, leer, anteil, meldung, hinweisZeigen,
@@ -10,7 +10,8 @@ import {
 import { icons, icon } from '../icons';
 import { kachel, alsKachel, reihe } from '../card';
 import { vergessen } from '../ansichten';
-import { spieler } from '../spieler';
+import { spieler, tonsprache, tonspracheMerken } from '../spieler';
+import { menueAnZiel } from '../menue';
 import { meldedialog } from '../melden';
 
 type Art = 'filme' | 'serien';
@@ -303,6 +304,15 @@ export function detailseite(art: Art, id: string, zurueck: () => void): HTMLElem
         reihe.appendChild(vonVorn);
       }
 
+      // **Die Sprache vor dem Start, nicht erst mitten im Film.**
+      //
+      // Im Spieler umzuschalten heisst, den Strom neu aufzubauen — und bei
+      // einem Film, den man immer auf Englisch sehen will, jedes Mal von
+      // Neuem. Welche Spuren es gibt, steht hier ohnehin schon; gewählt wird
+      // also, bevor etwas läuft.
+      const tonwahl = tonspurwahl(datei);
+      if (tonwahl) reihe.appendChild(tonwahl);
+
       const laden = knopf('Herunterladen', 'btn');
       laden.prepend(icon('download'));
       laden.onclick = () => void herunterladen(datei, laden, hinweisfeld);
@@ -348,6 +358,50 @@ export function detailseite(art: Art, id: string, zurueck: () => void): HTMLElem
     return huelle;
   }
 
+  /** Die zuletzt gewählte Tonspur dieser Datei — oder keine Wahl. */
+  let gewaehlteSpur: number | null = null;
+
+  /** Ein Knopf, der die Tonspur zeigt und ein Menü dazu öffnet.
+   *
+   * **Nur bei mehr als einer.** Bei einer einzigen gäbe es nichts zu wählen,
+   * und ein Knopf, der nur bestätigt, was ohnehin läuft, ist einer zu viel. */
+  function tonspurwahl(datei: Datei): HTMLElement | null {
+    const spuren = datei.streams.filter(s => s.kind === 'Audio');
+    if (spuren.length < 2) return null;
+
+    // **Die gemerkte Sprache schlägt die Reihenfolge der Datei.** Sonst
+    // gewinnt immer die erste Spur — und das ist bei deutschen Veröffent-
+    // lichungen fast immer die deutsche.
+    const gemerkt = tonsprache();
+    const vorgewaehlt = gewaehlteSpur
+      ?? spuren.find(s => s.language && s.language === gemerkt)?.index
+      ?? spuren[0]!.index;
+    gewaehlteSpur = vorgewaehlt;
+
+    const name = (s: Spur): string =>
+      s.languageName ?? s.display?.split(' · ')[0] ?? s.language ?? `Spur ${s.index}`;
+
+    const k = knopf('', 'btn');
+    const zeichnen = (): void => {
+      const jetzt = spuren.find(s => s.index === gewaehlteSpur) ?? spuren[0]!;
+      k.textContent = `Ton: ${name(jetzt)}`;
+      k.prepend(icon('tonspur'));
+    };
+    zeichnen();
+
+    k.onclick = () => menueAnZiel(k, spuren.map(s => ({
+      text: name(s),
+      icon: s.index === gewaehlteSpur ? ('haken' as const) : undefined,
+      tun: () => {
+        gewaehlteSpur = s.index;
+        if (s.language) tonspracheMerken(s.language);
+        zeichnen();
+      },
+    })));
+
+    return k;
+  }
+
   function rundKnopf(
     bild: keyof typeof icons, an: boolean, titel: string, tun: () => Promise<void>,
   ): HTMLButtonElement {
@@ -737,6 +791,7 @@ export function detailseite(art: Art, id: string, zurueck: () => void): HTMLElem
       name,
       ab,
       laenge: datei.durationSeconds,
+      tonspur: gewaehlteSpur,
       danach: laden,
     });
   }