Struct MacOsDecoder 

pub struct MacOsDecoder { /* private fields */ }

Low-latency H.264/H.265 decoder backed by macOS VideoToolbox.

Implementations

impl MacOsDecoder

pub fn new(options: DecoderOptions) -> Result<Self, VideoError>

Create a VideoToolbox decoder using the supplied latency policy.

Examples found in repository

examples/decode_access_unit.rs (lines 30-33)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use std::{
        env, fs, thread,
        time::{Duration, Instant},
    };

    use openipc_video::{
        DecoderOptions, EncodedAccessUnit, PlatformDecoder, VideoCodec, VideoDecoder,
        VideoTimestamp,
    };

    let mut args = env::args().skip(1);
    let codec =
        match args.next().as_deref() {
            Some("h264") => VideoCodec::H264,
            Some("h265") | Some("hevc") => VideoCodec::H265,
            _ => return Err(
                "usage: decode_access_unit <h264|h265> <annex-b-access-unit> [--allow-software]"
                    .into(),
            ),
        };
    let path = args
        .next()
        .ok_or("usage: decode_access_unit <h264|h265> <annex-b-access-unit> [--allow-software]")?;
    let allow_software = args.any(|argument| argument == "--allow-software");
    let data = fs::read(path)?;
    let capabilities = PlatformDecoder::probe_capabilities();
    println!("capabilities={capabilities:?}");
    let mut decoder = PlatformDecoder::new(DecoderOptions {
        require_hardware: !allow_software,
        ..DecoderOptions::default()
    })?;
    let outcome = decoder.submit(EncodedAccessUnit::new(
        codec,
        data,
        VideoTimestamp::from_rtp(0),
        true,
    ))?;
    println!("submit={outcome:?}");

    let deadline = Instant::now() + Duration::from_secs(1);
    while Instant::now() < deadline {
        if let Some(frame) = decoder.latest_frame() {
            let dimensions = frame.dimensions();
            println!(
                "decoded={}x{} pixel_format={:?}",
                dimensions.width,
                dimensions.height,
                openipc_video::DecodedSurface::pixel_format(&frame.surface),
            );
            #[cfg(target_os = "macos")]
            println!("iosurface={}", frame.surface.is_io_surface_backed());
            #[cfg(target_os = "linux")]
            println!(
                "drm_fourcc={:#010x} pitches={:?}",
                frame.surface.drm_fourcc(),
                frame.surface.plane_pitches()
            );
            #[cfg(target_os = "windows")]
            println!(
                "d3d11_subresource={} texture={:?}",
                frame.surface.subresource_index(),
                frame.surface.texture()
            );
            return Ok(());
        }
        thread::sleep(Duration::from_millis(2));
    }
    Err(format!("no decoded frame; stats={:?}", decoder.stats()).into())
}

pub fn probe_capabilities() -> DecoderCapabilities

Query VideoToolbox H.264 and H.265 hardware support.

Examples found in repository

examples/decode_access_unit.rs (line 28)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use std::{
        env, fs, thread,
        time::{Duration, Instant},
    };

    use openipc_video::{
        DecoderOptions, EncodedAccessUnit, PlatformDecoder, VideoCodec, VideoDecoder,
        VideoTimestamp,
    };

    let mut args = env::args().skip(1);
    let codec =
        match args.next().as_deref() {
            Some("h264") => VideoCodec::H264,
            Some("h265") | Some("hevc") => VideoCodec::H265,
            _ => return Err(
                "usage: decode_access_unit <h264|h265> <annex-b-access-unit> [--allow-software]"
                    .into(),
            ),
        };
    let path = args
        .next()
        .ok_or("usage: decode_access_unit <h264|h265> <annex-b-access-unit> [--allow-software]")?;
    let allow_software = args.any(|argument| argument == "--allow-software");
    let data = fs::read(path)?;
    let capabilities = PlatformDecoder::probe_capabilities();
    println!("capabilities={capabilities:?}");
    let mut decoder = PlatformDecoder::new(DecoderOptions {
        require_hardware: !allow_software,
        ..DecoderOptions::default()
    })?;
    let outcome = decoder.submit(EncodedAccessUnit::new(
        codec,
        data,
        VideoTimestamp::from_rtp(0),
        true,
    ))?;
    println!("submit={outcome:?}");

    let deadline = Instant::now() + Duration::from_secs(1);
    while Instant::now() < deadline {
        if let Some(frame) = decoder.latest_frame() {
            let dimensions = frame.dimensions();
            println!(
                "decoded={}x{} pixel_format={:?}",
                dimensions.width,
                dimensions.height,
                openipc_video::DecodedSurface::pixel_format(&frame.surface),
            );
            #[cfg(target_os = "macos")]
            println!("iosurface={}", frame.surface.is_io_surface_backed());
            #[cfg(target_os = "linux")]
            println!(
                "drm_fourcc={:#010x} pitches={:?}",
                frame.surface.drm_fourcc(),
                frame.surface.plane_pitches()
            );
            #[cfg(target_os = "windows")]
            println!(
                "d3d11_subresource={} texture={:?}",
                frame.surface.subresource_index(),
                frame.surface.texture()
            );
            return Ok(());
        }
        thread::sleep(Duration::from_millis(2));
    }
    Err(format!("no decoded frame; stats={:?}", decoder.stats()).into())
}

Trait Implementations

impl Drop for MacOsDecoder

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 VideoDecoder for MacOsDecoder

type Surface = MacOsVideoFrame

Native decoded surface type produced by this backend.

fn capabilities(&self) -> DecoderCapabilities

Query decoder support on the current machine.

fn configure(&mut self, config: CodecConfig) -> Result<(), VideoError>

Explicitly configure or reconfigure the platform decoder.

fn submit( &mut self, frame: EncodedAccessUnit, ) -> Result<SubmitOutcome, VideoError>

Submit one complete encoded Annex-B access unit.

fn latest_frame(&mut self) -> Option<DecodedFrame<Self::Surface>>

Take the newest decoded frame, if one is ready.

fn flush(&mut self) -> Result<(), VideoError>

Clear decoder state and queued work.

fn stats(&self) -> DecoderStats

Read cumulative decoder statistics.