fuchsia_framebuffer/
sysmem.rs

1// Copyright 2019 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::FrameUsage;
6use anyhow::{format_err, Context, Error};
7use fidl::endpoints::{create_endpoints, ClientEnd, Proxy};
8use fidl_fuchsia_images2::{ColorSpace, PixelFormat, PixelFormatModifier};
9use fidl_fuchsia_sysmem2::{
10    AllocatorAllocateSharedCollectionRequest, AllocatorBindSharedCollectionRequest,
11    AllocatorMarker, AllocatorProxy, AllocatorSetDebugClientInfoRequest,
12    BufferCollectionConstraints, BufferCollectionInfo, BufferCollectionMarker,
13    BufferCollectionProxy, BufferCollectionSetConstraintsRequest,
14    BufferCollectionTokenDuplicateRequest, BufferCollectionTokenMarker, BufferCollectionTokenProxy,
15    BufferMemoryConstraints, BufferUsage, ImageFormatConstraints, NodeSetNameRequest,
16    CPU_USAGE_READ_OFTEN, CPU_USAGE_WRITE_OFTEN, NONE_USAGE,
17};
18use fuchsia_component::client::connect_to_protocol;
19use std::cmp;
20use zx::AsHandleRef;
21
22fn linear_image_format_constraints(
23    width: u32,
24    height: u32,
25    pixel_type: PixelFormat,
26) -> ImageFormatConstraints {
27    ImageFormatConstraints {
28        pixel_format: Some(pixel_type),
29        pixel_format_modifier: Some(PixelFormatModifier::Linear),
30        color_spaces: Some(vec![ColorSpace::Srgb]),
31        required_min_size: Some(fidl_fuchsia_math::SizeU { width, height }),
32        required_max_size: Some(fidl_fuchsia_math::SizeU { width, height }),
33        ..Default::default()
34    }
35}
36
37fn buffer_memory_constraints(width: u32, height: u32) -> BufferMemoryConstraints {
38    BufferMemoryConstraints {
39        min_size_bytes: Some(width as u64 * height as u64 * 4u64),
40        physically_contiguous_required: Some(false),
41        secure_required: Some(false),
42        ram_domain_supported: Some(true),
43        cpu_domain_supported: Some(true),
44        inaccessible_domain_supported: Some(false),
45        ..Default::default()
46    }
47}
48
49fn buffer_collection_constraints(
50    width: u32,
51    height: u32,
52    pixel_format: PixelFormat,
53    buffer_count: u32,
54    frame_usage: FrameUsage,
55) -> BufferCollectionConstraints {
56    let (usage, has_buffer_memory_constraints, has_image_format_constraints) = match frame_usage {
57        FrameUsage::Cpu => (
58            BufferUsage {
59                cpu: Some(CPU_USAGE_WRITE_OFTEN | CPU_USAGE_READ_OFTEN),
60                ..Default::default()
61            },
62            true,
63            true,
64        ),
65        FrameUsage::Gpu => {
66            (BufferUsage { none: Some(NONE_USAGE), ..Default::default() }, false, false)
67        }
68    };
69    BufferCollectionConstraints {
70        usage: Some(usage),
71        min_buffer_count: Some(buffer_count),
72        buffer_memory_constraints: if has_buffer_memory_constraints {
73            Some(buffer_memory_constraints(width, height))
74        } else {
75            None
76        },
77        image_format_constraints: if has_image_format_constraints {
78            Some(vec![linear_image_format_constraints(width, height, pixel_format)])
79        } else {
80            None
81        },
82        ..Default::default()
83    }
84}
85
86// See ImageFormatStrideBytesPerWidthPixel
87fn stride_bytes_per_width_pixel(pixel_type: PixelFormat) -> Result<u32, Error> {
88    match pixel_type {
89        PixelFormat::R8G8B8A8 => Ok(4),
90        PixelFormat::B8G8R8A8 => Ok(4),
91        PixelFormat::B8G8R8 => Ok(3),
92        PixelFormat::I420 => Ok(1),
93        PixelFormat::M420 => Ok(1),
94        PixelFormat::Nv12 => Ok(1),
95        PixelFormat::Yuy2 => Ok(2),
96        PixelFormat::Yv12 => Ok(1),
97        PixelFormat::R5G6B5 => Ok(2),
98        PixelFormat::R3G3B2 => Ok(1),
99        PixelFormat::R2G2B2X2 => Ok(1),
100        PixelFormat::L8 => Ok(1),
101        _ => return Err(format_err!("Unsupported format")),
102    }
103}
104
105fn round_up_to_align(x: u32, align: u32) -> u32 {
106    if align == 0 {
107        x
108    } else {
109        ((x + align - 1) / align) * align
110    }
111}
112
113// See ImageFormatMinimumRowBytes
114pub fn minimum_row_bytes(constraints: &ImageFormatConstraints, width: u32) -> Result<u32, Error> {
115    if width < constraints.min_size.ok_or("missing min_size").unwrap().width
116        || width > constraints.max_size.ok_or("missing max_size").unwrap().width
117    {
118        return Err(format_err!("Invalid width for constraints"));
119    }
120
121    let bytes_per_pixel = stride_bytes_per_width_pixel(
122        constraints.pixel_format.ok_or("missing pixel_format").unwrap(),
123    )?;
124    Ok(round_up_to_align(
125        cmp::max(
126            bytes_per_pixel * width,
127            constraints.min_bytes_per_row.ok_or("missing min_bytes_per_row").unwrap(),
128        ),
129        constraints.bytes_per_row_divisor.ok_or("missing bytes_per_row_divisor").unwrap(),
130    ))
131}
132
133pub struct BufferCollectionAllocator {
134    token: Option<BufferCollectionTokenProxy>,
135    width: u32,
136    height: u32,
137    pixel_format: PixelFormat,
138    usage: FrameUsage,
139    buffer_count: usize,
140    sysmem: AllocatorProxy,
141    collection_client: Option<BufferCollectionProxy>,
142}
143
144pub fn set_allocator_name(sysmem_client: &AllocatorProxy) -> Result<(), Error> {
145    Ok(sysmem_client.set_debug_client_info(&AllocatorSetDebugClientInfoRequest {
146        name: Some(fuchsia_runtime::process_self().get_name()?.to_string()),
147        id: Some(fuchsia_runtime::process_self().get_koid()?.raw_koid()),
148        ..Default::default()
149    })?)
150}
151
152impl BufferCollectionAllocator {
153    pub fn new(
154        width: u32,
155        height: u32,
156        pixel_format: PixelFormat,
157        usage: FrameUsage,
158        buffer_count: usize,
159    ) -> Result<BufferCollectionAllocator, Error> {
160        let sysmem = connect_to_protocol::<AllocatorMarker>()?;
161
162        let _ = set_allocator_name(&sysmem);
163
164        let (local_token, local_token_request) = create_endpoints::<BufferCollectionTokenMarker>();
165
166        sysmem.allocate_shared_collection(AllocatorAllocateSharedCollectionRequest {
167            token_request: Some(local_token_request),
168            ..Default::default()
169        })?;
170
171        Ok(BufferCollectionAllocator {
172            token: Some(local_token.into_proxy()),
173            width,
174            height,
175            pixel_format,
176            usage,
177            buffer_count,
178            sysmem,
179            collection_client: None,
180        })
181    }
182
183    pub fn set_name(&mut self, priority: u32, name: &str) -> Result<(), Error> {
184        Ok(self.token.as_ref().expect("token in set_name").set_name(&NodeSetNameRequest {
185            priority: Some(priority),
186            name: Some(name.into()),
187            ..Default::default()
188        })?)
189    }
190
191    pub fn set_pixel_type(&mut self, pixel_format: PixelFormat) {
192        self.pixel_format = pixel_format;
193    }
194
195    pub async fn allocate_buffers(
196        &mut self,
197        set_constraints: bool,
198    ) -> Result<BufferCollectionInfo, Error> {
199        let token = self.token.take().expect("token in allocate_buffers");
200        let (collection_client, collection_request) = create_endpoints::<BufferCollectionMarker>();
201        self.sysmem.bind_shared_collection(AllocatorBindSharedCollectionRequest {
202            token: Some(token.into_client_end().unwrap()),
203            buffer_collection_request: Some(collection_request),
204            ..Default::default()
205        })?;
206        let collection_client = collection_client.into_proxy();
207        self.allocate_buffers_proxy(collection_client, set_constraints).await
208    }
209
210    async fn allocate_buffers_proxy(
211        &mut self,
212        collection_client: BufferCollectionProxy,
213        set_constraints: bool,
214    ) -> Result<BufferCollectionInfo, Error> {
215        let buffer_collection_constraints = buffer_collection_constraints(
216            self.width,
217            self.height,
218            self.pixel_format,
219            self.buffer_count as u32,
220            self.usage,
221        );
222        collection_client
223            .set_constraints(BufferCollectionSetConstraintsRequest {
224                constraints: if set_constraints {
225                    Some(buffer_collection_constraints)
226                } else {
227                    None
228                },
229                ..Default::default()
230            })
231            .context("Sending buffer constraints to sysmem")?;
232        let wait_result = collection_client.wait_for_all_buffers_allocated().await;
233        self.collection_client = Some(collection_client);
234        if wait_result.is_err() {
235            let error: fidl::Error = wait_result.unwrap_err();
236            return Err(format_err!("Failed to wait for buffers {}", error));
237        }
238        if wait_result.as_ref().unwrap().is_err() {
239            let error: fidl_fuchsia_sysmem2::Error = wait_result.unwrap().unwrap_err();
240            return Err(format_err!("Wait for buffers failed {:?}", error));
241        }
242        let buffers = wait_result.unwrap().unwrap().buffer_collection_info.unwrap();
243        Ok(buffers)
244    }
245
246    pub async fn duplicate_token(
247        &mut self,
248    ) -> Result<ClientEnd<BufferCollectionTokenMarker>, Error> {
249        let (requested_token, requested_token_request) =
250            create_endpoints::<BufferCollectionTokenMarker>();
251
252        self.token.as_ref().expect("token in duplicate_token[duplicate]").duplicate(
253            BufferCollectionTokenDuplicateRequest {
254                rights_attenuation_mask: Some(fidl::Rights::SAME_RIGHTS),
255                token_request: Some(requested_token_request),
256                ..Default::default()
257            },
258        )?;
259        self.token.as_ref().expect("token in duplicate_token_2[sync]").sync().await?;
260        Ok(requested_token)
261    }
262}
263
264impl Drop for BufferCollectionAllocator {
265    fn drop(&mut self) {
266        if let Some(collection_client) = self.collection_client.as_mut() {
267            collection_client
268                .release()
269                .unwrap_or_else(|err| eprintln!("collection_client.release failed with {}", err));
270        }
271    }
272}
273
274#[cfg(test)]
275mod test {
276    use super::*;
277    use fidl_fuchsia_sysmem2::{
278        BufferCollectionRequest, BufferCollectionWaitForAllBuffersAllocatedResponse,
279        BufferMemorySettings, CoherencyDomain, Heap, SingleBufferSettings, VmoBuffer,
280    };
281    use fuchsia_async as fasync;
282    use futures::prelude::*;
283
284    const BUFFER_COUNT: usize = 3;
285
286    fn spawn_allocator_server() -> Result<AllocatorProxy, Error> {
287        let (proxy, mut stream) = fidl::endpoints::create_proxy_and_stream::<AllocatorMarker>();
288
289        fasync::Task::spawn(async move {
290            while let Some(_) = stream.try_next().await.expect("Failed to get request") {}
291        })
292        .detach();
293        Ok(proxy)
294    }
295
296    fn spawn_buffer_collection() -> Result<BufferCollectionProxy, Error> {
297        let (proxy, mut stream) =
298            fidl::endpoints::create_proxy_and_stream::<BufferCollectionMarker>();
299
300        fasync::Task::spawn(async move {
301            let mut stored_constraints = None;
302            while let Some(req) = stream.try_next().await.expect("Failed to get request") {
303                match req {
304                    BufferCollectionRequest::SetConstraints { payload, control_handle: _ } => {
305                        stored_constraints = payload.constraints;
306                    }
307                    BufferCollectionRequest::WaitForAllBuffersAllocated { responder } => {
308                        let constraints =
309                            stored_constraints.take().expect("Expected SetConstraints first");
310                        let mut buffers: Vec<VmoBuffer> = vec![];
311                        for _ in 0..*constraints.min_buffer_count.as_ref().unwrap() {
312                            buffers.push(fidl_fuchsia_sysmem2::VmoBuffer { ..Default::default() });
313                        }
314                        let buffer_collection_info = BufferCollectionInfo {
315                            settings: Some(SingleBufferSettings {
316                                buffer_settings: Some(BufferMemorySettings {
317                                    size_bytes: Some(0),
318                                    is_physically_contiguous: Some(false),
319                                    is_secure: Some(false),
320                                    coherency_domain: Some(CoherencyDomain::Cpu),
321                                    heap: Some(Heap {
322                                        heap_type: Some(
323                                            bind_fuchsia_sysmem_heap::HEAP_TYPE_SYSTEM_RAM.into(),
324                                        ),
325                                        ..Default::default()
326                                    }),
327                                    ..Default::default()
328                                }),
329                                image_format_constraints: Some(linear_image_format_constraints(
330                                    0,
331                                    0,
332                                    PixelFormat::Invalid,
333                                )),
334                                ..Default::default()
335                            }),
336                            buffers: Some(buffers),
337                            ..Default::default()
338                        };
339                        let response = BufferCollectionWaitForAllBuffersAllocatedResponse {
340                            buffer_collection_info: Some(buffer_collection_info),
341                            ..Default::default()
342                        };
343                        responder.send(Ok(response)).expect("Failed to send");
344                    }
345                    _ => panic!("Unexpected request"),
346                }
347            }
348        })
349        .detach();
350
351        return Ok(proxy);
352    }
353
354    #[fasync::run_singlethreaded(test)]
355    async fn test_buffer_collection_allocator() -> std::result::Result<(), anyhow::Error> {
356        let alloc_proxy = spawn_allocator_server()?;
357        let buf_proxy = spawn_buffer_collection()?;
358
359        // don't use new() as we want to inject alloc_proxy instead of discovering it.
360        let mut bca = BufferCollectionAllocator {
361            token: None,
362            width: 200,
363            height: 200,
364            pixel_format: PixelFormat::B8G8R8A8,
365            usage: FrameUsage::Cpu,
366            buffer_count: BUFFER_COUNT,
367            sysmem: alloc_proxy,
368            collection_client: None,
369        };
370
371        let buffers = bca.allocate_buffers_proxy(buf_proxy, true).await?;
372        assert_eq!(buffers.buffers.unwrap().len(), BUFFER_COUNT);
373
374        Ok(())
375    }
376}
fuchsia_framebuffer/sysmem.rs

fuchsia_framebuffer/
sysmem.rs
