From e078fe05ddd908d8e016ba67b4ddd5bd9a4902f1 Mon Sep 17 00:00:00 2001 From: Josh Megnauth Date: Fri, 16 Feb 2024 03:15:23 -0500 Subject: [PATCH] Pass HW decoder choice to player --- src/config.rs | 10 +-- src/hardware.rs | 7 ++ src/{wrappers.rs => hardware/device_type.rs} | 90 +++++++------------- src/hardware/iter.rs | 58 +++++++++++++ src/main.rs | 5 +- src/player.rs | 17 ++-- 6 files changed, 115 insertions(+), 72 deletions(-) create mode 100644 src/hardware.rs rename src/{wrappers.rs => hardware/device_type.rs} (74%) create mode 100644 src/hardware/iter.rs diff --git a/src/config.rs b/src/config.rs index 77f4ad1..2337e11 100644 --- a/src/config.rs +++ b/src/config.rs @@ -8,7 +8,7 @@ use lexopt::prelude::*; use serde::{Deserialize, Serialize}; use std::{path::PathBuf, process}; -use crate::wrappers::HWDeviceType; +use crate::hardware::DeviceType; pub const CONFIG_VERSION: u64 = 1; @@ -32,14 +32,14 @@ impl AppTheme { #[derive(Clone, CosmicConfigEntry, Debug, Deserialize, Eq, PartialEq, Serialize)] pub struct Config { pub app_theme: AppTheme, - pub hw_decoder: HWDeviceType, + pub hw_decoder: DeviceType, } impl Default for Config { fn default() -> Self { Self { app_theme: AppTheme::System, - hw_decoder: HWDeviceType::default(), + hw_decoder: DeviceType::default(), } } } @@ -54,7 +54,7 @@ impl Config { pub struct Args { pub paths: Vec, - pub decoder: Option, + pub decoder: Option, } impl Args { @@ -67,7 +67,7 @@ impl Args { match arg { Long("list-hwdec") => { println!("Supported hardware decoders:"); - for hwdec in HWDeviceType::supported_devices() { + for hwdec in DeviceType::supported_devices() { println!("\t* [{}] {hwdec}", hwdec.short_name()); } process::exit(0); diff --git a/src/hardware.rs b/src/hardware.rs new file mode 100644 index 0000000..143259d --- /dev/null +++ b/src/hardware.rs @@ -0,0 +1,7 @@ +// SPDX-License-Identifier: GPL-3.0-only + +pub mod device_type; +pub mod iter; + +pub use device_type::DeviceType; +pub use iter::SupportedDeviceIter; diff --git a/src/wrappers.rs b/src/hardware/device_type.rs similarity index 74% rename from src/wrappers.rs rename to src/hardware/device_type.rs index 2bbc617..8e82c68 100644 --- a/src/wrappers.rs +++ b/src/hardware/device_type.rs @@ -1,16 +1,18 @@ // SPDX-License-Identifier: GPL-3.0-only -use std::{fmt, iter::FusedIterator, str::FromStr}; +use std::{fmt, str::FromStr}; -use ffmpeg_next::ffi::{av_hwdevice_iterate_types, AVHWDeviceType}; +use ffmpeg_next::ffi::AVHWDeviceType; use serde::{ de::{value::Error as DeError, Error as DeErrorTrait, Unexpected}, Deserialize, Serialize, }; +use super::iter::SupportedDeviceIter; + /// Delegate type for [`ffmpeg_next::ffi::AVHWDeviceType`] for configs. #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] -pub enum HWDeviceType { +pub enum DeviceType { None, /// Compute Unified Device Architecture /// Nvidia only. @@ -52,7 +54,7 @@ pub enum HWDeviceType { Vulkan, } -impl HWDeviceType { +impl DeviceType { /// Hardware device names for user facing interfaces (logging, configs). pub const fn name(self) -> &'static str { match self { @@ -97,7 +99,7 @@ impl HWDeviceType { } } -impl FromStr for HWDeviceType { +impl FromStr for DeviceType { type Err = DeError; // av_hwdevice_find_type_by_name returns None for invalid device type names, but this type @@ -125,13 +127,13 @@ impl FromStr for HWDeviceType { } } -impl fmt::Display for HWDeviceType { +impl fmt::Display for DeviceType { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", self.name()) } } -impl From for HWDeviceType { +impl From for DeviceType { fn from(value: AVHWDeviceType) -> Self { match value { AVHWDeviceType::AV_HWDEVICE_TYPE_NONE => Self::None, @@ -152,59 +154,29 @@ impl From for HWDeviceType { } } -impl Default for HWDeviceType { +impl From for AVHWDeviceType { + fn from(value: DeviceType) -> Self { + match value { + DeviceType::None => Self::AV_HWDEVICE_TYPE_NONE, + DeviceType::Cuda => Self::AV_HWDEVICE_TYPE_CUDA, + DeviceType::D3d11va => Self::AV_HWDEVICE_TYPE_D3D11VA, + // NOTE: Next FFmpeg release + DeviceType::D3d12va => Self::AV_HWDEVICE_TYPE_NONE, + DeviceType::Dxva2 => Self::AV_HWDEVICE_TYPE_DXVA2, + DeviceType::Drm => Self::AV_HWDEVICE_TYPE_DRM, + DeviceType::MediaCodec => Self::AV_HWDEVICE_TYPE_MEDIACODEC, + DeviceType::OpenCl => Self::AV_HWDEVICE_TYPE_OPENCL, + DeviceType::Qsv => Self::AV_HWDEVICE_TYPE_QSV, + DeviceType::Vaapi => Self::AV_HWDEVICE_TYPE_VAAPI, + DeviceType::Vdpau => Self::AV_HWDEVICE_TYPE_VDPAU, + DeviceType::VideoToolbox => Self::AV_HWDEVICE_TYPE_VIDEOTOOLBOX, + DeviceType::Vulkan => Self::AV_HWDEVICE_TYPE_VULKAN, + } + } +} + +impl Default for DeviceType { fn default() -> Self { Self::Vaapi } } - -/// Iterator over system's supported hardware decoders. -pub struct SupportedDeviceIter { - current: AVHWDeviceType, -} - -impl Default for SupportedDeviceIter { - fn default() -> Self { - // SAFETY: FFmpeg's documentation states that the iterator is delimited by AV_HWDEVICE_TYPE_NONE. - let current = unsafe { av_hwdevice_iterate_types(AVHWDeviceType::AV_HWDEVICE_TYPE_NONE) }; - Self { current } - } -} - -impl Iterator for SupportedDeviceIter { - type Item = HWDeviceType; - - fn next(&mut self) -> Option { - // None is a sentinel value that indicates the iterator is exhausted - if self.current == AVHWDeviceType::AV_HWDEVICE_TYPE_NONE { - None - } else { - let prev = self.current; - // SAFETY: The docs and examples state that the iterator yields the next value - // when the previous is passed in. - self.current = unsafe { av_hwdevice_iterate_types(prev) }; - - Some(prev.into()) - } - } -} - -impl FusedIterator for SupportedDeviceIter {} - -#[cfg(test)] -mod tests { - use std::hint::black_box; - - use super::*; - - // The iterator's yielded values aren't important since hardware decoders vary by system - // This is just a sanity check to ensure the iterator works - #[test] - fn supported_device_iter_doesnt_seg_fault() { - for decoder in HWDeviceType::supported_devices() { - black_box(decoder); - } - - let _decoders: Vec<_> = black_box(HWDeviceType::supported_devices().collect()); - } -} diff --git a/src/hardware/iter.rs b/src/hardware/iter.rs new file mode 100644 index 0000000..0a52f7e --- /dev/null +++ b/src/hardware/iter.rs @@ -0,0 +1,58 @@ +// SPDX-License-Identifier: GPL-3.0-only + +use std::iter::FusedIterator; + +use ffmpeg_next::ffi::{av_hwdevice_iterate_types, AVHWDeviceType}; + +use super::device_type::DeviceType; + +/// Iterator over system's supported hardware decoders. +pub struct SupportedDeviceIter { + current: AVHWDeviceType, +} + +impl Default for SupportedDeviceIter { + fn default() -> Self { + // SAFETY: FFmpeg's documentation states that the iterator is delimited by AV_HWDEVICE_TYPE_NONE. + let current = unsafe { av_hwdevice_iterate_types(AVHWDeviceType::AV_HWDEVICE_TYPE_NONE) }; + Self { current } + } +} + +impl Iterator for SupportedDeviceIter { + type Item = DeviceType; + + fn next(&mut self) -> Option { + // None is a sentinel value that indicates the iterator is exhausted + if self.current == AVHWDeviceType::AV_HWDEVICE_TYPE_NONE { + None + } else { + let prev = self.current; + // SAFETY: The docs and examples state that the iterator yields the next value + // when the previous is passed in. + self.current = unsafe { av_hwdevice_iterate_types(prev) }; + + Some(prev.into()) + } + } +} + +impl FusedIterator for SupportedDeviceIter {} + +#[cfg(test)] +mod tests { + use std::hint::black_box; + + use super::*; + + // The iterator's yielded values aren't important since hardware decoders vary by system + // This is just a sanity check to ensure the iterator works + #[test] + fn supported_device_iter_doesnt_seg_fault() { + for decoder in DeviceType::supported_devices() { + black_box(decoder); + } + + let _decoders: Vec<_> = black_box(DeviceType::supported_devices().collect()); + } +} diff --git a/src/main.rs b/src/main.rs index 68a120d..bf665ca 100644 --- a/src/main.rs +++ b/src/main.rs @@ -32,7 +32,7 @@ mod localize; use player::{PlayerMessage, VideoFrame, VideoQueue}; mod player; -mod wrappers; +mod hardware; /// Runs application with these settings #[rustfmt::skip] @@ -72,7 +72,8 @@ fn main() -> Result<(), Box> { let Args { mut paths, .. } = args; let path = paths.pop().unwrap(); - let (player_tx, video_queue_lock) = player::run(path); + // TODO: Update video player config when it's updated via the app + let (player_tx, video_queue_lock) = player::run(path, config.clone()); let mut settings = Settings::default(); settings = settings.theme(config.app_theme.theme()); diff --git a/src/player.rs b/src/player.rs index b4b2f8a..2bf1473 100644 --- a/src/player.rs +++ b/src/player.rs @@ -28,6 +28,8 @@ use std::{ time::{Duration, Instant}, }; +use crate::config::Config; + //TODO: calculate presentation time of end of queue pub struct AudioQueue { pub channels: usize, @@ -207,6 +209,7 @@ fn ffmpeg_thread>( path: P, player_rx: mpsc::Receiver, video_queue_lock: Arc>, + config: Config, ) -> Result<(), Box> { let (audio_config, cpal_stream, audio_queue_lock) = cpal(); @@ -227,21 +230,23 @@ fn ffmpeg_thread>( let mut hw_device_ctx = ptr::null_mut(); unsafe { //TODO: support other types - let hw_device_kind = ffi::AVHWDeviceType::AV_HWDEVICE_TYPE_VAAPI; + let hw_device_kind = config.hw_decoder; if ffi::av_hwdevice_ctx_create( &mut hw_device_ctx, - hw_device_kind, + hw_device_kind.into(), ptr::null(), ptr::null_mut(), 0, ) == 0 { - log::info!("using vaapi decoding"); + log::info!("using {hw_device_kind} decoding"); (&mut *video_decoder_context.as_mut_ptr()).hw_device_ctx = ffi::av_buffer_ref(hw_device_ctx); } else { //TODO: support other hardware devices - log::warn!("failed to use vaapi decoding, falling back to software decoding"); + log::warn!( + "failed to use {hw_device_kind} decoding, falling back to software decoding" + ); } } @@ -630,7 +635,7 @@ fn ffmpeg_thread>( Ok(()) } -pub fn run(path: PathBuf) -> (mpsc::Sender, Arc>) { +pub fn run(path: PathBuf, config: Config) -> (mpsc::Sender, Arc>) { ffmpeg::init().unwrap(); let (player_tx, player_rx) = mpsc::channel(); @@ -640,7 +645,7 @@ pub fn run(path: PathBuf) -> (mpsc::Sender, Arc thread::Builder::new() .name("ffmpeg".to_string()) .spawn(move || { - ffmpeg_thread(path, player_rx, video_queue_lock).unwrap(); + ffmpeg_thread(path, player_rx, video_queue_lock, config).unwrap(); }) .unwrap(); }