WebCodecs meistern: Verbesserung der Videoqualität durch temporale Rauschunterdrückung

In der Welt der webbasierten Videokommunikation, des Streamings und der Echtzeitanwendungen ist Qualität von größter Bedeutung. Nutzer auf der ganzen Welt erwarten ein scharfes, klares Video, egal ob sie an einem Geschäftstreffen teilnehmen, eine Live-Veranstaltung verfolgen oder mit einem Remote-Dienst interagieren. Videostreams werden jedoch oft von einem hartnäckigen und störenden Artefakt geplagt: Rauschen. Dieses digitale Rauschen, oft als körnige oder statische Textur sichtbar, kann das Seherlebnis beeinträchtigen und überraschenderweise den Bandbreitenverbrauch erhöhen. Glücklicherweise gibt eine leistungsstarke Browser-API, WebCodecs, Entwicklern eine beispiellose Low-Level-Kontrolle, um dieses Problem direkt anzugehen.

Dieser umfassende Leitfaden führt Sie tief in die Verwendung von WebCodecs für eine spezielle, hochwirksame Videoverarbeitungstechnik ein: die temporale Rauschunterdrückung. Wir werden untersuchen, was Videorauschen ist, warum es schädlich ist und wie Sie das VideoFrame-Objekt nutzen können, um eine Filterpipeline direkt im Browser zu erstellen. Wir behandeln alles von der grundlegenden Theorie bis zu einer praktischen JavaScript-Implementierung, Leistungsüberlegungen mit WebAssembly und fortgeschrittenen Konzepten zur Erzielung professioneller Ergebnisse.

Was ist Videorauschen und warum ist es wichtig?

Bevor wir ein Problem beheben können, müssen wir es zunächst verstehen. In der digitalen Videotechnik bezeichnet Rauschen zufällige Schwankungen von Helligkeits- oder Farbinformationen im Videosignal. Es ist ein unerwünschtes Nebenprodukt des Bilderfassungs- und Übertragungsprozesses.

Quellen und Arten von Rauschen

• Sensorrauschen: Der Hauptverursacher. Bei schlechten Lichtverhältnissen verstärken Kamerasensoren das eingehende Signal, um ein ausreichend helles Bild zu erzeugen. Dieser Verstärkungsprozess verstärkt auch zufällige elektronische Fluktuationen, was zu sichtbarem Korn führt.
• Thermisches Rauschen: Wärme, die von der Kameraelektronik erzeugt wird, kann Elektronen dazu veranlassen, sich zufällig zu bewegen, wodurch Rauschen entsteht, das unabhängig vom Lichtpegel ist.
• Quantisierungsrauschen: Wird während der Analog-Digital-Wandlung und der Komprimierungsprozesse eingeführt, bei denen kontinuierliche Werte auf eine begrenzte Anzahl diskreter Stufen abgebildet werden.

Dieses Rauschen äußert sich typischerweise als Gaußsches Rauschen, bei dem die Intensität jedes Pixels zufällig um seinen wahren Wert schwankt, was ein feines, schimmerndes Korn über den gesamten Frame erzeugt.

Die zweifachen Auswirkungen von Rauschen

Videorauschen ist mehr als nur ein kosmetisches Problem; es hat erhebliche technische und wahrnehmungsbezogene Konsequenzen:

1. Verschlechterte Benutzererfahrung: Die offensichtlichste Auswirkung betrifft die visuelle Qualität. Ein verrauschtes Video wirkt unprofessionell, ist ablenkend und kann es schwierig machen, wichtige Details zu erkennen. In Anwendungen wie Telekonferenzen können Teilnehmer dadurch körnig und undeutlich erscheinen, was das Präsenzgefühl beeinträchtigt.
2. Reduzierte Kompressionseffizienz: Dies ist das weniger intuitive, aber ebenso kritische Problem. Moderne Videocodecs (wie H.264, VP9, AV1) erreichen hohe Kompressionsraten durch die Nutzung von Redundanz. Sie suchen nach Ähnlichkeiten zwischen Frames (temporale Redundanz) und innerhalb eines einzelnen Frames (räumliche Redundanz). Rauschen ist seiner Natur nach zufällig und unvorhersehbar. Es durchbricht diese Redundanzmuster. Der Encoder sieht das zufällige Rauschen als hochfrequentes Detail, das erhalten werden muss, und ist gezwungen, mehr Bits für die Kodierung des Rauschens anstelle des eigentlichen Inhalts zu verwenden. Dies führt entweder zu einer größeren Dateigröße bei gleicher wahrgenommener Qualität oder zu einer geringeren Qualität bei gleicher Bitrate.

Indem wir Rauschen vor der Kodierung entfernen, können wir das Videosignal vorhersagbarer machen, sodass der Encoder effizienter arbeiten kann. Dies führt zu einer besseren visuellen Qualität, einem geringeren Bandbreitenverbrauch und einem reibungsloseren Streaming-Erlebnis für Nutzer weltweit.

Vorhang auf für WebCodecs: Die Macht der Low-Level-Videosteuerung

Jahrelang war die direkte Videomanipulation im Browser eingeschränkt. Entwickler waren weitgehend auf die Fähigkeiten des <video>-Elements und der Canvas-API beschränkt, was oft leistungsintensive Readbacks von der GPU mit sich brachte. WebCodecs verändert das Spiel komplett.

WebCodecs ist eine Low-Level-API, die direkten Zugriff auf die integrierten Medien-Encoder und -Decoder des Browsers bietet. Sie ist für Anwendungen konzipiert, die eine präzise Kontrolle über die Medienverarbeitung erfordern, wie z. B. Video-Editoren, Cloud-Gaming-Plattformen und fortschrittliche Echtzeit-Kommunikationsclients.

Die Kernkomponente, auf die wir uns konzentrieren, ist das VideoFrame-Objekt. Ein VideoFrame repräsentiert einen einzelnen Videobild als Bild, ist aber weit mehr als eine einfache Bitmap. Es ist ein hocheffizientes, übertragbares Objekt, das Videodaten in verschiedenen Pixelformaten (wie RGBA, I420, NV12) enthalten kann und wichtige Metadaten wie die folgenden trägt:

• timestamp: Die Präsentationszeit des Frames in Mikrosekunden.
• duration: Die Dauer des Frames in Mikrosekunden.
• codedWidth und codedHeight: Die Abmessungen des Frames in Pixeln.
• format: Das Pixelformat der Daten (z. B. 'I420', 'RGBA').

Entscheidend ist, dass VideoFrame eine Methode namens copyTo() bereitstellt, mit der wir die rohen, unkomprimierten Pixeldaten in einen ArrayBuffer kopieren können. Dies ist unser Einstiegspunkt für Analyse und Manipulation. Sobald wir die rohen Bytes haben, können wir unseren Rauschunterdrückungsalgorithmus anwenden und dann aus den modifizierten Daten einen neuen VideoFrame erstellen, um ihn weiter in der Verarbeitungspipeline zu übergeben (z. B. an einen Video-Encoder oder auf eine Canvas).

Grundlagen der temporalen Filterung

Techniken zur Rauschunterdrückung lassen sich grob in zwei Arten einteilen: räumliche und temporale.

• Räumliche Filterung: Diese Technik arbeitet auf einem einzelnen, isolierten Frame. Sie analysiert die Beziehungen zwischen benachbarten Pixeln, um Rauschen zu identifizieren und zu glätten. Ein einfaches Beispiel ist ein Weichzeichnerfilter. Obwohl räumliche Filter Rauschen effektiv reduzieren, können sie auch wichtige Details und Kanten weichzeichnen, was zu einem weniger scharfen Bild führt.
• Temporale Filterung: Dies ist der anspruchsvollere Ansatz, auf den wir uns konzentrieren. Er arbeitet über mehrere Frames hinweg im Zeitverlauf. Das Grundprinzip ist, dass der eigentliche Szeneninhalt wahrscheinlich von einem Frame zum nächsten korreliert ist, während das Rauschen zufällig und unkorreliert ist. Durch den Vergleich des Werts eines Pixels an einer bestimmten Position über mehrere Frames hinweg können wir das konsistente Signal (das reale Bild) von den zufälligen Schwankungen (dem Rauschen) unterscheiden.

Die einfachste Form der temporalen Filterung ist die temporale Mittelwertbildung. Stellen Sie sich vor, Sie haben den aktuellen Frame und den vorherigen Frame. Für jedes beliebige Pixel liegt sein 'wahrer' Wert wahrscheinlich irgendwo zwischen seinem Wert im aktuellen Frame und seinem Wert im vorherigen. Indem wir sie mischen, können wir das zufällige Rauschen ausmitteln. Der neue Pixelwert kann mit einem einfachen gewichteten Durchschnitt berechnet werden:

new_pixel = (alpha * current_pixel) + ((1 - alpha) * previous_pixel)

Hier ist alpha ein Mischfaktor zwischen 0 und 1. Ein höherer alpha-Wert bedeutet, dass wir dem aktuellen Frame mehr vertrauen, was zu weniger Rauschunterdrückung, aber auch zu weniger Bewegungsartefakten führt. Ein niedrigerer alpha-Wert sorgt für eine stärkere Rauschunterdrückung, kann aber in Bereichen mit Bewegung zu 'Ghosting' oder Nachzieheffekten führen. Die richtige Balance zu finden ist entscheidend.

Implementierung eines einfachen temporalen Mittelwertfilters

Lassen Sie uns eine praktische Implementierung dieses Konzepts mit WebCodecs erstellen. Unsere Pipeline wird aus drei Hauptschritten bestehen:

1. Einen Stream von VideoFrame-Objekten erhalten (z. B. von einer Webcam).
2. Für jeden Frame unseren temporalen Filter unter Verwendung der Daten des vorherigen Frames anwenden.
3. Einen neuen, bereinigten VideoFrame erstellen.

Schritt 1: Einrichten des Frame-Streams

Der einfachste Weg, einen Live-Stream von VideoFrame-Objekten zu erhalten, ist die Verwendung von MediaStreamTrackProcessor, der einen MediaStreamTrack (wie den von getUserMedia) konsumiert und dessen Frames als lesbaren Stream bereitstellt.

Konzeptioneller JavaScript-Aufbau:

async function setupVideoStream() { const stream = await navigator.mediaDevices.getUserMedia({ video: true }); const track = stream.getVideoTracks()[0]; const trackProcessor = new MediaStreamTrackProcessor({ track }); const reader = trackProcessor.readable.getReader(); let previousFrameBuffer = null; let previousFrameTimestamp = -1; while (true) { const { value: frame, done } = await reader.read(); if (done) break; // Hier werden wir jeden 'frame' verarbeiten const processedFrame = await applyTemporalFilter(frame, previousFrameBuffer); // Für die nächste Iteration müssen wir die Daten des *originalen* aktuellen Frames speichern // Sie würden die Daten des originalen Frames hier in 'previousFrameBuffer' kopieren, bevor Sie ihn schließen. // Vergessen Sie nicht, Frames zu schließen, um Speicher freizugeben! frame.close(); // Etwas mit dem processedFrame tun (z.B. auf Canvas rendern, kodieren) // ... und ihn dann ebenfalls schließen! processedFrame.close(); } }

Schritt 2: Der Filteralgorithmus – Arbeiten mit Pixeldaten

Dies ist der Kern unserer Arbeit. Innerhalb unserer applyTemporalFilter-Funktion müssen wir auf die Pixeldaten des eingehenden Frames zugreifen. Der Einfachheit halber gehen wir davon aus, dass unsere Frames im 'RGBA'-Format vorliegen. Jedes Pixel wird durch 4 Bytes repräsentiert: Rot, Grün, Blau und Alpha (Transparenz).

async function applyTemporalFilter(currentFrame, previousFrameBuffer) { // Definieren Sie unseren Mischfaktor. 0.8 bedeutet 80% des neuen Frames und 20% des alten. const alpha = 0.8; // Die Dimensionen abrufen const width = currentFrame.codedWidth; const height = currentFrame.codedHeight; // Einen ArrayBuffer zuweisen, um die Pixeldaten des aktuellen Frames zu halten. const currentFrameSize = width * height * 4; // 4 Bytes pro Pixel für RGBA const currentFrameBuffer = new Uint8Array(currentFrameSize); await currentFrame.copyTo(currentFrameBuffer); // Wenn dies der erste Frame ist, gibt es keinen vorherigen Frame zum Mischen. // Geben Sie ihn einfach so zurück, aber speichern Sie seinen Puffer für die nächste Iteration. if (!previousFrameBuffer) { const newFrameBuffer = new Uint8Array(currentFrameBuffer); // Wir werden unseren globalen 'previousFrameBuffer' außerhalb dieser Funktion mit diesem aktualisieren. return { buffer: newFrameBuffer, frame: currentFrame }; } // Einen neuen Puffer für unseren Ausgabe-Frame erstellen. const outputFrameBuffer = new Uint8Array(currentFrameSize); // Die Hauptverarbeitungsschleife. for (let i = 0; i < currentFrameSize; i++) { const currentPixelValue = currentFrameBuffer[i]; const previousPixelValue = previousFrameBuffer[i]; // Die temporale Mittelwertformel für jeden Farbkanal anwenden. // Wir überspringen den Alpha-Kanal (jedes 4. Byte). if ((i + 1) % 4 !== 0) { outputFrameBuffer[i] = Math.round(alpha * currentPixelValue + (1 - alpha) * previousPixelValue); } else { // Den Alpha-Kanal unverändert lassen. outputFrameBuffer[i] = currentPixelValue; } } return { buffer: outputFrameBuffer, frame: currentFrame }; }

Ein Hinweis zu YUV-Formaten (I420, NV12): Während RGBA leicht zu verstehen ist, werden die meisten Videos aus Effizienzgründen nativ in YUV-Farbräumen verarbeitet. Die Handhabung von YUV ist komplexer, da die Farb- (U, V) und Helligkeitsinformationen (Y) getrennt gespeichert werden (in 'Ebenen' oder 'Planes'). Die Filterlogik bleibt dieselbe, aber Sie müssten jede Ebene (Y, U und V) separat durchlaufen und dabei deren jeweilige Dimensionen berücksichtigen (Farbebenen haben oft eine geringere Auflösung, eine Technik, die als Chroma-Subsampling bezeichnet wird).

Schritt 3: Erstellen des neuen, gefilterten `VideoFrame`

Nachdem unsere Schleife beendet ist, enthält outputFrameBuffer die Pixeldaten für unseren neuen, saubereren Frame. Wir müssen diese nun in ein neues VideoFrame-Objekt verpacken und sicherstellen, dass wir die Metadaten vom ursprünglichen Frame kopieren.

// Innerhalb Ihrer Hauptschleife nach dem Aufruf von applyTemporalFilter... const { buffer: processedBuffer, frame: originalFrame } = await applyTemporalFilter(frame, previousFrameBuffer); // Einen neuen VideoFrame aus unserem verarbeiteten Puffer erstellen. const newFrame = new VideoFrame(processedBuffer, { format: 'RGBA', codedWidth: originalFrame.codedWidth, codedHeight: originalFrame.codedHeight, timestamp: originalFrame.timestamp, duration: originalFrame.duration }); // WICHTIG: Den Puffer des vorherigen Frames für die nächste Iteration aktualisieren. // Wir müssen die Daten des *originalen* Frames kopieren, nicht die gefilterten Daten. // Eine separate Kopie sollte vor dem Filtern erstellt werden. previousFrameBuffer = new Uint8Array(originalFrameData); // Jetzt können Sie 'newFrame' verwenden. Rendern, kodieren usw. // renderer.draw(newFrame); // Und entscheidend: Schließen Sie ihn, wenn Sie fertig sind, um Speicherlecks zu vermeiden. newFrame.close();

Speicherverwaltung ist entscheidend: VideoFrame-Objekte können große Mengen unkomprimierter Videodaten enthalten und durch Speicher außerhalb des JavaScript-Heaps gestützt werden. Sie müssen frame.close() für jeden Frame aufrufen, mit dem Sie fertig sind. Andernfalls kommt es schnell zu Speichererschöpfung und einem abgestürzten Tab.

Leistungsüberlegungen: JavaScript vs. WebAssembly

Die reine JavaScript-Implementierung oben eignet sich hervorragend zum Lernen und zur Demonstration. Für ein Video mit 30 FPS und 1080p (1920x1080) muss unsere Schleife jedoch über 248 Millionen Berechnungen pro Sekunde durchführen! (1920 * 1080 * 4 Bytes * 30 fps). Obwohl moderne JavaScript-Engines unglaublich schnell sind, ist diese pixelweise Verarbeitung ein perfekter Anwendungsfall für eine leistungsorientiertere Technologie: WebAssembly (Wasm).

Der WebAssembly-Ansatz

WebAssembly ermöglicht es Ihnen, Code, der in Sprachen wie C++, Rust oder Go geschrieben wurde, im Browser mit nahezu nativer Geschwindigkeit auszuführen. Die Logik für unseren temporalen Filter ist in diesen Sprachen einfach zu implementieren. Sie würden eine Funktion schreiben, die Zeiger auf die Eingabe- und Ausgabepuffer entgegennimmt und dieselbe iterative Mischoperation durchführt.

Konzeptionelle C++-Funktion für Wasm:

extern "C" { void apply_temporal_filter(unsigned char* current_frame, unsigned char* previous_frame, unsigned char* output_frame, int buffer_size, float alpha) { for (int i = 0; i < buffer_size; ++i) { if ((i + 1) % 4 != 0) { // Alpha-Kanal überspringen output_frame[i] = (unsigned char)(alpha * current_frame[i] + (1.0 - alpha) * previous_frame[i]); } else { output_frame[i] = current_frame[i]; } } } }

Von der JavaScript-Seite aus würden Sie dieses kompilierte Wasm-Modul laden. Der entscheidende Leistungsvorteil ergibt sich aus der gemeinsamen Speichernutzung. Sie können in JavaScript ArrayBuffers erstellen, die durch den linearen Speicher des Wasm-Moduls gestützt werden. Dies ermöglicht es Ihnen, die Frame-Daten ohne teures Kopieren an Wasm zu übergeben. Die gesamte Pixelverarbeitungsschleife läuft dann als ein einziger, hochoptimierter Wasm-Funktionsaufruf ab, was deutlich schneller ist als eine JavaScript-`for`-Schleife.

Fortgeschrittene Techniken der temporalen Filterung

Die einfache temporale Mittelwertbildung ist ein großartiger Ausgangspunkt, hat aber einen erheblichen Nachteil: Sie führt zu Bewegungsunschärfe oder 'Ghosting'. Wenn sich ein Objekt bewegt, werden seine Pixel im aktuellen Frame mit den Hintergrundpixeln aus dem vorherigen Frame gemischt, wodurch eine Spur entsteht. Um einen wirklich professionellen Filter zu erstellen, müssen wir die Bewegung berücksichtigen.

Bewegungskompensierte temporale Filterung (MCTF)

Der Goldstandard für die temporale Rauschunterdrückung ist die bewegungskompensierte temporale Filterung. Anstatt ein Pixel blind mit dem an der gleichen (x, y)-Koordinate im vorherigen Frame zu mischen, versucht MCTF zuerst herauszufinden, woher dieses Pixel kam.

Der Prozess umfasst:

1. Bewegungsschätzung: Der Algorithmus teilt den aktuellen Frame in Blöcke auf (z. B. 16x16 Pixel). Für jeden Block durchsucht er den vorherigen Frame, um den ähnlichsten Block zu finden (z. B. den mit der geringsten Summe der absoluten Differenzen). Die Verschiebung zwischen diesen beiden Blöcken wird als 'Bewegungsvektor' bezeichnet.
2. Bewegungskompensation: Anschließend wird eine 'bewegungskompensierte' Version des vorherigen Frames erstellt, indem die Blöcke entsprechend ihrer Bewegungsvektoren verschoben werden.
3. Filterung: Schließlich wird die temporale Mittelwertbildung zwischen dem aktuellen Frame und diesem neuen, bewegungskompensierten vorherigen Frame durchgeführt.

Auf diese Weise wird ein bewegtes Objekt mit sich selbst aus dem vorherigen Frame gemischt, nicht mit dem Hintergrund, den es gerade freigegeben hat. Dies reduziert Ghosting-Artefakte drastisch. Die Implementierung der Bewegungsschätzung ist rechenintensiv und komplex, erfordert oft fortschrittliche Algorithmen und ist fast ausschließlich eine Aufgabe für WebAssembly oder sogar WebGPU-Compute-Shader.

Adaptive Filterung

Eine weitere Verbesserung besteht darin, den Filter adaptiv zu gestalten. Anstatt einen festen alpha-Wert für den gesamten Frame zu verwenden, können Sie ihn basierend auf lokalen Bedingungen variieren.

• Bewegungsadaptivität: In Bereichen mit hoher erkannter Bewegung können Sie alpha erhöhen (z. B. auf 0.95 oder 1.0), um sich fast ausschließlich auf den aktuellen Frame zu verlassen und so Bewegungsunschärfe zu vermeiden. In statischen Bereichen (wie einer Wand im Hintergrund) können Sie alpha verringern (z. B. auf 0.5), um eine viel stärkere Rauschunterdrückung zu erzielen.
• Luminanzadaptivität: Rauschen ist oft in dunkleren Bereichen eines Bildes besser sichtbar. Der Filter könnte in Schatten aggressiver und in hellen Bereichen weniger aggressiv gestaltet werden, um Details zu erhalten.

Praktische Anwendungsfälle und Applikationen

Die Fähigkeit, hochwertige Rauschunterdrückung im Browser durchzuführen, eröffnet zahlreiche Möglichkeiten:

• Echtzeitkommunikation (WebRTC): Den Webcam-Feed eines Nutzers vorverarbeiten, bevor er an den Video-Encoder gesendet wird. Dies ist ein großer Gewinn für Videoanrufe in Umgebungen mit wenig Licht, da es die visuelle Qualität verbessert und die erforderliche Bandbreite reduziert.
• Webbasierte Videobearbeitung: Bieten Sie einen 'Entrauschen'-Filter als Funktion in einem browserbasierten Video-Editor an, damit Benutzer ihr hochgeladenes Filmmaterial ohne serverseitige Verarbeitung bereinigen können.
• Cloud-Gaming und Remote-Desktop: Eingehende Videostreams bereinigen, um Kompressionsartefakte zu reduzieren und ein klareres, stabileres Bild zu liefern.
• Vorverarbeitung für Computer Vision: Für webbasierte KI/ML-Anwendungen (wie Objektverfolgung oder Gesichtserkennung) kann das Entrauschen des Eingangsvideos die Daten stabilisieren und zu genaueren und zuverlässigeren Ergebnissen führen.

Herausforderungen und zukünftige Richtungen

Obwohl dieser Ansatz leistungsstark ist, ist er nicht ohne Herausforderungen. Entwickler müssen Folgendes beachten:

• Leistung: Die Echtzeitverarbeitung von HD- oder 4K-Videos ist anspruchsvoll. Eine effiziente Implementierung, typischerweise mit WebAssembly, ist ein Muss.
• Speicher: Das Speichern eines oder mehrerer vorheriger Frames als unkomprimierte Puffer verbraucht eine erhebliche Menge an RAM. Eine sorgfältige Verwaltung ist unerlässlich.
• Latenz: Jeder Verarbeitungsschritt fügt Latenz hinzu. Für die Echtzeitkommunikation muss diese Pipeline hoch optimiert sein, um spürbare Verzögerungen zu vermeiden.
• Die Zukunft mit WebGPU: Die aufkommende WebGPU-API wird eine neue Grenze für diese Art von Arbeit darstellen. Sie wird es ermöglichen, diese pixelweisen Algorithmen als hochgradig parallele Compute-Shader auf der GPU des Systems auszuführen, was einen weiteren massiven Leistungssprung gegenüber sogar WebAssembly auf der CPU bietet.

Fazit

Die WebCodecs-API markiert eine neue Ära für die fortschrittliche Medienverarbeitung im Web. Sie reißt die Barrieren des traditionellen Blackbox-<video>-Elements ein und gibt Entwicklern die feingranulare Kontrolle, die sie benötigen, um wirklich professionelle Videoanwendungen zu erstellen. Die temporale Rauschunterdrückung ist ein perfektes Beispiel für ihre Leistungsfähigkeit: eine anspruchsvolle Technik, die sowohl die vom Benutzer wahrgenommene Qualität als auch die zugrunde liegende technische Effizienz direkt anspricht.

Wir haben gesehen, dass wir durch das Abfangen einzelner VideoFrame-Objekte leistungsstarke Filterlogiken implementieren können, um Rauschen zu reduzieren, die Komprimierbarkeit zu verbessern und ein überlegenes Videoerlebnis zu liefern. Während eine einfache JavaScript-Implementierung ein großartiger Ausgangspunkt ist, führt der Weg zu einer produktionsreifen Echtzeitlösung über die Leistung von WebAssembly und in Zukunft über die parallele Rechenleistung von WebGPU.

Wenn Sie das nächste Mal ein körniges Video in einer Web-App sehen, denken Sie daran, dass die Werkzeuge, um es zu beheben, jetzt zum ersten Mal direkt in den Händen der Webentwickler liegen. Es ist eine aufregende Zeit, um mit Video im Web zu arbeiten.