Enum VideoCodec 

#[non_exhaustive]
pub enum VideoCodec {
    H264,
    H265,
    Vp8,
    Vp9,
    Av1,
    ProRes,
    Mpeg4,
    Mpeg2,
    Mjpeg,
    Unknown,
}

Video codec identifier.

This enum represents common video codecs used in media files. It covers the most widely used codecs while remaining extensible via the Unknown variant.

Common Usage

• H.264/AVC: Most common codec for HD video, excellent compatibility
• H.265/HEVC: Better compression than H.264, used for 4K content
• VP9: Google’s open codec for web video streaming
• AV1: Next-gen open codec, excellent compression
• Apple ProRes: Apple’s professional editing codec

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

H264

H.264/AVC - most common video codec

H265

H.265/HEVC - successor to H.264, better compression

Vp8

VP8 - Google’s older open codec

Vp9

VP9 - Google’s open codec for web video streaming

Av1

AV1 - Alliance for Open Media codec, next-gen compression

ProRes

Apple’s professional editing codec

Mpeg4

MPEG-4 Part 2 - older codec, legacy support

Mpeg2

MPEG-2 Video - DVD and broadcast standard

Mjpeg

MJPEG - Motion JPEG, used by some cameras

Unknown

Unknown or unsupported codec

Implementations

impl VideoCodec

pub const fn name(&self) -> &'static str

Returns the codec name as a human-readable string.

Examples

use ff_format::codec::VideoCodec;

assert_eq!(VideoCodec::H264.name(), "h264");
assert_eq!(VideoCodec::H265.name(), "hevc");

pub const fn display_name(&self) -> &'static str

Returns the human-readable display name for the codec.

Examples

use ff_format::codec::VideoCodec;

assert_eq!(VideoCodec::H264.display_name(), "H.264/AVC");
assert_eq!(VideoCodec::H265.display_name(), "H.265/HEVC");

pub const fn is_h264_family(&self) -> bool

Returns true if this is part of the H.264 family.

Examples

use ff_format::codec::VideoCodec;

assert!(VideoCodec::H264.is_h264_family());
assert!(!VideoCodec::H265.is_h264_family());

pub const fn is_h265_family(&self) -> bool

Returns true if this is part of the H.265/HEVC family.

Examples

use ff_format::codec::VideoCodec;

assert!(VideoCodec::H265.is_h265_family());
assert!(!VideoCodec::H264.is_h265_family());

pub const fn is_vp_family(&self) -> bool

Returns true if this is a Google/WebM codec (VP8, VP9).

Examples

use ff_format::codec::VideoCodec;

assert!(VideoCodec::Vp8.is_vp_family());
assert!(VideoCodec::Vp9.is_vp_family());
assert!(!VideoCodec::H264.is_vp_family());

pub const fn is_professional(&self) -> bool

Returns true if this is a professional/editing codec.

Examples

use ff_format::codec::VideoCodec;

assert!(VideoCodec::ProRes.is_professional());
assert!(!VideoCodec::H264.is_professional());

pub const fn has_hardware_support(&self) -> bool

Returns true if this codec supports hardware acceleration on most platforms.

Examples

use ff_format::codec::VideoCodec;

assert!(VideoCodec::H264.has_hardware_support());
assert!(VideoCodec::H265.has_hardware_support());
assert!(!VideoCodec::ProRes.has_hardware_support());

pub const fn is_unknown(&self) -> bool

Returns true if the codec is unknown.

Examples

use ff_format::codec::VideoCodec;

assert!(VideoCodec::Unknown.is_unknown());
assert!(!VideoCodec::H264.is_unknown());

Trait Implementations

impl Clone for VideoCodec

fn clone(&self) -> VideoCodec

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for VideoCodec

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for VideoCodec

fn default() -> VideoCodec

Returns the “default value” for a type.

impl Display for VideoCodec

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Hash for VideoCodec

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for VideoCodec

fn eq(&self, other: &VideoCodec) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for VideoCodec

impl Eq for VideoCodec

impl StructuralPartialEq for VideoCodec