Camera hangs - not able get u8 data into image buffer of slint

[MohaBeacon]

use slint::PlatformError;
use v4l::buffer::Type;
use v4l::io::mmap::Stream;
use v4l::io::traits::CaptureStream;
use v4l::video::Capture;
use v4l::Device;
use v4l::FourCC;
use image;
use slint::slint;
slint!{
    import { Button }  from "std-widgets.slint";

global Palette {
    out property <color> window-background: #2e3440;
    out property <color> widget-background: #4c566a;
    out property <color> widget-stroke: #eceff4;
    out property <color> window-border: #d8dee9;
    out property <color> text-color: #eceff4;
    out property <color> hyper-blue: #5e81ac;
}

export component MainWindow inherits Window {
    background: Palette.window-background;

    width: 1024px;
    height: 720px;

    in property camera_image <=> camera_image.source;
    in property scale_image <=> scale_image.source;
    

    in property lower_scale_temp_text <=> lower_scale_temp_text.text;
    in property upper_scale_temp_text <=> upper_scale_temp_text.text;
    
    callback autoscale-toggled(bool);
    callback manual-scale-max-temp-increased();
    callback manual-scale-max-temp-decreased();
    callback manual-scale-min-temp-increased();
    callback manual-scale-min-temp-decreased();
    callback mode-decreased();
    callback mode-increased();
    

    HorizontalLayout {
        VerticalLayout { 
            spacing: 3px;
            HorizontalLayout {
                camera_image := Image {
                    width: 1024px;
                    height: 720px;                    
                }
                VerticalLayout {    
                    spacing: 1px;  
                    padding-left: 3px;             
                    padding-right: 3px;
                    upper_scale_temp_text := Text {
                        color: Palette.text-color;
                        vertical-alignment: TextVerticalAlignment.center;
                        horizontal-alignment: TextHorizontalAlignment.center;
                    }
                    scale_image := Image{}
                    lower_scale_temp_text := Text {
                        color: Palette.text-color;
                        vertical-alignment: TextVerticalAlignment.center;
                        horizontal-alignment: TextHorizontalAlignment.center;
                    }
                }
            }
            
            
        }
        
    }
}

}

fn main() -> Result<(),PlatformError> {
    
   

    let main_window = MainWindow::new()?;
    
    
    // handle dynamic UI stuff
    let handle_weak = main_window.as_weak();
    let thread = std::thread::spawn(move || {

        let mut cam_image_shape ;
        let mut cam_data_buffer: &[u8];
        
        let mut stream_opt: Option<Stream> = None;

    
        let mut dev = Device::new(0).expect("Failed to open device");
        let mut fmt = dev.format().expect("Failed to read format");
        fmt.width = 1280;
        fmt.height = 720;
        fmt.fourcc = FourCC::new(b"YUYV");
        cam_image_shape = (fmt.width, fmt.height);
        dev.set_format(&fmt).expect("Failed to write format");
        stream_opt =
            Some(Stream::with_buffers(&mut dev, Type::VideoCapture, 4).expect("Failed to create buffer stream"));

        loop {
           
            let result = stream_opt.as_mut().unwrap().next().unwrap();
            cam_data_buffer = result.0;

            let rgb_buffer_size = 3 * cam_image_shape.0 as usize * cam_image_shape.1 as usize;
            let mut cam_rgb_raw_buf = cam_data_buffer.to_vec();

            // decode camera data
            let mut camera_rgb_image =
                image::RgbImage::from_raw(cam_image_shape.0, cam_image_shape.1, cam_rgb_raw_buf).unwrap();

            // flip image horizontally
            camera_rgb_image = image::DynamicImage::ImageRgb8(camera_rgb_image).fliph().to_rgb8();

               
            let displayed_image =camera_rgb_image;

            let handle_copy = handle_weak.clone();
            slint::invoke_from_event_loop(move || {
                let mw = handle_copy.unwrap();
                let ui_image = slint::Image::from_rgb8(slint::SharedPixelBuffer::clone_from_slice(
                    &displayed_image,
                    displayed_image.width(),
                    displayed_image.height(),
                ));

                mw.set_camera_image(ui_image);
            })
            .unwrap();
        }
    });
    main_window.run();
    thread.join().unwrap();

    Ok(())
}

[ogoffart]

What is the problem in this example?
It look similar to #2541