700 lines
23 KiB
Rust
700 lines
23 KiB
Rust
use std::any::Any;
|
|
use std::sync::atomic::AtomicU32;
|
|
use std::sync::atomic::Ordering;
|
|
use std::sync::mpsc;
|
|
use std::sync::Arc;
|
|
use std::thread::JoinHandle;
|
|
|
|
use ashpd::desktop::{
|
|
screencast::{CursorMode, Screencast, SourceType},
|
|
PersistMode,
|
|
};
|
|
|
|
pub use ashpd::Error as AshpdError;
|
|
|
|
use pipewire as pw;
|
|
use pw::spa;
|
|
|
|
use pw::properties::properties;
|
|
use pw::stream::{Stream, StreamFlags};
|
|
use pw::{context::Context, main_loop::MainLoop, Error};
|
|
use spa::buffer::DataType;
|
|
use spa::buffer::MetaData;
|
|
use spa::buffer::MetaType;
|
|
use spa::param::video::VideoFormat;
|
|
use spa::param::video::VideoInfoRaw;
|
|
use spa::param::ParamType;
|
|
use spa::pod::serialize::GenError;
|
|
use spa::pod::ChoiceValue;
|
|
use spa::pod::Pod;
|
|
use spa::pod::{Object, Property, PropertyFlags, Value};
|
|
use spa::utils::Choice;
|
|
use spa::utils::ChoiceEnum;
|
|
use spa::utils::ChoiceFlags;
|
|
|
|
use crate::frame::DrmFormat;
|
|
use crate::frame::FourCC;
|
|
use crate::frame::FrameFormat;
|
|
use crate::frame::MouseMeta;
|
|
use crate::frame::Transform;
|
|
use crate::frame::WlxFrame;
|
|
use crate::frame::DRM_FORMAT_ABGR2101010;
|
|
use crate::frame::DRM_FORMAT_ABGR8888;
|
|
use crate::frame::DRM_FORMAT_ARGB8888;
|
|
use crate::frame::DRM_FORMAT_XBGR2101010;
|
|
use crate::frame::DRM_FORMAT_XBGR8888;
|
|
use crate::frame::DRM_FORMAT_XRGB8888;
|
|
use crate::frame::{DmabufFrame, FramePlane, MemFdFrame, MemPtrFrame};
|
|
use crate::WlxCapture;
|
|
|
|
pub struct PipewireStream {
|
|
pub node_id: u32,
|
|
pub position: Option<(i32, i32)>,
|
|
pub size: Option<(i32, i32)>,
|
|
}
|
|
|
|
pub struct PipewireSelectScreenResult {
|
|
pub streams: Vec<PipewireStream>,
|
|
pub restore_token: Option<String>,
|
|
}
|
|
|
|
pub async fn pipewire_select_screen(
|
|
token: Option<&str>,
|
|
embed_mouse: bool,
|
|
screens_only: bool,
|
|
persist: bool,
|
|
multiple: bool,
|
|
) -> Result<PipewireSelectScreenResult, AshpdError> {
|
|
static CURSOR_MODES: AtomicU32 = AtomicU32::new(0);
|
|
|
|
let proxy = Screencast::new().await?;
|
|
let session = proxy.create_session().await?;
|
|
|
|
let mut cursor_modes = CURSOR_MODES.load(Ordering::Relaxed);
|
|
if cursor_modes == 0 {
|
|
cursor_modes = proxy.get_property::<u32>("AvailableCursorModes").await?;
|
|
|
|
log::debug!("Available cursor modes: {cursor_modes:#x}");
|
|
|
|
// propery will be same system-wide, so race condition not a concern
|
|
CURSOR_MODES.store(cursor_modes, Ordering::Relaxed);
|
|
}
|
|
|
|
let cursor_mode = match embed_mouse {
|
|
true if cursor_modes & (CursorMode::Embedded as u32) != 0 => CursorMode::Embedded,
|
|
_ if cursor_modes & (CursorMode::Metadata as u32) != 0 => CursorMode::Metadata,
|
|
_ => CursorMode::Hidden,
|
|
};
|
|
|
|
log::debug!("Selected cursor mode: {cursor_mode:?}");
|
|
|
|
let source_type = if screens_only {
|
|
SourceType::Monitor.into()
|
|
} else {
|
|
SourceType::Monitor | SourceType::Window | SourceType::Virtual
|
|
};
|
|
|
|
let persist_mode = if persist {
|
|
PersistMode::ExplicitlyRevoked
|
|
} else {
|
|
PersistMode::DoNot
|
|
};
|
|
|
|
proxy
|
|
.select_sources(
|
|
&session,
|
|
cursor_mode,
|
|
source_type,
|
|
multiple,
|
|
token,
|
|
persist_mode,
|
|
)
|
|
.await?;
|
|
|
|
let response = proxy.start(&session, None).await?.response()?;
|
|
|
|
let streams: Vec<_> = response
|
|
.streams()
|
|
.iter()
|
|
.map(|stream| PipewireStream {
|
|
node_id: stream.pipe_wire_node_id(),
|
|
position: stream.position(),
|
|
size: stream.size(),
|
|
})
|
|
.collect();
|
|
if !streams.is_empty() {
|
|
return Ok(PipewireSelectScreenResult {
|
|
streams,
|
|
restore_token: response.restore_token().map(String::from),
|
|
});
|
|
}
|
|
|
|
Err(ashpd::Error::NoResponse)
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct StreamData {
|
|
format: Option<FrameFormat>,
|
|
stream: Option<Stream>,
|
|
}
|
|
|
|
pub enum PwChangeRequest {
|
|
Pause,
|
|
Resume,
|
|
Stop,
|
|
}
|
|
|
|
struct CaptureData<R>
|
|
where
|
|
R: Any + Send,
|
|
{
|
|
tx_ctrl: pw::channel::Sender<PwChangeRequest>,
|
|
rx_frame: mpsc::Receiver<R>,
|
|
}
|
|
|
|
pub struct PipewireCapture<R>
|
|
where
|
|
R: Any + Send,
|
|
{
|
|
name: Arc<str>,
|
|
data: Option<CaptureData<R>>,
|
|
node_id: u32,
|
|
handle: Option<JoinHandle<Result<(), Error>>>,
|
|
}
|
|
|
|
impl<R> PipewireCapture<R>
|
|
where
|
|
R: Any + Send,
|
|
{
|
|
pub fn new(name: Arc<str>, node_id: u32) -> Self {
|
|
PipewireCapture {
|
|
name,
|
|
data: None,
|
|
node_id,
|
|
handle: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<R> Drop for PipewireCapture<R>
|
|
where
|
|
R: Any + Send,
|
|
{
|
|
fn drop(&mut self) {
|
|
if let Some(data) = &self.data {
|
|
let _ = data.tx_ctrl.send(PwChangeRequest::Stop);
|
|
}
|
|
if let Some(handle) = self.handle.take() {
|
|
let _ = handle.join();
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<U, R> WlxCapture<U, R> for PipewireCapture<R>
|
|
where
|
|
U: Any + Send,
|
|
R: Any + Send,
|
|
{
|
|
fn init(
|
|
&mut self,
|
|
dmabuf_formats: &[DrmFormat],
|
|
user_data: U,
|
|
receive_callback: fn(&U, WlxFrame) -> Option<R>,
|
|
) {
|
|
let (tx_frame, rx_frame) = mpsc::sync_channel(2);
|
|
let (tx_ctrl, rx_ctrl) = pw::channel::channel();
|
|
|
|
self.data = Some(CaptureData { tx_ctrl, rx_frame });
|
|
|
|
self.handle = Some(std::thread::spawn({
|
|
let name = self.name.clone();
|
|
let node_id = self.node_id;
|
|
let formats = dmabuf_formats.to_vec();
|
|
|
|
move || {
|
|
main_loop::<U, R>(
|
|
name,
|
|
node_id,
|
|
formats,
|
|
tx_frame,
|
|
rx_ctrl,
|
|
user_data,
|
|
receive_callback,
|
|
)
|
|
}
|
|
}));
|
|
}
|
|
fn is_ready(&self) -> bool {
|
|
self.data.is_some()
|
|
}
|
|
fn supports_dmbuf(&self) -> bool {
|
|
true
|
|
}
|
|
fn receive(&mut self) -> Option<R> {
|
|
if let Some(data) = self.data.as_ref() {
|
|
return data.rx_frame.try_iter().last();
|
|
}
|
|
None
|
|
}
|
|
fn pause(&mut self) {
|
|
if let Some(data) = &self.data {
|
|
match data.tx_ctrl.send(PwChangeRequest::Pause) {
|
|
Ok(_) => (),
|
|
Err(_) => {
|
|
log::warn!("{}: disconnected, stopping stream", &self.name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
fn resume(&mut self) {
|
|
if let Some(data) = &self.data {
|
|
match data.tx_ctrl.send(PwChangeRequest::Resume) {
|
|
Ok(_) => {
|
|
log::debug!(
|
|
"{}: dropped {} old frames before resuming",
|
|
&self.name,
|
|
data.rx_frame.try_iter().count()
|
|
);
|
|
}
|
|
Err(_) => {
|
|
log::warn!("{}: disconnected, stopping stream", &self.name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
fn request_new_frame(&mut self) {}
|
|
}
|
|
|
|
fn main_loop<U, R>(
|
|
name: Arc<str>,
|
|
node_id: u32,
|
|
dmabuf_formats: Vec<DrmFormat>,
|
|
sender: mpsc::SyncSender<R>,
|
|
receiver: pw::channel::Receiver<PwChangeRequest>,
|
|
user_data: U,
|
|
receive_callback: fn(&U, WlxFrame) -> Option<R>,
|
|
) -> Result<(), Error>
|
|
where
|
|
U: Any,
|
|
R: Any,
|
|
{
|
|
let main_loop = MainLoop::new(None)?;
|
|
let context = Context::new(&main_loop)?;
|
|
let core = context.connect(None)?;
|
|
|
|
let stream = Stream::new(
|
|
&core,
|
|
&name,
|
|
properties! {
|
|
*pw::keys::MEDIA_TYPE => "Video",
|
|
*pw::keys::MEDIA_CATEGORY => "Capture",
|
|
*pw::keys::MEDIA_ROLE => "Screen",
|
|
},
|
|
)?;
|
|
|
|
let _listener = stream
|
|
.add_local_listener_with_user_data(FrameFormat::default())
|
|
.state_changed({
|
|
let name = name.clone();
|
|
move |_, _, old, new| {
|
|
log::info!("{}: stream state changed: {:?} -> {:?}", &name, old, new);
|
|
}
|
|
})
|
|
.param_changed({
|
|
let name = name.clone();
|
|
move |stream, format, id, param| {
|
|
let Some(param) = param else {
|
|
return;
|
|
};
|
|
if id != ParamType::Format.as_raw() {
|
|
return;
|
|
}
|
|
|
|
let mut info = VideoInfoRaw::default();
|
|
info.parse(param)
|
|
.expect("Failed to parse param changed to VideoInfoRaw");
|
|
|
|
format.width = info.size().width;
|
|
format.height = info.size().height;
|
|
format.fourcc = spa_to_fourcc(info.format());
|
|
format.modifier = info.modifier();
|
|
|
|
let kind = if format.modifier != 0 {
|
|
"DMA-buf"
|
|
} else {
|
|
"SHM"
|
|
};
|
|
|
|
log::info!("{}: got {} video format:", &name, &kind);
|
|
log::info!(" format: {} ({:?})", info.format().as_raw(), info.format());
|
|
log::info!(" size: {}x{}", info.size().width, info.size().height);
|
|
log::info!(" modifier: {}", info.modifier());
|
|
let Ok(params_bytes) = obj_to_bytes(get_buffer_params()) else {
|
|
log::warn!("{}: failed to serialize buffer params", &name);
|
|
return;
|
|
};
|
|
let Some(params_pod) = Pod::from_bytes(¶ms_bytes) else {
|
|
log::warn!("{}: failed to deserialize buffer params", &name);
|
|
return;
|
|
};
|
|
|
|
let header_bytes = obj_to_bytes(get_meta_object(
|
|
spa::sys::SPA_META_Header,
|
|
std::mem::size_of::<spa::sys::spa_meta_header>(),
|
|
))
|
|
.unwrap(); // want panic
|
|
let header_pod = Pod::from_bytes(&header_bytes).unwrap(); // want panic
|
|
|
|
let xform_bytes = obj_to_bytes(get_meta_object(
|
|
spa::sys::SPA_META_VideoTransform,
|
|
std::mem::size_of::<spa::sys::spa_meta_videotransform>(),
|
|
))
|
|
.unwrap(); // want panic
|
|
let xform_pod = Pod::from_bytes(&xform_bytes).unwrap(); // want panic
|
|
|
|
let mut pods = [params_pod, header_pod, xform_pod];
|
|
if let Err(e) = stream.update_params(&mut pods) {
|
|
log::error!("{}: failed to update params: {}", &name, e);
|
|
}
|
|
}
|
|
})
|
|
.process({
|
|
let name = name.clone();
|
|
let u = user_data;
|
|
move |stream, format| {
|
|
let mut maybe_buffer = None;
|
|
// discard all but the newest frame
|
|
while let Some(buffer) = stream.dequeue_buffer() {
|
|
maybe_buffer = Some(buffer);
|
|
}
|
|
|
|
if let Some(mut buffer) = maybe_buffer {
|
|
if let MetaData::Header(header) = buffer.find_meta_data(MetaType::Header) {
|
|
if header.flags & spa::sys::SPA_META_HEADER_FLAG_CORRUPTED != 0 {
|
|
log::warn!("{}: PipeWire buffer is corrupt.", &name);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if let MetaData::VideoTransform(transform) =
|
|
buffer.find_meta_data(MetaType::VideoTransform)
|
|
{
|
|
format.transform = match transform.transform {
|
|
spa::sys::SPA_META_TRANSFORMATION_None => Transform::Normal,
|
|
spa::sys::SPA_META_TRANSFORMATION_90 => Transform::Rotated90,
|
|
spa::sys::SPA_META_TRANSFORMATION_180 => Transform::Rotated180,
|
|
spa::sys::SPA_META_TRANSFORMATION_270 => Transform::Rotated270,
|
|
spa::sys::SPA_META_TRANSFORMATION_Flipped => Transform::Flipped,
|
|
spa::sys::SPA_META_TRANSFORMATION_Flipped90 => Transform::Flipped90,
|
|
spa::sys::SPA_META_TRANSFORMATION_Flipped180 => Transform::Flipped180,
|
|
spa::sys::SPA_META_TRANSFORMATION_Flipped270 => Transform::Flipped270,
|
|
_ => Transform::Undefined,
|
|
};
|
|
log::debug!("{}: Transform: {:?}", &name, &format.transform);
|
|
}
|
|
|
|
let mouse_meta = match buffer.find_meta_data(MetaType::Cursor) {
|
|
MetaData::Cursor(cursor) if cursor.id != 0 => Some(MouseMeta {
|
|
x: cursor.position.x as f32 / format.width as f32,
|
|
y: cursor.position.y as f32 / format.height as f32,
|
|
}),
|
|
_ => None,
|
|
};
|
|
|
|
let datas = buffer.datas_mut();
|
|
if datas.is_empty() {
|
|
log::debug!("{}: no data", &name);
|
|
return;
|
|
}
|
|
|
|
let planes: Vec<FramePlane> = datas
|
|
.iter()
|
|
.map(|p| FramePlane {
|
|
fd: Some(p.as_raw().fd as _),
|
|
offset: p.chunk().offset(),
|
|
stride: p.chunk().stride(),
|
|
})
|
|
.collect();
|
|
|
|
match datas[0].type_() {
|
|
DataType::DmaBuf => {
|
|
let mut dmabuf = DmabufFrame {
|
|
format: *format,
|
|
num_planes: planes.len(),
|
|
mouse: mouse_meta,
|
|
..Default::default()
|
|
};
|
|
dmabuf.planes[..planes.len()].copy_from_slice(&planes[..planes.len()]);
|
|
|
|
let frame = WlxFrame::Dmabuf(dmabuf);
|
|
|
|
if let Some(r) = receive_callback(&u, frame) {
|
|
match sender.try_send(r) {
|
|
Ok(_) => (),
|
|
Err(mpsc::TrySendError::Full(_)) => (),
|
|
Err(mpsc::TrySendError::Disconnected(_)) => {
|
|
log::warn!("{}: disconnected, stopping stream", &name);
|
|
let _ = stream.disconnect();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
DataType::MemFd => {
|
|
let memfd = MemFdFrame {
|
|
format: *format,
|
|
plane: FramePlane {
|
|
fd: Some(datas[0].as_raw().fd as _),
|
|
offset: datas[0].chunk().offset(),
|
|
stride: datas[0].chunk().stride(),
|
|
},
|
|
mouse: mouse_meta,
|
|
};
|
|
|
|
let frame = WlxFrame::MemFd(memfd);
|
|
if let Some(r) = receive_callback(&u, frame) {
|
|
match sender.try_send(r) {
|
|
Ok(_) => (),
|
|
Err(mpsc::TrySendError::Full(_)) => (),
|
|
Err(mpsc::TrySendError::Disconnected(_)) => {
|
|
log::warn!("{}: disconnected, stopping stream", &name);
|
|
let _ = stream.disconnect();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
DataType::MemPtr => {
|
|
let memptr = MemPtrFrame {
|
|
format: *format,
|
|
ptr: datas[0].as_raw().data as _,
|
|
size: datas[0].chunk().size() as _,
|
|
mouse: mouse_meta,
|
|
};
|
|
|
|
let frame = WlxFrame::MemPtr(memptr);
|
|
if let Some(r) = receive_callback(&u, frame) {
|
|
match sender.try_send(r) {
|
|
Ok(_) => (),
|
|
Err(mpsc::TrySendError::Full(_)) => (),
|
|
Err(mpsc::TrySendError::Disconnected(_)) => {
|
|
log::warn!("{}: disconnected, stopping stream", &name);
|
|
let _ = stream.disconnect();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_ => {
|
|
log::error!("Received invalid frame data type ({:?})", datas[0].type_())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
})
|
|
.register()?;
|
|
|
|
let mut format_params: Vec<Vec<u8>> = dmabuf_formats
|
|
.iter()
|
|
.filter_map(|f| obj_to_bytes(get_format_params(Some(f))).ok())
|
|
.collect();
|
|
|
|
format_params.push(obj_to_bytes(get_format_params(None)).unwrap()); // safe unwrap: known
|
|
// good values
|
|
|
|
let mut params: Vec<&Pod> = format_params
|
|
.iter()
|
|
.filter_map(|bytes| Pod::from_bytes(bytes))
|
|
.collect();
|
|
|
|
stream.connect(
|
|
spa::utils::Direction::Input,
|
|
Some(node_id),
|
|
StreamFlags::AUTOCONNECT | StreamFlags::MAP_BUFFERS,
|
|
params.as_mut_slice(),
|
|
)?;
|
|
|
|
let _receiver = receiver.attach(main_loop.loop_(), {
|
|
let name = name.clone();
|
|
let main_loop = main_loop.clone();
|
|
move |req| match req {
|
|
PwChangeRequest::Pause => {
|
|
let _ = stream.set_active(false);
|
|
}
|
|
PwChangeRequest::Resume => {
|
|
let _ = stream.set_active(true);
|
|
}
|
|
PwChangeRequest::Stop => {
|
|
main_loop.quit();
|
|
log::info!("{}: stopping pipewire loop", &name);
|
|
}
|
|
}
|
|
});
|
|
|
|
main_loop.run();
|
|
log::info!("{}: pipewire loop exited", &name);
|
|
Ok::<(), Error>(())
|
|
}
|
|
|
|
fn obj_to_bytes(obj: spa::pod::Object) -> Result<Vec<u8>, GenError> {
|
|
Ok(spa::pod::serialize::PodSerializer::serialize(
|
|
std::io::Cursor::new(Vec::new()),
|
|
&spa::pod::Value::Object(obj),
|
|
)?
|
|
.0
|
|
.into_inner())
|
|
}
|
|
|
|
fn get_buffer_params() -> Object {
|
|
let data_types = (1 << DataType::MemFd.as_raw())
|
|
| (1 << DataType::MemPtr.as_raw())
|
|
| (1 << DataType::DmaBuf.as_raw());
|
|
|
|
let property = Property {
|
|
key: spa::sys::SPA_PARAM_BUFFERS_dataType,
|
|
flags: PropertyFlags::empty(),
|
|
value: Value::Int(data_types),
|
|
};
|
|
|
|
spa::pod::object!(
|
|
spa::utils::SpaTypes::ObjectParamBuffers,
|
|
spa::param::ParamType::Buffers,
|
|
property,
|
|
)
|
|
}
|
|
|
|
fn get_meta_object(key: u32, size: usize) -> Object {
|
|
let meta_type_property = Property {
|
|
key: spa::sys::SPA_PARAM_META_type,
|
|
flags: PropertyFlags::empty(),
|
|
value: Value::Id(spa::utils::Id(key)),
|
|
};
|
|
|
|
let meta_size_property = Property {
|
|
key: spa::sys::SPA_PARAM_META_size,
|
|
flags: PropertyFlags::empty(),
|
|
value: Value::Int(size as i32),
|
|
};
|
|
|
|
spa::pod::object!(
|
|
spa::utils::SpaTypes::ObjectParamMeta,
|
|
spa::param::ParamType::Meta,
|
|
meta_type_property,
|
|
meta_size_property,
|
|
)
|
|
}
|
|
|
|
fn get_format_params(fmt: Option<&DrmFormat>) -> Object {
|
|
let mut obj = spa::pod::object!(
|
|
spa::utils::SpaTypes::ObjectParamFormat,
|
|
spa::param::ParamType::EnumFormat,
|
|
spa::pod::property!(
|
|
spa::param::format::FormatProperties::MediaType,
|
|
Id,
|
|
spa::param::format::MediaType::Video
|
|
),
|
|
spa::pod::property!(
|
|
spa::param::format::FormatProperties::MediaSubtype,
|
|
Id,
|
|
spa::param::format::MediaSubtype::Raw
|
|
),
|
|
spa::pod::property!(
|
|
spa::param::format::FormatProperties::VideoSize,
|
|
Choice,
|
|
Range,
|
|
Rectangle,
|
|
spa::utils::Rectangle {
|
|
width: 256,
|
|
height: 256,
|
|
},
|
|
spa::utils::Rectangle {
|
|
width: 1,
|
|
height: 1,
|
|
},
|
|
spa::utils::Rectangle {
|
|
width: 8192,
|
|
height: 8192,
|
|
}
|
|
),
|
|
spa::pod::property!(
|
|
spa::param::format::FormatProperties::VideoFramerate,
|
|
Choice,
|
|
Range,
|
|
Fraction,
|
|
spa::utils::Fraction { num: 0, denom: 1 },
|
|
spa::utils::Fraction { num: 0, denom: 1 },
|
|
spa::utils::Fraction {
|
|
num: 1000,
|
|
denom: 1
|
|
}
|
|
),
|
|
);
|
|
|
|
if let Some(fmt) = fmt {
|
|
let spa_fmt = fourcc_to_spa(fmt.fourcc);
|
|
|
|
let prop = spa::pod::property!(
|
|
spa::param::format::FormatProperties::VideoFormat,
|
|
Choice,
|
|
Enum,
|
|
Id,
|
|
spa_fmt,
|
|
spa_fmt,
|
|
);
|
|
obj.properties.push(prop);
|
|
|
|
// TODO rewrite when property macro supports Long
|
|
let prop = Property {
|
|
key: spa::param::format::FormatProperties::VideoModifier.as_raw(),
|
|
flags: PropertyFlags::MANDATORY | PropertyFlags::DONT_FIXATE,
|
|
value: Value::Choice(ChoiceValue::Long(Choice(
|
|
ChoiceFlags::empty(),
|
|
ChoiceEnum::Enum {
|
|
default: fmt.modifiers[0] as _,
|
|
alternatives: fmt.modifiers.iter().map(|m| *m as _).collect(),
|
|
},
|
|
))),
|
|
};
|
|
obj.properties.push(prop);
|
|
} else {
|
|
let prop = spa::pod::property!(
|
|
spa::param::format::FormatProperties::VideoFormat,
|
|
Choice,
|
|
Enum,
|
|
Id,
|
|
spa::param::video::VideoFormat::RGBA,
|
|
spa::param::video::VideoFormat::RGBA,
|
|
spa::param::video::VideoFormat::BGRA,
|
|
spa::param::video::VideoFormat::RGBx,
|
|
spa::param::video::VideoFormat::BGRx,
|
|
spa::param::video::VideoFormat::ABGR_210LE,
|
|
spa::param::video::VideoFormat::xBGR_210LE,
|
|
);
|
|
obj.properties.push(prop);
|
|
}
|
|
|
|
obj
|
|
}
|
|
|
|
fn fourcc_to_spa(fourcc: FourCC) -> VideoFormat {
|
|
match fourcc.value {
|
|
DRM_FORMAT_ARGB8888 => VideoFormat::BGRA,
|
|
DRM_FORMAT_ABGR8888 => VideoFormat::RGBA,
|
|
DRM_FORMAT_XRGB8888 => VideoFormat::BGRx,
|
|
DRM_FORMAT_XBGR8888 => VideoFormat::RGBx,
|
|
DRM_FORMAT_ABGR2101010 => VideoFormat::ABGR_210LE,
|
|
DRM_FORMAT_XBGR2101010 => VideoFormat::xBGR_210LE,
|
|
_ => panic!("Unsupported format"),
|
|
}
|
|
}
|
|
|
|
#[allow(non_upper_case_globals)]
|
|
fn spa_to_fourcc(spa: VideoFormat) -> FourCC {
|
|
match spa {
|
|
VideoFormat::BGRA => DRM_FORMAT_ARGB8888.into(),
|
|
VideoFormat::RGBA => DRM_FORMAT_ABGR8888.into(),
|
|
VideoFormat::BGRx => DRM_FORMAT_XRGB8888.into(),
|
|
VideoFormat::RGBx => DRM_FORMAT_XBGR8888.into(),
|
|
VideoFormat::ABGR_210LE => DRM_FORMAT_ABGR2101010.into(),
|
|
VideoFormat::xBGR_210LE => DRM_FORMAT_XBGR2101010.into(),
|
|
_ => panic!("Unsupported format"),
|
|
}
|
|
}
|