How can I multithread video decoding?

[ThatNerdUKnow]

I have this struct

pub struct Video {
    input: Input,
    decoder: VideoDecoder,
    video_index: usize,
    scaler: Scaler,
}

I'm currently implementing my Video struct as an iterator of frames, however this only runs on one core. How can I enable multithreading for decoder.recieve_frame?

impl Iterator for Video {
    type Item = VideoFrame;

    fn next(&mut self) -> Option<Self::Item> {
        // This is an iterator of each packet in the selected video stream
        let packets = self
            .input
            .packets()
            .filter(|(stream, _packet)| stream.index() == self.video_index)
            .map(|(_stream, packet)| packet);

        for packet in packets {
            while self.decoder.send_packet(&packet)
                != Err(AVError::Other {
                    errno: libc::EAGAIN,
                })
            {
                break;
            }

            // Allocate an empty frame for our decoder to use
            // the relationship of packet to frame is not 1:1, so
            // if an error throws, just continue
            let mut frame = VideoFrame::empty();
            match self.decoder.receive_frame(&mut frame) {
                Ok(_) => {
                    let mut scaled_frame = VideoFrame::empty();
                    self.scaler.run(&frame, &mut scaled_frame).unwrap();
                    return Some(scaled_frame);
                }
                Err(_) => continue,
            }
        }

        // Send eof to decoder so it can clean up
        self.decoder
            .send_eof()
            .into_report()
            .attach_printable("Encountered error when decoding video")
            .unwrap();
        None
    }
}

in my constructor for my Video type, I have the following

        let mut decoder = context_decoder
            .decoder()
            .video()
            .into_report()
            .change_context(VideoError::Construct(path.as_ref().to_owned()))?;

        let mut threading_config = decoder.threading();
        threading_config.count = num_cpus::get();
        threading_config.kind = ThreadingType::Slice;

        decoder.set_threading(threading_config);

Apparently editing the threading configuration for my decoder doesn't seem to do anything

[gcanat]

Any chance you managed to find a solution ? Finding myself in the same situation...
Thanks!

[ThatNerdUKnow]

I haven't but one thing i've had on my mind is by manually picking the decoder instead of letting FFMPEG decide. I'm pretty sure context_decoder came from an iterator of decoders? It's been a minute since I last touched this library