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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
/*
* Copyright 2020 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef PC_TRANSCEIVER_LIST_H_
#define PC_TRANSCEIVER_LIST_H_
#include <stddef.h>
#include <algorithm>
#include <map>
#include <string>
#include <vector>
#include "absl/types/optional.h"
#include "api/media_types.h"
#include "api/rtc_error.h"
#include "api/rtp_parameters.h"
#include "api/rtp_sender_interface.h"
#include "api/scoped_refptr.h"
#include "api/sequence_checker.h"
#include "pc/rtp_transceiver.h"
#include "rtc_base/checks.h"
#include "rtc_base/system/no_unique_address.h"
#include "rtc_base/thread_annotations.h"
namespace webrtc {
typedef rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
RtpTransceiverProxyRefPtr;
// Captures partial state to be used for rollback. Applicable only in
// Unified Plan.
class TransceiverStableState {
public:
TransceiverStableState() {}
void set_newly_created();
void SetMSectionIfUnset(absl::optional<std::string> mid,
absl::optional<size_t> mline_index);
void SetRemoteStreamIds(const std::vector<std::string>& ids);
void SetInitSendEncodings(
const std::vector<RtpEncodingParameters>& encodings);
void SetFiredDirection(
absl::optional<RtpTransceiverDirection> fired_direction) {
fired_direction_ = fired_direction;
}
absl::optional<std::string> mid() const { return mid_; }
absl::optional<size_t> mline_index() const { return mline_index_; }
absl::optional<std::vector<std::string>> remote_stream_ids() const {
return remote_stream_ids_;
}
absl::optional<std::vector<RtpEncodingParameters>> init_send_encodings()
const {
return init_send_encodings_;
}
bool has_m_section() const { return has_m_section_; }
bool newly_created() const { return newly_created_; }
bool did_set_fired_direction() const { return fired_direction_.has_value(); }
// Because fired_direction() is nullable, did_set_fired_direction() is used to
// distinguish beteen "no value" and "null value".
absl::optional<RtpTransceiverDirection> fired_direction() const {
RTC_DCHECK(did_set_fired_direction());
return fired_direction_.value();
}
private:
absl::optional<std::string> mid_;
absl::optional<size_t> mline_index_;
absl::optional<std::vector<std::string>> remote_stream_ids_;
absl::optional<std::vector<RtpEncodingParameters>> init_send_encodings_;
// Indicates that mid value from stable state has been captured and
// that rollback has to restore the transceiver. Also protects against
// subsequent overwrites.
bool has_m_section_ = false;
// Indicates that the transceiver was created as part of applying a
// description to track potential need for removing transceiver during
// rollback.
bool newly_created_ = false;
// `fired_direction_` is nullable, so an optional of an optional is used to
// distinguish between null and not set (sorry if this hurts your eyes).
absl::optional<absl::optional<RtpTransceiverDirection>> fired_direction_;
};
// This class encapsulates the active list of transceivers on a
// PeerConnection, and offers convenient functions on that list.
// It is a single-thread class; all operations must be performed
// on the same thread.
class TransceiverList {
public:
// Returns a copy of the currently active list of transceivers. The
// list consists of rtc::scoped_refptrs, which will keep the transceivers
// from being deallocated, even if they are removed from the TransceiverList.
std::vector<RtpTransceiverProxyRefPtr> List() const {
RTC_DCHECK_RUN_ON(&sequence_checker_);
return transceivers_;
}
// As above, but does not check thread ownership. Unsafe.
// TODO(bugs.webrtc.org/12692): Refactor and remove
std::vector<RtpTransceiverProxyRefPtr> UnsafeList() const {
return transceivers_;
}
// Returns a list of the internal() pointers of the currently active list
// of transceivers. These raw pointers are not thread-safe, so need to
// be consumed on the same thread.
std::vector<RtpTransceiver*> ListInternal() const;
void Add(RtpTransceiverProxyRefPtr transceiver) {
RTC_DCHECK_RUN_ON(&sequence_checker_);
transceivers_.push_back(transceiver);
}
void Remove(RtpTransceiverProxyRefPtr transceiver) {
RTC_DCHECK_RUN_ON(&sequence_checker_);
transceivers_.erase(
std::remove(transceivers_.begin(), transceivers_.end(), transceiver),
transceivers_.end());
}
RtpTransceiverProxyRefPtr FindBySender(
rtc::scoped_refptr<RtpSenderInterface> sender) const;
RtpTransceiverProxyRefPtr FindByMid(const std::string& mid) const;
RtpTransceiverProxyRefPtr FindByMLineIndex(size_t mline_index) const;
// Find or create the stable state for a transceiver.
TransceiverStableState* StableState(RtpTransceiverProxyRefPtr transceiver) {
RTC_DCHECK_RUN_ON(&sequence_checker_);
return &(transceiver_stable_states_by_transceivers_[transceiver]);
}
void DiscardStableStates() {
RTC_DCHECK_RUN_ON(&sequence_checker_);
transceiver_stable_states_by_transceivers_.clear();
}
std::map<RtpTransceiverProxyRefPtr, TransceiverStableState>& StableStates() {
RTC_DCHECK_RUN_ON(&sequence_checker_);
return transceiver_stable_states_by_transceivers_;
}
private:
RTC_NO_UNIQUE_ADDRESS SequenceChecker sequence_checker_;
std::vector<RtpTransceiverProxyRefPtr> transceivers_;
// TODO(bugs.webrtc.org/12692): Add RTC_GUARDED_BY(sequence_checker_);
// Holds changes made to transceivers during applying descriptors for
// potential rollback. Gets cleared once signaling state goes to stable.
std::map<RtpTransceiverProxyRefPtr, TransceiverStableState>
transceiver_stable_states_by_transceivers_
RTC_GUARDED_BY(sequence_checker_);
// Holds remote stream ids for transceivers from stable state.
std::map<RtpTransceiverProxyRefPtr, std::vector<std::string>>
remote_stream_ids_by_transceivers_ RTC_GUARDED_BY(sequence_checker_);
};
} // namespace webrtc
#endif // PC_TRANSCEIVER_LIST_H_
|
