const FB_WIDTH: usize = 640;
const FB_HEIGHT: usize = 360;
const PIXEL_SIZE: usize = 4;

#[derive(Clone)]
struct FrameData {
    framebuffer: Arc<Mutex<Vec<u8>>>,
    video_frame: Arc<Mutex<VideoFrame<I420Buffer>>>,
}

let source = NativeVideoSource::new(VideoResolution {
    width: FB_WIDTH as u32,
    height: FB_HEIGHT as u32,
});
let track = LocalVideoTrack::create_video_track("file", RtcVideoSource::Native(source.clone()));
room.local_participant().publish_track(LocalTrack::Video(track), TrackPublishOptions {
    source: TrackSource::Camera,
    ..Default::default()
}).await.unwrap();

tokio::spawn(async move {
    let file = File::open("test.h264").unwrap();
    let reader = BufReader::new(file);
    let mut h264 = H264Reader::new(reader, 1_048_576);

    let mut ticker = tokio::time::interval(Duration::from_millis(33));

    let mut data = FrameData {
        framebuffer: Arc::new(Mutex::new(vec![0u8; FB_WIDTH * FB_HEIGHT * 4])),
        video_frame: Arc::new(Mutex::new(VideoFrame {
            rotation: VideoRotation::VideoRotation0,
            buffer: I420Buffer::new(FB_WIDTH as u32, FB_HEIGHT as u32),
            timestamp_us: 0,
        })),
    };

    loop {
        let nal = match h264.next_nal() {
            Ok(nal) => nal,
            Err(err) => {
                println!("All video frames parsed and sent: {err}");
                break;
            }
        };

        let data1 = nal.data.freeze();

        println!("{}", data1.len());

        let mut framebuffer = data.framebuffer.lock().await;
        let mut video_frame = data.video_frame.lock().await;
        let i420_buffer = &mut video_frame.buffer;

        let (stride_y, stride_u, stride_v) = i420_buffer.strides();
        let (data_y, data_u, data_v) = i420_buffer.data_mut();

        *framebuffer = data1.to_vec();

        println!("{}", framebuffer.len());

        println!("{}", (FB_WIDTH * PIXEL_SIZE) * FB_HEIGHT);

        yuv_helper::abgr_to_i420(
            &framebuffer,
            (FB_WIDTH * PIXEL_SIZE) as u32,
            data_y,
            stride_y,
            data_u,
            stride_u,
            data_v,
            stride_v,
            FB_WIDTH as i32,
            FB_HEIGHT as i32,
        ).expect("panic");

        source.capture_frame(&*video_frame);

        let _ = ticker.tick().await;
    }

    Result::<(), ()>::Ok(())
}).await.unwrap().unwrap();

dst isn't large enough

export RUST_LOG=libwebrtc=debug

RUST_LOG=libwebrtc=debug cargo run

RUST_LOG=debug cargo run