1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef REMOTING_HOST_VIDEO_MEMORY_UTILS_H_
#define REMOTING_HOST_VIDEO_MEMORY_UTILS_H_
#include <memory>
#include "base/functional/callback.h"
#include "base/memory/read_only_shared_memory_region.h"
#include "base/memory/ref_counted.h"
#include "base/memory/shared_memory_mapping.h"
#include "third_party/webrtc/modules/desktop_capture/shared_memory.h"
#if BUILDFLAG(IS_WIN)
#include "base/win/scoped_handle.h"
#endif // BUILDFLAG(IS_WIN)
// Helper classes to implement sharing of captured video frames over an IPC
// channel.
namespace remoting {
// webrtc::SharedMemory implementation that creates a
// base::ReadOnlySharedMemoryRegion along with a writable mapping.
// The writable mapping is used by the real video-capturer in the Desktop
// process, and the read-only region is sent over the IPC channel.
class SharedVideoMemory : public webrtc::SharedMemory {
public:
static std::unique_ptr<SharedVideoMemory>
Create(size_t size, int id, base::OnceClosure on_deleted_callback);
SharedVideoMemory(const SharedVideoMemory&) = delete;
SharedVideoMemory& operator=(const SharedVideoMemory&) = delete;
~SharedVideoMemory() override;
const base::ReadOnlySharedMemoryRegion& region() const { return region_; }
private:
SharedVideoMemory(base::ReadOnlySharedMemoryRegion region,
base::WritableSharedMemoryMapping mapping,
webrtc::SharedMemory::Handle handle,
int id,
base::OnceClosure on_deleted_callback);
base::OnceClosure on_deleted_callback_;
base::ReadOnlySharedMemoryRegion region_;
base::WritableSharedMemoryMapping mapping_;
#if BUILDFLAG(IS_WIN)
// Owns the handle passed to the base class which is used by
// webrtc::ScreenCapturer.
base::win::ScopedHandle writable_handle_;
#endif
};
// A webrtc::SharedMemoryFactory implementation which creates
// SharedVideoMemory objects for the real video-capturer in the Desktop
// process. It notifies callbacks when memory is created and released.
class SharedVideoMemoryFactory : public webrtc::SharedMemoryFactory {
public:
using SharedMemoryCreatedCallback = base::RepeatingCallback<
void(int id, base::ReadOnlySharedMemoryRegion, uint32_t size)>;
using SharedMemoryReleasedCallback = base::RepeatingCallback<void(int id)>;
SharedVideoMemoryFactory(
SharedMemoryCreatedCallback shared_memory_created_callback,
SharedMemoryReleasedCallback shared_memory_released_callback);
SharedVideoMemoryFactory(const SharedVideoMemoryFactory&) = delete;
SharedVideoMemoryFactory& operator=(const SharedVideoMemoryFactory&) = delete;
~SharedVideoMemoryFactory() override;
std::unique_ptr<webrtc::SharedMemory> CreateSharedMemory(
size_t size) override;
private:
int next_shared_buffer_id_ = 1;
SharedMemoryCreatedCallback shared_memory_created_callback_;
SharedMemoryReleasedCallback shared_memory_released_callback_;
};
// A wrapper for read-only memory received over IPC. This creates and stores a
// ReadOnlySharedMemoryMapping for the received memory-region.
class IpcSharedBufferCore
: public base::RefCountedThreadSafe<IpcSharedBufferCore> {
public:
IpcSharedBufferCore(int id, base::ReadOnlySharedMemoryRegion region);
IpcSharedBufferCore(const IpcSharedBufferCore&) = delete;
IpcSharedBufferCore& operator=(const IpcSharedBufferCore&) = delete;
int id() const { return id_; }
size_t size() const { return mapping_.size(); }
const void* memory() const { return mapping_.memory(); }
private:
~IpcSharedBufferCore();
friend class base::RefCountedThreadSafe<IpcSharedBufferCore>;
int id_;
base::ReadOnlySharedMemoryMapping mapping_;
};
// A webrtc::SharedMemory implementation which wraps an IpcSharedBufferCore.
// This is used for the `shared_memory` field of a webrtc::DesktopFrame in the
// Network process.
class IpcSharedBuffer : public webrtc::SharedMemory {
public:
explicit IpcSharedBuffer(scoped_refptr<IpcSharedBufferCore> core);
IpcSharedBuffer(const IpcSharedBuffer&) = delete;
IpcSharedBuffer& operator=(const IpcSharedBuffer&) = delete;
~IpcSharedBuffer() override;
private:
scoped_refptr<IpcSharedBufferCore> core_;
};
} // namespace remoting
#endif // REMOTING_HOST_VIDEO_MEMORY_UTILS_H_
|
