End-to-end video test

Parametrize for simulcast

Higher resolution to get 3 simulcast layers

Use higher tolerance

Increase test timeout

Clean up

Revert timeout increase

Clean up

Check simulcasted property

Format

Add HEVC to test matrix

Increase timeout

Lower resource requirements

GitHub Actions runners struggle with the old settings

Receive single frame

Author: ladvoc

livekit/tests/common/e2e/mod.rs

@@ -25,6 +25,7 @@ use tokio::{
 };
 
 pub mod audio;
+pub mod video;
 
 struct TestEnvironment {
     api_key: String,

livekit/tests/common/e2e/video.rs

@@ -0,0 +1,116 @@
+// Copyright 2025 LiveKit, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use libwebrtc::{
+    prelude::{I420Buffer, RtcVideoSource, VideoFrame, VideoResolution, VideoRotation},
+    video_source::native::NativeVideoSource,
+};
+use livekit::{
+    options::{TrackPublishOptions, VideoCodec},
+    track::{LocalTrack, LocalVideoTrack},
+    Room, RoomResult,
+};
+use std::sync::Arc;
+use tokio::{sync::oneshot, task::JoinHandle, time};
+
+/// Parameters for the solid-color frames generated with [`SolidColorTrack`].
+#[derive(Clone, Debug)]
+pub struct SolidColorParams {
+    pub width: u32,
+    pub height: u32,
+    /// Y-plane value (0..255). U and V planes are fixed at 128 (neutral gray).
+    pub luma: u8,
+}
+
+/// Video track which generates and publishes solid-color I420 frames.
+///
+/// Analogous to [`super::audio::SineTrack`] for audio.
+pub struct SolidColorTrack {
+    rtc_source: NativeVideoSource,
+    params: SolidColorParams,
+    room: Arc<Room>,
+    handle: Option<TrackHandle>,
+}
+
+struct TrackHandle {
+    close_tx: oneshot::Sender<()>,
+    track: LocalVideoTrack,
+    task: JoinHandle<()>,
+}
+
+impl SolidColorTrack {
+    pub fn new(room: Arc<Room>, params: SolidColorParams) -> Self {
+        Self {
+            rtc_source: NativeVideoSource::new(
+                VideoResolution { width: params.width, height: params.height },
+                false,
+            ),
+            params,
+            room,
+            handle: None,
+        }
+    }
+
+    pub async fn publish(&mut self, codec: VideoCodec, simulcast: bool) -> RoomResult<()> {
+        let (close_tx, close_rx) = oneshot::channel();
+        let track = LocalVideoTrack::create_video_track(
+            "solid-color-track",
+            RtcVideoSource::Native(self.rtc_source.clone()),
+        );
+        let task =
+            tokio::spawn(Self::track_task(close_rx, self.rtc_source.clone(), self.params.clone()));
+        self.room
+            .local_participant()
+            .publish_track(
+                LocalTrack::Video(track.clone()),
+                TrackPublishOptions { video_codec: codec, simulcast, ..Default::default() },
+            )
+            .await?;
+        let handle = TrackHandle { close_tx, track, task };
+        self.handle = Some(handle);
+        Ok(())
+    }
+
+    pub async fn unpublish(&mut self) -> RoomResult<()> {
+        if let Some(handle) = self.handle.take() {
+            handle.close_tx.send(()).ok();
+            handle.task.await.ok();
+            self.room.local_participant().unpublish_track(&handle.track.sid()).await?;
+        }
+        Ok(())
+    }
+
+    async fn track_task(
+        mut close_rx: oneshot::Receiver<()>,
+        rtc_source: NativeVideoSource,
+        params: SolidColorParams,
+    ) {
+        let interval = std::time::Duration::from_millis(1000 / 5); // ~5 FPS
+        loop {
+            if close_rx.try_recv().is_ok() {
+                break;
+            }
+            let mut buffer = I420Buffer::new(params.width, params.height);
+            let (data_y, data_u, data_v) = buffer.data_mut();
+            data_y.fill(params.luma);
+            data_u.fill(128);
+            data_v.fill(128);
+
+            let frame =
+                VideoFrame { rotation: VideoRotation::VideoRotation0, timestamp_us: 0, buffer };
+            rtc_source.capture_frame(&frame);
+            time::sleep(interval).await;
+        }
+    }
+}

livekit/tests/video_test.rs

@@ -0,0 +1,151 @@
+// Copyright 2026 LiveKit, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#[cfg(feature = "__lk-e2e-test")]
+use {
+    anyhow::{anyhow, Ok, Result},
+    common::{
+        test_rooms,
+        video::{SolidColorParams, SolidColorTrack},
+    },
+    futures_util::StreamExt,
+    libwebrtc::video_stream::native::NativeVideoStream,
+    livekit::{options::VideoCodec, prelude::*},
+    std::{sync::Arc, time::Duration},
+    tokio::time::timeout,
+};
+
+mod common;
+
+#[cfg(feature = "__lk-e2e-test")]
+struct VideoTestParams {
+    codec: VideoCodec,
+    width: u32,
+    height: u32,
+    simulcast: bool,
+}
+
+#[cfg(feature = "__lk-e2e-test")]
+#[test_log::test(tokio::test)]
+async fn test_video() -> Result<()> {
+    let test_params = [
+        VideoTestParams { codec: VideoCodec::VP8,  width: 640,  height: 360, simulcast: false },
+        VideoTestParams { codec: VideoCodec::VP8,  width: 1280, height: 720, simulcast: true },
+        VideoTestParams { codec: VideoCodec::H264, width: 640,  height: 360, simulcast: false },
+        VideoTestParams { codec: VideoCodec::H264, width: 1280, height: 720, simulcast: true },
+        VideoTestParams { codec: VideoCodec::H265, width: 640,  height: 360, simulcast: false },
+        VideoTestParams { codec: VideoCodec::H265, width: 1280, height: 720, simulcast: true },
+        VideoTestParams { codec: VideoCodec::VP9,  width: 640,  height: 360, simulcast: false },
+    ];
+    for params in test_params {
+        log::info!("Testing with {}", params);
+        test_video_with(params).await?;
+    }
+    Ok(())
+}
+
+/// Tests video transfer between two participants.
+///
+/// Verifies that video can be published and received correctly by publishing
+/// solid-color I420 frames and checking the average luminance on the subscriber end.
+///
+#[cfg(feature = "__lk-e2e-test")]
+async fn test_video_with(params: VideoTestParams) -> Result<()> {
+    let mut rooms = test_rooms(2).await?;
+    let (pub_room, _) = rooms.pop().unwrap();
+    let (_, mut sub_room_events) = rooms.pop().unwrap();
+
+    const EXPECTED_LUMA: u8 = 180;
+    const LUMA_TOLERANCE: f64 = 30.0;
+    const FRAMES_TO_ANALYZE: usize = 1;
+
+    let solid_params =
+        SolidColorParams { width: params.width, height: params.height, luma: EXPECTED_LUMA };
+    let mut solid_track = SolidColorTrack::new(Arc::new(pub_room), solid_params);
+    solid_track.publish(params.codec, params.simulcast).await?;
+
+    let track: RemoteTrack = timeout(Duration::from_secs(15), async {
+        loop {
+            let Some(event) = sub_room_events.recv().await else {
+                Err(anyhow!("Never received track"))?
+            };
+            let RoomEvent::TrackSubscribed { track, publication, .. } = event else {
+                continue;
+            };
+            assert_eq!(publication.simulcasted(), params.simulcast);
+            break Ok(track.into());
+        }
+    })
+    .await??;
+
+    let RemoteTrack::Video(track) = track else { Err(anyhow!("Expected video track"))? };
+    let mut stream = NativeVideoStream::new(track.rtc_track());
+
+    let receive_frames = async {
+        let mut frames_analyzed = 0;
+
+        while let Some(frame) = stream.next().await {
+            log::info!("Received frame: {:?}", frame);
+
+            let (width, height) = (frame.buffer.width(), frame.buffer.height());
+            assert!(width > 0 && height > 0, "Frame has zero dimensions");
+
+            let expected_ar = params.width as f64 / params.height as f64;
+            let actual_ar = width as f64 / height as f64;
+            assert!(
+                (actual_ar - expected_ar).abs() < 0.1,
+                "Aspect ratio mismatch: {}x{} ({:.3}) != expected {:.3}",
+                width,
+                height,
+                actual_ar,
+                expected_ar
+            );
+
+            let i420 = frame.buffer.to_i420();
+            let (data_y, _, _) = i420.data();
+            let avg_luma = data_y.iter().map(|&b| b as f64).sum::<f64>() / data_y.len() as f64;
+
+            assert!(
+                (avg_luma - EXPECTED_LUMA as f64).abs() < LUMA_TOLERANCE,
+                "Average luma {:.1} not within {} of expected {}",
+                avg_luma,
+                LUMA_TOLERANCE,
+                EXPECTED_LUMA
+            );
+
+            frames_analyzed += 1;
+            if frames_analyzed >= FRAMES_TO_ANALYZE {
+                break;
+            }
+        }
+        assert_eq!(frames_analyzed, FRAMES_TO_ANALYZE);
+    };
+
+    timeout(Duration::from_secs(60), receive_frames).await?;
+    Ok(())
+}
+
+#[cfg(feature = "__lk-e2e-test")]
+impl std::fmt::Display for VideoTestParams {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}x{}, {}, simulcast={}",
+            self.width,
+            self.height,
+            self.codec.as_str(),
+            self.simulcast
+        )
+    }
+}