Struct VideoDecoder 

pub struct VideoDecoder { /* private fields */ }

Implementations

impl VideoDecoder

pub fn open(input: &InputContext, config: VideoDecoderConfig) -> Result<Self>

Examples found in repository

examples/transcode_file.rs (lines 24-30)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = env::args().skip(1);
    let input_path = args
        .next()
        .map(PathBuf::from)
        .ok_or("usage: transcode_file <input> <output> [max_frames] [encoder]")?;
    let output_path = args
        .next()
        .map(PathBuf::from)
        .ok_or("missing output path")?;
    let max_frames = args.next().and_then(|value| value.parse::<usize>().ok());
    let encoder_name = args.next();

    let started = Instant::now();
    let mut input = InputContext::open(input_path.to_string_lossy().to_string())?;
    let stream = input.best_video_stream()?;
    let mut decoder = VideoDecoder::open(
        &input,
        VideoDecoderConfig {
            stream_index: stream.stream_index,
            mode: DecodeMode::Cpu,
        },
    )?;
    let fps = stream
        .avg_frame_rate
        .as_f64()
        .filter(|fps| *fps > 0.0)
        .unwrap_or(60.0)
        .round()
        .clamp(1.0, u32::MAX as f64) as u32;
    let mut config =
        VideoEncoderConfig::cpu_rgba(stream.width, stream.height, fps, VideoCodec::H264);
    if let Some(encoder_name) = encoder_name {
        config.encoder_name = Some(encoder_name);
    }
    let mut encoder = MuxedEncoder::create(output_path.to_string_lossy().to_string(), config)?;

    let mut frames = 0_usize;
    'decode: while let Some(packet) = input.read_packet()? {
        decoder.send_packet(&packet)?;
        while let Some(frame) = decoder.receive_cpu_frame()? {
            encoder.write_video_frame(&frame)?;
            frames = frames.saturating_add(1);
            if max_frames.is_some_and(|limit| frames >= limit) {
                break 'decode;
            }
        }
    }

    if max_frames.is_none_or(|limit| frames < limit) {
        decoder.send_eof()?;
        while let Some(frame) = decoder.receive_cpu_frame()? {
            encoder.write_video_frame(&frame)?;
            frames = frames.saturating_add(1);
            if max_frames.is_some_and(|limit| frames >= limit) {
                break;
            }
        }
    }

    encoder.finish()?;
    println!("input={}", input_path.display());
    println!("output={}", output_path.display());
    println!("frames={frames}");
    println!("elapsed_ms={}", started.elapsed().as_millis());
    println!(
        "fps={:.2}",
        frames as f64 / started.elapsed().as_secs_f64().max(1e-9)
    );
    Ok(())
}

examples/decode_file.rs (lines 44-50)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = env::args().skip(1);
    let path = args.next().map(PathBuf::from).ok_or(
        "usage: decode_file <path> [max_frames] [cpu|cuda|metal|vulkan] [gpu|rgba|cuda-rgba]",
    )?;
    let next = args.next();
    let (max_frames, mode_arg) = match next {
        Some(value) => match value.parse::<usize>() {
            Ok(max_frames) => (Some(max_frames), args.next()),
            Err(_) => (None, Some(value)),
        },
        None => (None, None),
    };
    let mode = match mode_arg.as_deref() {
        Some("cuda") => DecodeMode::Gpu(GpuBackend::Cuda),
        Some("metal") => DecodeMode::Gpu(GpuBackend::Metal),
        Some("vulkan") => DecodeMode::Gpu(GpuBackend::Vulkan),
        Some("cpu") | None => DecodeMode::Cpu,
        Some(other) => return Err(format!("unknown decode mode `{other}`").into()),
    };
    let receive = match args.next().as_deref() {
        Some("gpu") => ReceiveMode::Gpu,
        Some("cuda-rgba") => ReceiveMode::CudaRgba,
        Some("rgba") | None => ReceiveMode::Rgba,
        Some(other) => return Err(format!("unknown receive mode `{other}`").into()),
    };

    let started = Instant::now();
    let mut input = InputContext::open(path.to_string_lossy().to_string())?;
    let stream = input.best_video_stream()?;
    let open_elapsed = started.elapsed();
    let mut decoder = VideoDecoder::open(
        &input,
        VideoDecoderConfig {
            stream_index: stream.stream_index,
            mode,
        },
    )?;

    let decode_started = Instant::now();
    let mut cuda = CudaRgbaState::new(receive, stream.width, stream.height)?;
    let mut frames = 0_usize;
    let mut bytes = 0_usize;

    'decode: while let Some(packet) = input.read_packet()? {
        decoder.send_packet(&packet)?;
        while let Some(frame_bytes) = receive_frame(&mut decoder, mode, receive, cuda.as_mut())? {
            frames = frames.saturating_add(1);
            bytes = bytes.saturating_add(frame_bytes);
            if max_frames.is_some_and(|limit| frames >= limit) {
                break 'decode;
            }
        }
    }

    if max_frames.is_none_or(|limit| frames < limit) {
        decoder.send_eof()?;
        while let Some(frame_bytes) = receive_frame(&mut decoder, mode, receive, cuda.as_mut())? {
            frames = frames.saturating_add(1);
            bytes = bytes.saturating_add(frame_bytes);
            if max_frames.is_some_and(|limit| frames >= limit) {
                break;
            }
        }
    }

    let decode_elapsed = decode_started.elapsed();
    let total_elapsed = started.elapsed();
    let usage = usage();
    println!("path={}", path.display());
    println!("codec={:?}", stream.codec);
    println!("dimensions={}x{}", stream.width, stream.height);
    println!("frames={frames}");
    println!("mode={mode:?}");
    println!("receive={receive:?}");
    println!("decoded_frame_bytes={bytes}");
    println!("open_ms={}", millis(open_elapsed));
    println!("decode_ms={}", millis(decode_elapsed));
    println!("total_ms={}", millis(total_elapsed));
    println!(
        "fps={:.2}",
        frames as f64 / decode_elapsed.as_secs_f64().max(1e-9)
    );
    println!("user_cpu_ms={}", millis(usage.user));
    println!("system_cpu_ms={}", millis(usage.system));
    println!("max_rss_platform_units={}", usage.max_rss);
    Ok(())
}

pub fn codec(&self) -> VideoCodec

pub fn stream_index(&self) -> usize

pub fn time_base(&self) -> Rational

pub fn send_packet(&mut self, packet: &Packet) -> Result<()>

Examples found in repository

examples/transcode_file.rs (line 47)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = env::args().skip(1);
    let input_path = args
        .next()
        .map(PathBuf::from)
        .ok_or("usage: transcode_file <input> <output> [max_frames] [encoder]")?;
    let output_path = args
        .next()
        .map(PathBuf::from)
        .ok_or("missing output path")?;
    let max_frames = args.next().and_then(|value| value.parse::<usize>().ok());
    let encoder_name = args.next();

    let started = Instant::now();
    let mut input = InputContext::open(input_path.to_string_lossy().to_string())?;
    let stream = input.best_video_stream()?;
    let mut decoder = VideoDecoder::open(
        &input,
        VideoDecoderConfig {
            stream_index: stream.stream_index,
            mode: DecodeMode::Cpu,
        },
    )?;
    let fps = stream
        .avg_frame_rate
        .as_f64()
        .filter(|fps| *fps > 0.0)
        .unwrap_or(60.0)
        .round()
        .clamp(1.0, u32::MAX as f64) as u32;
    let mut config =
        VideoEncoderConfig::cpu_rgba(stream.width, stream.height, fps, VideoCodec::H264);
    if let Some(encoder_name) = encoder_name {
        config.encoder_name = Some(encoder_name);
    }
    let mut encoder = MuxedEncoder::create(output_path.to_string_lossy().to_string(), config)?;

    let mut frames = 0_usize;
    'decode: while let Some(packet) = input.read_packet()? {
        decoder.send_packet(&packet)?;
        while let Some(frame) = decoder.receive_cpu_frame()? {
            encoder.write_video_frame(&frame)?;
            frames = frames.saturating_add(1);
            if max_frames.is_some_and(|limit| frames >= limit) {
                break 'decode;
            }
        }
    }

    if max_frames.is_none_or(|limit| frames < limit) {
        decoder.send_eof()?;
        while let Some(frame) = decoder.receive_cpu_frame()? {
            encoder.write_video_frame(&frame)?;
            frames = frames.saturating_add(1);
            if max_frames.is_some_and(|limit| frames >= limit) {
                break;
            }
        }
    }

    encoder.finish()?;
    println!("input={}", input_path.display());
    println!("output={}", output_path.display());
    println!("frames={frames}");
    println!("elapsed_ms={}", started.elapsed().as_millis());
    println!(
        "fps={:.2}",
        frames as f64 / started.elapsed().as_secs_f64().max(1e-9)
    );
    Ok(())
}

examples/decode_file.rs (line 58)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = env::args().skip(1);
    let path = args.next().map(PathBuf::from).ok_or(
        "usage: decode_file <path> [max_frames] [cpu|cuda|metal|vulkan] [gpu|rgba|cuda-rgba]",
    )?;
    let next = args.next();
    let (max_frames, mode_arg) = match next {
        Some(value) => match value.parse::<usize>() {
            Ok(max_frames) => (Some(max_frames), args.next()),
            Err(_) => (None, Some(value)),
        },
        None => (None, None),
    };
    let mode = match mode_arg.as_deref() {
        Some("cuda") => DecodeMode::Gpu(GpuBackend::Cuda),
        Some("metal") => DecodeMode::Gpu(GpuBackend::Metal),
        Some("vulkan") => DecodeMode::Gpu(GpuBackend::Vulkan),
        Some("cpu") | None => DecodeMode::Cpu,
        Some(other) => return Err(format!("unknown decode mode `{other}`").into()),
    };
    let receive = match args.next().as_deref() {
        Some("gpu") => ReceiveMode::Gpu,
        Some("cuda-rgba") => ReceiveMode::CudaRgba,
        Some("rgba") | None => ReceiveMode::Rgba,
        Some(other) => return Err(format!("unknown receive mode `{other}`").into()),
    };

    let started = Instant::now();
    let mut input = InputContext::open(path.to_string_lossy().to_string())?;
    let stream = input.best_video_stream()?;
    let open_elapsed = started.elapsed();
    let mut decoder = VideoDecoder::open(
        &input,
        VideoDecoderConfig {
            stream_index: stream.stream_index,
            mode,
        },
    )?;

    let decode_started = Instant::now();
    let mut cuda = CudaRgbaState::new(receive, stream.width, stream.height)?;
    let mut frames = 0_usize;
    let mut bytes = 0_usize;

    'decode: while let Some(packet) = input.read_packet()? {
        decoder.send_packet(&packet)?;
        while let Some(frame_bytes) = receive_frame(&mut decoder, mode, receive, cuda.as_mut())? {
            frames = frames.saturating_add(1);
            bytes = bytes.saturating_add(frame_bytes);
            if max_frames.is_some_and(|limit| frames >= limit) {
                break 'decode;
            }
        }
    }

    if max_frames.is_none_or(|limit| frames < limit) {
        decoder.send_eof()?;
        while let Some(frame_bytes) = receive_frame(&mut decoder, mode, receive, cuda.as_mut())? {
            frames = frames.saturating_add(1);
            bytes = bytes.saturating_add(frame_bytes);
            if max_frames.is_some_and(|limit| frames >= limit) {
                break;
            }
        }
    }

    let decode_elapsed = decode_started.elapsed();
    let total_elapsed = started.elapsed();
    let usage = usage();
    println!("path={}", path.display());
    println!("codec={:?}", stream.codec);
    println!("dimensions={}x{}", stream.width, stream.height);
    println!("frames={frames}");
    println!("mode={mode:?}");
    println!("receive={receive:?}");
    println!("decoded_frame_bytes={bytes}");
    println!("open_ms={}", millis(open_elapsed));
    println!("decode_ms={}", millis(decode_elapsed));
    println!("total_ms={}", millis(total_elapsed));
    println!(
        "fps={:.2}",
        frames as f64 / decode_elapsed.as_secs_f64().max(1e-9)
    );
    println!("user_cpu_ms={}", millis(usage.user));
    println!("system_cpu_ms={}", millis(usage.system));
    println!("max_rss_platform_units={}", usage.max_rss);
    Ok(())
}

pub fn send_eof(&mut self) -> Result<()>

Examples found in repository

examples/transcode_file.rs (line 58)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = env::args().skip(1);
    let input_path = args
        .next()
        .map(PathBuf::from)
        .ok_or("usage: transcode_file <input> <output> [max_frames] [encoder]")?;
    let output_path = args
        .next()
        .map(PathBuf::from)
        .ok_or("missing output path")?;
    let max_frames = args.next().and_then(|value| value.parse::<usize>().ok());
    let encoder_name = args.next();

    let started = Instant::now();
    let mut input = InputContext::open(input_path.to_string_lossy().to_string())?;
    let stream = input.best_video_stream()?;
    let mut decoder = VideoDecoder::open(
        &input,
        VideoDecoderConfig {
            stream_index: stream.stream_index,
            mode: DecodeMode::Cpu,
        },
    )?;
    let fps = stream
        .avg_frame_rate
        .as_f64()
        .filter(|fps| *fps > 0.0)
        .unwrap_or(60.0)
        .round()
        .clamp(1.0, u32::MAX as f64) as u32;
    let mut config =
        VideoEncoderConfig::cpu_rgba(stream.width, stream.height, fps, VideoCodec::H264);
    if let Some(encoder_name) = encoder_name {
        config.encoder_name = Some(encoder_name);
    }
    let mut encoder = MuxedEncoder::create(output_path.to_string_lossy().to_string(), config)?;

    let mut frames = 0_usize;
    'decode: while let Some(packet) = input.read_packet()? {
        decoder.send_packet(&packet)?;
        while let Some(frame) = decoder.receive_cpu_frame()? {
            encoder.write_video_frame(&frame)?;
            frames = frames.saturating_add(1);
            if max_frames.is_some_and(|limit| frames >= limit) {
                break 'decode;
            }
        }
    }

    if max_frames.is_none_or(|limit| frames < limit) {
        decoder.send_eof()?;
        while let Some(frame) = decoder.receive_cpu_frame()? {
            encoder.write_video_frame(&frame)?;
            frames = frames.saturating_add(1);
            if max_frames.is_some_and(|limit| frames >= limit) {
                break;
            }
        }
    }

    encoder.finish()?;
    println!("input={}", input_path.display());
    println!("output={}", output_path.display());
    println!("frames={frames}");
    println!("elapsed_ms={}", started.elapsed().as_millis());
    println!(
        "fps={:.2}",
        frames as f64 / started.elapsed().as_secs_f64().max(1e-9)
    );
    Ok(())
}

examples/decode_file.rs (line 69)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = env::args().skip(1);
    let path = args.next().map(PathBuf::from).ok_or(
        "usage: decode_file <path> [max_frames] [cpu|cuda|metal|vulkan] [gpu|rgba|cuda-rgba]",
    )?;
    let next = args.next();
    let (max_frames, mode_arg) = match next {
        Some(value) => match value.parse::<usize>() {
            Ok(max_frames) => (Some(max_frames), args.next()),
            Err(_) => (None, Some(value)),
        },
        None => (None, None),
    };
    let mode = match mode_arg.as_deref() {
        Some("cuda") => DecodeMode::Gpu(GpuBackend::Cuda),
        Some("metal") => DecodeMode::Gpu(GpuBackend::Metal),
        Some("vulkan") => DecodeMode::Gpu(GpuBackend::Vulkan),
        Some("cpu") | None => DecodeMode::Cpu,
        Some(other) => return Err(format!("unknown decode mode `{other}`").into()),
    };
    let receive = match args.next().as_deref() {
        Some("gpu") => ReceiveMode::Gpu,
        Some("cuda-rgba") => ReceiveMode::CudaRgba,
        Some("rgba") | None => ReceiveMode::Rgba,
        Some(other) => return Err(format!("unknown receive mode `{other}`").into()),
    };

    let started = Instant::now();
    let mut input = InputContext::open(path.to_string_lossy().to_string())?;
    let stream = input.best_video_stream()?;
    let open_elapsed = started.elapsed();
    let mut decoder = VideoDecoder::open(
        &input,
        VideoDecoderConfig {
            stream_index: stream.stream_index,
            mode,
        },
    )?;

    let decode_started = Instant::now();
    let mut cuda = CudaRgbaState::new(receive, stream.width, stream.height)?;
    let mut frames = 0_usize;
    let mut bytes = 0_usize;

    'decode: while let Some(packet) = input.read_packet()? {
        decoder.send_packet(&packet)?;
        while let Some(frame_bytes) = receive_frame(&mut decoder, mode, receive, cuda.as_mut())? {
            frames = frames.saturating_add(1);
            bytes = bytes.saturating_add(frame_bytes);
            if max_frames.is_some_and(|limit| frames >= limit) {
                break 'decode;
            }
        }
    }

    if max_frames.is_none_or(|limit| frames < limit) {
        decoder.send_eof()?;
        while let Some(frame_bytes) = receive_frame(&mut decoder, mode, receive, cuda.as_mut())? {
            frames = frames.saturating_add(1);
            bytes = bytes.saturating_add(frame_bytes);
            if max_frames.is_some_and(|limit| frames >= limit) {
                break;
            }
        }
    }

    let decode_elapsed = decode_started.elapsed();
    let total_elapsed = started.elapsed();
    let usage = usage();
    println!("path={}", path.display());
    println!("codec={:?}", stream.codec);
    println!("dimensions={}x{}", stream.width, stream.height);
    println!("frames={frames}");
    println!("mode={mode:?}");
    println!("receive={receive:?}");
    println!("decoded_frame_bytes={bytes}");
    println!("open_ms={}", millis(open_elapsed));
    println!("decode_ms={}", millis(decode_elapsed));
    println!("total_ms={}", millis(total_elapsed));
    println!(
        "fps={:.2}",
        frames as f64 / decode_elapsed.as_secs_f64().max(1e-9)
    );
    println!("user_cpu_ms={}", millis(usage.user));
    println!("system_cpu_ms={}", millis(usage.system));
    println!("max_rss_platform_units={}", usage.max_rss);
    Ok(())
}

pub fn flush(&mut self)

pub fn receive_cpu_frame(&mut self) -> Result<Option<CpuVideoFrame>>

Examples found in repository

examples/decode_file.rs (line 124)

fn receive_frame(
    decoder: &mut VideoDecoder,
    mode: DecodeMode,
    receive: ReceiveMode,
    cuda: Option<&mut CudaRgbaState>,
) -> lumen_ffmpeg::Result<Option<usize>> {
    match receive {
        ReceiveMode::Rgba => Ok(decoder.receive_rgba_frame()?.map(|frame| frame.data.len())),
        ReceiveMode::CudaRgba => match decoder.receive_gpu_frame()? {
            Some(frame) => {
                let Some(cuda) = cuda else {
                    return Err(lumen_ffmpeg::FfmpegError::new(
                        "decode_file",
                        "cuda-rgba receive mode requires a CUDA conversion state",
                    ));
                };
                cuda.convert(&frame)?;
                Ok(Some(frame.estimated_rgba_bytes() as usize))
            }
            None => Ok(None),
        },
        ReceiveMode::Gpu => match mode {
            DecodeMode::Cpu => Ok(decoder.receive_cpu_frame()?.map(|frame| frame.data.len())),
            DecodeMode::Gpu(_) => Ok(decoder.receive_gpu_frame()?.map(|_| 0)),
        },
    }
}

examples/transcode_file.rs (line 48)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = env::args().skip(1);
    let input_path = args
        .next()
        .map(PathBuf::from)
        .ok_or("usage: transcode_file <input> <output> [max_frames] [encoder]")?;
    let output_path = args
        .next()
        .map(PathBuf::from)
        .ok_or("missing output path")?;
    let max_frames = args.next().and_then(|value| value.parse::<usize>().ok());
    let encoder_name = args.next();

    let started = Instant::now();
    let mut input = InputContext::open(input_path.to_string_lossy().to_string())?;
    let stream = input.best_video_stream()?;
    let mut decoder = VideoDecoder::open(
        &input,
        VideoDecoderConfig {
            stream_index: stream.stream_index,
            mode: DecodeMode::Cpu,
        },
    )?;
    let fps = stream
        .avg_frame_rate
        .as_f64()
        .filter(|fps| *fps > 0.0)
        .unwrap_or(60.0)
        .round()
        .clamp(1.0, u32::MAX as f64) as u32;
    let mut config =
        VideoEncoderConfig::cpu_rgba(stream.width, stream.height, fps, VideoCodec::H264);
    if let Some(encoder_name) = encoder_name {
        config.encoder_name = Some(encoder_name);
    }
    let mut encoder = MuxedEncoder::create(output_path.to_string_lossy().to_string(), config)?;

    let mut frames = 0_usize;
    'decode: while let Some(packet) = input.read_packet()? {
        decoder.send_packet(&packet)?;
        while let Some(frame) = decoder.receive_cpu_frame()? {
            encoder.write_video_frame(&frame)?;
            frames = frames.saturating_add(1);
            if max_frames.is_some_and(|limit| frames >= limit) {
                break 'decode;
            }
        }
    }

    if max_frames.is_none_or(|limit| frames < limit) {
        decoder.send_eof()?;
        while let Some(frame) = decoder.receive_cpu_frame()? {
            encoder.write_video_frame(&frame)?;
            frames = frames.saturating_add(1);
            if max_frames.is_some_and(|limit| frames >= limit) {
                break;
            }
        }
    }

    encoder.finish()?;
    println!("input={}", input_path.display());
    println!("output={}", output_path.display());
    println!("frames={frames}");
    println!("elapsed_ms={}", started.elapsed().as_millis());
    println!(
        "fps={:.2}",
        frames as f64 / started.elapsed().as_secs_f64().max(1e-9)
    );
    Ok(())
}

pub fn receive_rgba_frame(&mut self) -> Result<Option<CpuVideoFrame>>

Receives the next decoded frame as RGBA8.

CPU decoders convert their native software frame with swscale. Hardware decoders first transfer the decoded frame into software memory, then use the same RGBA8 conversion path. This keeps callers independent from FFmpeg’s platform-specific GPU frame handles while still allowing decode itself to use VideoToolbox/NVDEC/Vulkan when available.

Examples found in repository

examples/decode_file.rs (line 109)

fn receive_frame(
    decoder: &mut VideoDecoder,
    mode: DecodeMode,
    receive: ReceiveMode,
    cuda: Option<&mut CudaRgbaState>,
) -> lumen_ffmpeg::Result<Option<usize>> {
    match receive {
        ReceiveMode::Rgba => Ok(decoder.receive_rgba_frame()?.map(|frame| frame.data.len())),
        ReceiveMode::CudaRgba => match decoder.receive_gpu_frame()? {
            Some(frame) => {
                let Some(cuda) = cuda else {
                    return Err(lumen_ffmpeg::FfmpegError::new(
                        "decode_file",
                        "cuda-rgba receive mode requires a CUDA conversion state",
                    ));
                };
                cuda.convert(&frame)?;
                Ok(Some(frame.estimated_rgba_bytes() as usize))
            }
            None => Ok(None),
        },
        ReceiveMode::Gpu => match mode {
            DecodeMode::Cpu => Ok(decoder.receive_cpu_frame()?.map(|frame| frame.data.len())),
            DecodeMode::Gpu(_) => Ok(decoder.receive_gpu_frame()?.map(|_| 0)),
        },
    }
}

pub fn receive_gpu_frame(&mut self) -> Result<Option<GpuVideoFrame>>

Examples found in repository

examples/decode_file.rs (line 110)

fn receive_frame(
    decoder: &mut VideoDecoder,
    mode: DecodeMode,
    receive: ReceiveMode,
    cuda: Option<&mut CudaRgbaState>,
) -> lumen_ffmpeg::Result<Option<usize>> {
    match receive {
        ReceiveMode::Rgba => Ok(decoder.receive_rgba_frame()?.map(|frame| frame.data.len())),
        ReceiveMode::CudaRgba => match decoder.receive_gpu_frame()? {
            Some(frame) => {
                let Some(cuda) = cuda else {
                    return Err(lumen_ffmpeg::FfmpegError::new(
                        "decode_file",
                        "cuda-rgba receive mode requires a CUDA conversion state",
                    ));
                };
                cuda.convert(&frame)?;
                Ok(Some(frame.estimated_rgba_bytes() as usize))
            }
            None => Ok(None),
        },
        ReceiveMode::Gpu => match mode {
            DecodeMode::Cpu => Ok(decoder.receive_cpu_frame()?.map(|frame| frame.data.len())),
            DecodeMode::Gpu(_) => Ok(decoder.receive_gpu_frame()?.map(|_| 0)),
        },
    }
}

Trait Implementations

impl Drop for VideoDecoder

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Send for VideoDecoder