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
163
164
165
166
167
168
169
170
171
172
|
// Copyright 2020 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 CAST_STREAMING_SENDER_SESSION_H_
#define CAST_STREAMING_SENDER_SESSION_H_
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "cast/common/public/message_port.h"
#include "cast/streaming/answer_messages.h"
#include "cast/streaming/capture_configs.h"
#include "cast/streaming/offer_messages.h"
#include "cast/streaming/sender.h"
#include "cast/streaming/sender_packet_router.h"
#include "cast/streaming/session_config.h"
#include "cast/streaming/session_messager.h"
#include "json/value.h"
#include "util/json/json_serialization.h"
namespace openscreen {
namespace cast {
namespace capture_recommendations {
struct Recommendations;
}
class Environment;
class Sender;
class SenderSession final {
public:
// Upon successful negotiation, a set of configured senders is constructed
// for handling audio and video. Note that either sender may be null.
struct ConfiguredSenders {
// In practice, we may have 0, 1, or 2 senders configured, depending
// on if the device supports audio and video, and if we were able to
// successfully negotiate a sender configuration.
// If the sender is audio- or video-only, either of the senders
// may be nullptr. However, in the majority of cases they will be populated.
Sender* audio_sender;
AudioCaptureConfig audio_config;
Sender* video_sender;
VideoCaptureConfig video_config;
};
// The embedder should provide a client for handling the negotiation.
// When the negotiation is complete, the OnMirroringNegotiated callback is
// called.
class Client {
public:
// Called when a new set of senders has been negotiated. This may be
// called multiple times during a session, once for every time
// NegotiateMirroring() is called on the SenderSession object. The
// negotiation call also includes capture recommendations that can be used
// by the sender to provide an optimal video stream for the receiver.
virtual void OnMirroringNegotiated(
const SenderSession* session,
ConfiguredSenders senders,
capture_recommendations::Recommendations capture_recommendations) = 0;
// Called whenever an error occurs. Ends the ongoing session, and the caller
// must call NegotiateMirroring() again if they wish to re-establish
// streaming.
virtual void OnError(const SenderSession* session, Error error) = 0;
protected:
virtual ~Client();
};
// The SenderSession assumes that the passed in client, environment, and
// message port persist for at least the lifetime of the SenderSession. If
// one of these classes needs to be reset, a new SenderSession should be
// created.
//
// |message_source_id| and |message_destination_id| are the local and remote
// ID, respectively, to use when sending or receiving control messages (e.g.,
// OFFERs or ANSWERs) over the |message_port|. |message_port|'s SetClient()
// method will be called.
SenderSession(IPAddress remote_address,
Client* const client,
Environment* environment,
MessagePort* message_port,
std::string message_source_id,
std::string message_destination_id);
SenderSession(const SenderSession&) = delete;
SenderSession(SenderSession&&) noexcept = delete;
SenderSession& operator=(const SenderSession&) = delete;
SenderSession& operator=(SenderSession&&) = delete;
~SenderSession();
// Starts an OFFER/ANSWER exchange with the already configured receiver
// over the message port. The caller should assume any configured senders
// become invalid when calling this method.
Error NegotiateMirroring(std::vector<AudioCaptureConfig> audio_configs,
std::vector<VideoCaptureConfig> video_configs);
// Get the current network usage (in bits per second). This includes all
// senders managed by this session, and is a best guess based on receiver
// feedback. Embedders may use this information to throttle capture devices.
int GetEstimatedNetworkBandwidth() const;
private:
// We store the current negotiation, so that when we get an answer from the
// receiver we can line up the selected streams with the original
// configuration.
struct Negotiation {
Offer offer;
std::vector<AudioCaptureConfig> audio_configs;
std::vector<VideoCaptureConfig> video_configs;
};
// Specific message type handler methods.
void OnAnswer(ReceiverMessage message);
// Used by SpawnSenders to generate a sender for a specific stream.
std::unique_ptr<Sender> CreateSender(Ssrc receiver_ssrc,
const Stream& stream,
RtpPayloadType type);
// Helper methods for spawning specific senders from the Answer message.
void SpawnAudioSender(ConfiguredSenders* senders,
Ssrc receiver_ssrc,
int send_index,
int config_index);
void SpawnVideoSender(ConfiguredSenders* senders,
Ssrc receiver_ssrc,
int send_index,
int config_index);
// Spawn a set of configured senders from the currently stored negotiation.
ConfiguredSenders SpawnSenders(const Answer& answer);
// The remote address of the receiver we are communicating with. Used
// for both TLS and UDP traffic.
const IPAddress remote_address_;
// The embedder is expected to provide us a client for notifications about
// negotiations and errors, a valid cast environment, and a messaging
// port for communicating to the Receiver over TLS.
Client* const client_;
Environment* const environment_;
SenderSessionMessager messager_;
// The packet router used for messaging across all senders.
SenderPacketRouter packet_router_;
// Each negotiation has its own sequence number, and the receiver replies
// with the same sequence number that we send. Each message to the receiver
// advances our current sequence number.
int current_sequence_number_ = 0;
// The current negotiation. If present, we are expected an ANSWER from
// the receiver. If not present, any provided ANSWERS are rejected.
std::unique_ptr<Negotiation> current_negotiation_;
// If the negotiation has succeeded, we store the current audio and video
// senders used for this session. Either or both may be nullptr.
std::unique_ptr<Sender> current_audio_sender_;
std::unique_ptr<Sender> current_video_sender_;
}; // namespace cast
} // namespace cast
} // namespace openscreen
#endif // CAST_STREAMING_SENDER_SESSION_H_
|
