Struct VideoDecoder 

pub struct VideoDecoder { /* private fields */ }

A video decoder for extracting frames from media files.

The decoder provides frame-by-frame access to video content with support for seeking, hardware acceleration, and format conversion.

Construction

Use VideoDecoder::open() to create a builder, then call VideoDecoderBuilder::build():

use ff_decode::VideoDecoder;
use ff_format::PixelFormat;

let decoder = VideoDecoder::open("video.mp4")?
    .output_format(PixelFormat::Rgba)
    .build()?;

Frame Decoding

Frames can be decoded one at a time or using the built-in iterator:

// Decode one frame
if let Some(frame) = decoder.decode_one()? {
    println!("Frame at {:?}", frame.timestamp().as_duration());
}

// Iterator form — VideoDecoder implements Iterator directly
for result in &mut decoder {
    let frame = result?;
    // Process frame...
}

Seeking

The decoder supports efficient seeking:

use ff_decode::SeekMode;
use std::time::Duration;

// Seek to 30 seconds (keyframe)
decoder.seek(Duration::from_secs(30), SeekMode::Keyframe)?;

// Seek to exact frame
decoder.seek(Duration::from_secs(30), SeekMode::Exact)?;

Implementations

impl VideoDecoder

pub fn open(path: impl AsRef<Path>) -> VideoDecoderBuilder

Opens a media file and returns a builder for configuring the decoder.

This is the entry point for creating a decoder. The returned builder allows setting options before the decoder is fully initialized.

Arguments

• path - Path to the media file to decode.

Examples

use ff_decode::VideoDecoder;

// Simple usage
let decoder = VideoDecoder::open("video.mp4")?
    .build()?;

// With options
let decoder = VideoDecoder::open("video.mp4")?
    .output_format(PixelFormat::Rgba)
    .hardware_accel(HardwareAccel::Auto)
    .build()?;

Note

This method does not validate that the file exists or is a valid media file. Validation occurs when VideoDecoderBuilder::build() is called.

pub fn stream_info(&self) -> &VideoStreamInfo

Returns the video stream information.

This contains metadata about the video stream including resolution, frame rate, codec, and color characteristics.

pub fn width(&self) -> u32

Returns the video width in pixels.

pub fn height(&self) -> u32

Returns the video height in pixels.

pub fn frame_rate(&self) -> f64

Returns the frame rate in frames per second.

pub fn duration(&self) -> Duration

Returns the total duration of the video.

Returns Duration::ZERO if duration is unknown.

pub fn duration_opt(&self) -> Option<Duration>

Returns the total duration of the video, or None for live streams or formats that do not carry duration information.

pub fn container_info(&self) -> &ContainerInfo

Returns container-level metadata (format name, bitrate, stream count).

pub fn position(&self) -> Duration

Returns the current playback position.

pub fn is_eof(&self) -> bool

Returns true if the end of stream has been reached.

pub fn path(&self) -> &Path

Returns the file path being decoded.

pub fn frame_pool(&self) -> Option<&Arc<dyn FramePool>>

Returns a reference to the frame pool, if configured.

pub fn hardware_accel(&self) -> HardwareAccel

Returns the currently active hardware acceleration mode.

This method returns the actual hardware acceleration being used, which may differ from what was requested:

• If HardwareAccel::Auto was requested, this returns the specific accelerator that was successfully initialized (e.g., HardwareAccel::Nvdec), or HardwareAccel::None if no hardware acceleration is available.
• If a specific accelerator was requested and initialization failed, the decoder creation would have returned an error.
• If HardwareAccel::None was requested, this always returns HardwareAccel::None.

Examples

use ff_decode::{VideoDecoder, HardwareAccel};

// Request automatic hardware acceleration
let decoder = VideoDecoder::open("video.mp4")?
    .hardware_accel(HardwareAccel::Auto)
    .build()?;

// Check which accelerator was selected
match decoder.hardware_accel() {
    HardwareAccel::None => println!("Using software decoding"),
    HardwareAccel::Nvdec => println!("Using NVIDIA NVDEC"),
    HardwareAccel::Qsv => println!("Using Intel Quick Sync"),
    HardwareAccel::VideoToolbox => println!("Using Apple VideoToolbox"),
    HardwareAccel::Vaapi => println!("Using VA-API"),
    HardwareAccel::Amf => println!("Using AMD AMF"),
    _ => unreachable!(),
}

pub fn decode_one(&mut self) -> Result<Option<VideoFrame>, DecodeError>

Decodes the next video frame.

This method reads and decodes a single frame from the video stream. Frames are returned in presentation order.

Returns

• Ok(Some(frame)) - A frame was successfully decoded
• Ok(None) - End of stream reached, no more frames
• Err(_) - An error occurred during decoding

Errors

Returns DecodeError if:

• Reading from the file fails
• Decoding the frame fails
• Pixel format conversion fails

Examples

use ff_decode::VideoDecoder;

let mut decoder = VideoDecoder::open("video.mp4")?.build()?;

while let Some(frame) = decoder.decode_one()? {
    println!("Frame at {:?}", frame.timestamp().as_duration());
    // Process frame...
}

pub fn decode_range( &mut self, start: Duration, end: Duration, ) -> Result<Vec<VideoFrame>, DecodeError>

Decodes all frames within a specified time range.

This method seeks to the start position and decodes all frames until the end position is reached. Frames outside the range are skipped.

Performance

• The method performs a keyframe seek to the start position
• Frames before start (from nearest keyframe) are decoded but discarded
• All frames within [start, end) are collected and returned
• The decoder position after this call will be at or past end

For large time ranges or high frame rates, this may allocate significant memory. Consider iterating manually with decode_one() for very large ranges.

Arguments

• start - Start of the time range (inclusive).
• end - End of the time range (exclusive).

Returns

A vector of frames with timestamps in the range [start, end). Frames are returned in presentation order.

Errors

Returns DecodeError if:

• Seeking to the start position fails
• Decoding frames fails
• The time range is invalid (start >= end)

Examples

use ff_decode::VideoDecoder;
use std::time::Duration;

let mut decoder = VideoDecoder::open("video.mp4")?.build()?;

// Decode frames from 5s to 10s
let frames = decoder.decode_range(
    Duration::from_secs(5),
    Duration::from_secs(10),
)?;

println!("Decoded {} frames", frames.len());
for frame in frames {
    println!("Frame at {:?}", frame.timestamp().as_duration());
}

Memory Usage

At 30fps, a 5-second range will allocate ~150 frames. For 1080p RGBA:

• Each frame: ~8.3 MB (1920 × 1080 × 4 bytes)
• 150 frames: ~1.25 GB

Consider using a frame pool to reduce allocation overhead.

pub fn seek( &mut self, position: Duration, mode: SeekMode, ) -> Result<(), DecodeError>

Seeks to a specified position in the video stream.

This method performs efficient seeking without reopening the file, providing significantly better performance than file-reopen-based seeking (5-10ms vs 50-100ms).

Performance

• Keyframe seeking: 5-10ms (typical GOP 1-2s)
• Exact seeking: 10-50ms depending on GOP size
• Backward seeking: Similar to keyframe seeking

For videos with large GOP sizes (>5 seconds), exact seeking may take longer as it requires decoding all frames from the nearest keyframe to the target.

Choosing a Seek Mode

• Use crate::SeekMode::Keyframe for:

  • Video player scrubbing (approximate positioning)
  • Thumbnail generation
  • Quick preview navigation

• Use crate::SeekMode::Exact for:

  • Frame-accurate editing
  • Precise timestamp extraction
  • Quality-critical operations

• Use crate::SeekMode::Backward for:

  • Guaranteed keyframe positioning
  • Preparing for forward playback

Arguments

• position - Target position to seek to.
• mode - Seek mode determining accuracy and performance.

Errors

Returns DecodeError::SeekFailed if:

• The target position is beyond the video duration
• The file format doesn’t support seeking
• The seek operation fails internally

Examples

use ff_decode::{VideoDecoder, SeekMode};
use std::time::Duration;

let mut decoder = VideoDecoder::open("video.mp4")?.build()?;

// Fast seek to 30 seconds (keyframe)
decoder.seek(Duration::from_secs(30), SeekMode::Keyframe)?;

// Exact seek to 1 minute
decoder.seek(Duration::from_secs(60), SeekMode::Exact)?;

// Seek and decode next frame
decoder.seek(Duration::from_secs(10), SeekMode::Keyframe)?;
if let Some(frame) = decoder.decode_one()? {
    println!("Frame at {:?}", frame.timestamp().as_duration());
}

pub fn flush(&mut self)

Flushes the decoder’s internal buffers.

This method clears any cached frames and resets the decoder state. The decoder is ready to receive new packets after flushing.

When to Use

• After seeking to ensure clean state
• Before switching between different parts of the video
• To clear buffered frames after errors

Examples

use ff_decode::VideoDecoder;

let mut decoder = VideoDecoder::open("video.mp4")?.build()?;

// Decode some frames...
for _ in 0..10 {
    decoder.decode_one()?;
}

// Flush and start fresh
decoder.flush();

Note

Calling seek() automatically flushes the decoder, so you don’t need to call this method explicitly after seeking.

pub fn thumbnail_at( &mut self, position: Duration, width: u32, height: u32, ) -> Result<Option<VideoFrame>, DecodeError>

Generates a thumbnail at a specific timestamp.

This method seeks to the specified position, decodes a frame, and scales it to the target dimensions. It’s optimized for thumbnail generation by using keyframe seeking for speed.

Performance

• Seeking: 5-10ms (keyframe mode)
• Decoding: 5-10ms for 1080p H.264
• Scaling: 1-3ms for 1080p → 320x180
• Total: ~10-25ms per thumbnail

Aspect Ratio

The thumbnail preserves the video’s aspect ratio using a “fit-within” strategy. The output dimensions will be at most the target size, with at least one dimension matching the target. No letterboxing is applied.

Arguments

• position - Timestamp to extract the thumbnail from.
• width - Target thumbnail width in pixels.
• height - Target thumbnail height in pixels.

Returns

A scaled VideoFrame representing the thumbnail.

Errors

Returns DecodeError if:

• Seeking to the position fails
• No frame can be decoded at that position (returns Ok(None))
• Scaling fails

Examples

use ff_decode::VideoDecoder;
use std::time::Duration;

let mut decoder = VideoDecoder::open("video.mp4")?.build()?;

// Generate a 320x180 thumbnail at 5 seconds
let thumbnail = decoder.thumbnail_at(
    Duration::from_secs(5),
    320,
    180,
)?;

assert_eq!(thumbnail.width(), 320);
assert_eq!(thumbnail.height(), 180);

Use Cases

• Video player scrubbing preview
• Timeline thumbnail strips
• Gallery view thumbnails
• Social media preview images

pub fn thumbnails( &mut self, count: usize, width: u32, height: u32, ) -> Result<Vec<VideoFrame>, DecodeError>

Generates multiple thumbnails evenly distributed across the video.

This method creates a series of thumbnails by dividing the video duration into equal intervals and extracting a frame at each position. This is commonly used for timeline preview strips or video galleries.

Performance

For a 2-minute video generating 10 thumbnails:

• Per thumbnail: ~10-25ms (see thumbnail_at())
• Total: ~100-250ms

Performance scales linearly with the number of thumbnails.

Thumbnail Positions

Thumbnails are extracted at evenly spaced intervals:

• Position 0: 0s
• Position 1: duration / count
• Position 2: 2 * (duration / count)
• …
• Position N-1: (N-1) * (duration / count)

Arguments

• count - Number of thumbnails to generate.
• width - Target thumbnail width in pixels.
• height - Target thumbnail height in pixels.

Returns

A vector of VideoFrame thumbnails in temporal order.

Errors

Returns DecodeError if:

• Any individual thumbnail generation fails (see thumbnail_at())
• The video duration is unknown (Duration::ZERO)
• Count is zero

Examples

use ff_decode::VideoDecoder;

let mut decoder = VideoDecoder::open("video.mp4")?.build()?;

// Generate 10 thumbnails at 160x90 resolution
let thumbnails = decoder.thumbnails(10, 160, 90)?;

assert_eq!(thumbnails.len(), 10);
for thumb in thumbnails {
    assert_eq!(thumb.width(), 160);
    assert_eq!(thumb.height(), 90);
}

Use Cases

• Timeline preview strips (like YouTube’s timeline hover)
• Video gallery grid views
• Storyboard generation for editing
• Video summary/preview pages

Memory Usage

For 10 thumbnails at 160x90 RGBA:

• Per thumbnail: ~56 KB (160 × 90 × 4 bytes)
• Total: ~560 KB

This is typically acceptable, but consider using a smaller resolution or generating thumbnails on-demand for very large thumbnail counts.

Trait Implementations

impl Iterator for VideoDecoder

type Item = Result<VideoFrame, DecodeError>

The type of the elements being iterated over.

fn next(&mut self) -> Option<Self::Item>

Advances the iterator and returns the next value.

fn next_chunk<const N: usize>( &mut self, ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>

where Self: Sized,

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

Advances the iterator and returns an array containing the next N values.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn count(self) -> usize

where Self: Sized,

Consumes the iterator, counting the number of iterations and returning it.

fn last(self) -> Option<Self::Item>

where Self: Sized,

Consumes the iterator, returning the last element.

fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

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

Advances the iterator by n elements.

fn nth(&mut self, n: usize) -> Option<Self::Item>

Returns the nth element of the iterator.

fn step_by(self, step: usize) -> StepBy<Self>

where Self: Sized,

Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both in sequence.

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator,

‘Zips up’ two iterators into a single iterator of pairs.

fn intersperse(self, separator: Self::Item) -> Intersperse<Self>

where Self: Sized, Self::Item: Clone,

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

Creates a new iterator which places a copy of separator between items of the original iterator.

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>

where Self: Sized, G: FnMut() -> Self::Item,

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

Creates a new iterator which places an item generated by separator between items of the original iterator.

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Takes a closure and creates an iterator which calls that closure on each element.

fn for_each<F>(self, f: F)

where Self: Sized, F: FnMut(Self::Item),

Calls a closure on each element of an iterator.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator which uses a closure to determine if an element should be yielded.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both filters and maps.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates an iterator which gives the current iteration count as well as the next value.

fn peekable(self) -> Peekable<Self>

where Self: Sized,

Creates an iterator which can use the peek and peek_mut methods to look at the next element of the iterator without consuming it. See their documentation for more information.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that skips elements based on a predicate.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that yields elements based on a predicate.

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>

where Self: Sized, P: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both yields elements based on a predicate and maps.

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Creates an iterator that skips the first n elements.

fn take(self, n: usize) -> Take<Self>

where Self: Sized,

Creates an iterator that yields the first n elements, or fewer if the underlying iterator ends sooner.

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>

where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,

An iterator adapter which, like fold, holds internal state, but unlike fold, produces a new iterator.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>

where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,

Creates an iterator that works like map, but flattens nested structure.

fn flatten(self) -> Flatten<Self>

where Self: Sized, Self::Item: IntoIterator,

Creates an iterator that flattens nested structure.

fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

where Self: Sized, F: FnMut(&[Self::Item; N]) -> R,

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

Calls the given function f for each contiguous window of size N over self and returns an iterator over the outputs of f. Like slice::windows(), the windows during mapping overlap as well.

fn fuse(self) -> Fuse<Self>

where Self: Sized,

Creates an iterator which ends after the first None.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where Self: Sized, F: FnMut(&Self::Item),

Does something with each element of an iterator, passing the value on.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Iterator.

fn collect<B>(self) -> B

where B: FromIterator<Self::Item>, Self: Sized,

Transforms an iterator into a collection.

fn try_collect<B>( &mut self, ) -> <<Self::Item as Try>::Residual as Residual<B>>::TryType

where Self: Sized, Self::Item: Try, <Self::Item as Try>::Residual: Residual<B>, B: FromIterator<<Self::Item as Try>::Output>,

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

Fallibly transforms an iterator into a collection, short circuiting if a failure is encountered.

fn collect_into<E>(self, collection: &mut E) -> &mut E

where E: Extend<Self::Item>, Self: Sized,

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

Collects all the items from an iterator into a collection.

fn partition<B, F>(self, f: F) -> (B, B)

where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,

Consumes an iterator, creating two collections from it.

fn is_partitioned<P>(self, predicate: P) -> bool

where Self: Sized, P: FnMut(Self::Item) -> bool,

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

Checks if the elements of this iterator are partitioned according to the given predicate, such that all those that return true precede all those that return false.

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R

where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

An iterator method that applies a function as long as it returns successfully, producing a single, final value.

fn try_for_each<F, R>(&mut self, f: F) -> R

where Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = ()>,

An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error.

fn fold<B, F>(self, init: B, f: F) -> B

where Self: Sized, F: FnMut(B, Self::Item) -> B,

Folds every element into an accumulator by applying an operation, returning the final result.

fn reduce<F>(self, f: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the elements to a single one, by repeatedly applying a reducing operation.

fn try_reduce<R>( &mut self, f: impl FnMut(Self::Item, Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType

where Self: Sized, R: Try<Output = Self::Item>, <R as Try>::Residual: Residual<Option<Self::Item>>,

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

Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately.

fn all<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if every element of the iterator matches a predicate.

fn any<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if any element of the iterator matches a predicate.

fn find<P>(&mut self, predicate: P) -> Option<Self::Item>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Searches for an element of an iterator that satisfies a predicate.

fn find_map<B, F>(&mut self, f: F) -> Option<B>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Applies function to the elements of iterator and returns the first non-none result.

fn try_find<R>( &mut self, f: impl FnMut(&Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType

where Self: Sized, R: Try<Output = bool>, <R as Try>::Residual: Residual<Option<Self::Item>>,

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

Applies function to the elements of iterator and returns the first true result or the first error.

fn position<P>(&mut self, predicate: P) -> Option<usize>

where Self: Sized, P: FnMut(Self::Item) -> bool,

Searches for an element in an iterator, returning its index.

fn max(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the maximum element of an iterator.

fn min(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the minimum element of an iterator.

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the maximum value from the specified function.

fn max_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the maximum value with respect to the specified comparison function.

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the minimum value from the specified function.

fn min_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the minimum value with respect to the specified comparison function.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)

where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Iterator<Item = (A, B)>,

Converts an iterator of pairs into a pair of containers.

fn copied<'a, T>(self) -> Copied<Self>

where T: Copy + 'a, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which copies all of its elements.

fn cloned<'a, T>(self) -> Cloned<Self>

where T: Clone + 'a, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which clones all of its elements.

fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>

where Self: Sized,

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

Returns an iterator over N elements of the iterator at a time.

fn sum<S>(self) -> S

where Self: Sized, S: Sum<Self::Item>,

Sums the elements of an iterator.

fn product<P>(self) -> P

where Self: Sized, P: Product<Self::Item>,

Iterates over the entire iterator, multiplying all the elements

fn cmp<I>(self, other: I) -> Ordering

where I: IntoIterator<Item = Self::Item>, Self::Item: Ord, Self: Sized,

Lexicographically compares the elements of this Iterator with those of another.

fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

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

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn partial_cmp<I>(self, other: I) -> Option<Ordering>

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Lexicographically compares the PartialOrd elements of this Iterator with those of another. The comparison works like short-circuit evaluation, returning a result without comparing the remaining elements. As soon as an order can be determined, the evaluation stops and a result is returned.

fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

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

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn eq<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are equal to those of another.

fn eq_by<I, F>(self, other: I, eq: F) -> bool

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

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

Determines if the elements of this Iterator are equal to those of another with respect to the specified equality function.

fn ne<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are not equal to those of another.

fn lt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less than those of another.

fn le<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less or equal to those of another.

fn gt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than those of another.

fn ge<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than or equal to those of another.

fn is_sorted(self) -> bool

where Self: Sized, Self::Item: PartialOrd,

Checks if the elements of this iterator are sorted.

fn is_sorted_by<F>(self, compare: F) -> bool

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> bool,

Checks if the elements of this iterator are sorted using the given comparator function.

fn is_sorted_by_key<F, K>(self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> K, K: PartialOrd,

Checks if the elements of this iterator are sorted using the given key extraction function.

impl FusedIterator for VideoDecoder