| // Copyright 2021 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef MEDIA_FUCHSIA_COMMON_VMO_BUFFER_H_ |
| #define MEDIA_FUCHSIA_COMMON_VMO_BUFFER_H_ |
| |
| #include <fuchsia/media/cpp/fidl.h> |
| #include <fuchsia/sysmem/cpp/fidl.h> |
| |
| #include <memory> |
| |
| #include "base/compiler_specific.h" |
| #include "base/containers/span.h" |
| #include "base/memory/shared_memory_mapping.h" |
| #include "media/base/media_export.h" |
| #include "third_party/abseil-cpp/absl/types/optional.h" |
| |
| namespace media { |
| |
| class MEDIA_EXPORT VmoBuffer { |
| public: |
| // Returns sysmem buffer constraints to use to ensure that sysmem buffer |
| // collection is compatible with this class. |
| static fuchsia::sysmem::BufferCollectionConstraints GetRecommendedConstraints( |
| size_t min_buffer_count, |
| absl::optional<size_t> min_buffer_size, |
| bool writable); |
| |
| // Creates a set of buffers from a sysmem collection. An empty vector is |
| // returned in case of a failure. |
| static std::vector<VmoBuffer> CreateBuffersFromSysmemCollection( |
| fuchsia::sysmem::BufferCollectionInfo_2* info, |
| bool writable); |
| |
| VmoBuffer(); |
| ~VmoBuffer(); |
| |
| VmoBuffer(VmoBuffer&&); |
| VmoBuffer& operator=(VmoBuffer&&); |
| |
| // Initializes the buffer from the specified |vmo|. |writable| should be true |
| // for writable buffers. |offset| and |size| are used to specify the portion |
| // of the |vmo| that should be used for this buffer. Returns false if it fails |
| // to map the buffer. |
| bool Initialize(zx::vmo vmo, |
| bool writable, |
| size_t offset, |
| size_t size, |
| fuchsia::sysmem::CoherencyDomain coherency_domain) |
| WARN_UNUSED_RESULT; |
| |
| size_t size() const { return size_; } |
| |
| // Read the buffer content into |data|, starting from |offset|. For buffers |
| // with RAM coherency the cache is invalidated prior to read to ensure the |
| // data is read from RAM instead of the CPU cache. Returns number of bytes |
| // that have been copied. |
| size_t Read(size_t offset, base::span<uint8_t> data); |
| |
| // Writes |data| to this input buffer. If the |data| is larger than the buffer |
| // then writes only size() bytes from the head of the |data|. Returns number |
| // of bytes that have been copied. |
| size_t Write(base::span<const uint8_t> data); |
| |
| // Returns read-only memory corresponding to the buffer. Also invalidates CPU |
| // cache for buffers with RAM coherency. |
| base::span<const uint8_t> GetMemory(); |
| |
| // Returns writable memory span. The caller should call Flush() after writing |
| // to the buffer in order to ensure that the buffer is flushed in case it uses |
| // RAM coherency. |
| base::span<uint8_t> GetWritableMemory(); |
| |
| // Flushes the CPU cache if the buffers uses RAM coherency. No-op for buffers |
| // with CPU coherency. If |invalidate| flag is set then the cache is also |
| // invalidated. |
| void FlushCache(size_t flush_offset, size_t flush_size, bool invalidate); |
| |
| // Duplicates VMO. |
| zx::vmo Duplicate(bool writable); |
| |
| private: |
| // Returns size of the mapped region. |
| size_t mapped_size(); |
| |
| zx::vmo vmo_; |
| |
| uint8_t* base_address_ = nullptr; |
| |
| bool writable_ = false; |
| size_t offset_ = 0; |
| size_t size_ = 0; |
| fuchsia::sysmem::CoherencyDomain coherency_domain_; |
| }; |
| |
| } // namespace media |
| |
| #endif // MEDIA_FUCHSIA_COMMON_VMO_BUFFER_H_ |