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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
// Copyright 2014 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.
// This class maintains a send transport for audio and video in a Cast
// Streaming session.
// Audio, video frames and RTCP messages are submitted to this object
// and then packetized and paced to the underlying UDP socket.
//
// The hierarchy of send transport in a Cast Streaming session:
//
// CastTransportSender RTP RTCP
// ------------------------------------------------------------------
// TransportEncryptionHandler (A/V)
// RtpSender (A/V) Rtcp (A/V)
// PacedSender (Shared)
// UdpTransport (Shared)
//
// There are objects of TransportEncryptionHandler, RtpSender and Rtcp
// for each audio and video stream.
// PacedSender and UdpTransport are shared between all RTP and RTCP
// streams.
#ifndef MEDIA_CAST_NET_CAST_TRANSPORT_SENDER_IMPL_H_
#define MEDIA_CAST_NET_CAST_TRANSPORT_SENDER_IMPL_H_
#include <stdint.h>
#include <set>
#include <vector>
#include "base/callback.h"
#include "base/gtest_prod_util.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/time/tick_clock.h"
#include "base/time/time.h"
#include "media/cast/common/transport_encryption_handler.h"
#include "media/cast/logging/logging_defines.h"
#include "media/cast/net/cast_transport_config.h"
#include "media/cast/net/cast_transport_sender.h"
#include "media/cast/net/pacing/paced_sender.h"
#include "media/cast/net/rtcp/sender_rtcp_session.h"
#include "media/cast/net/rtp/rtp_parser.h"
#include "media/cast/net/rtp/rtp_sender.h"
#include "net/base/network_interfaces.h"
namespace media {
namespace cast {
class UdpTransport;
class CastTransportSenderImpl : public CastTransportSender {
public:
CastTransportSenderImpl(
base::TickClock* clock, // Owned by the caller.
base::TimeDelta logging_flush_interval,
scoped_ptr<Client> client,
scoped_ptr<PacketSender> transport,
const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner);
~CastTransportSenderImpl() final;
// CastTransportSender implementation.
void InitializeAudio(const CastTransportRtpConfig& config,
const RtcpCastMessageCallback& cast_message_cb,
const RtcpRttCallback& rtt_cb) final;
void InitializeVideo(const CastTransportRtpConfig& config,
const RtcpCastMessageCallback& cast_message_cb,
const RtcpRttCallback& rtt_cb) final;
void InsertFrame(uint32_t ssrc, const EncodedFrame& frame) final;
void SendSenderReport(uint32_t ssrc,
base::TimeTicks current_time,
RtpTimeTicks current_time_as_rtp_timestamp) final;
void CancelSendingFrames(uint32_t ssrc,
const std::vector<uint32_t>& frame_ids) final;
void ResendFrameForKickstart(uint32_t ssrc, uint32_t frame_id) final;
PacketReceiverCallback PacketReceiverForTesting() final;
// Possible keys of |options| handled here are:
// "pacer_target_burst_size": int
// - Specifies how many packets to send per 10 ms ideally.
// "pacer_max_burst_size": int
// - Specifies how many pakcets to send per 10 ms, maximum.
// "send_buffer_min_size": int
// - Specifies the minimum socket send buffer size.
// "disable_wifi_scan" (value ignored)
// - Disable wifi scans while streaming.
// "media_streaming_mode" (value ignored)
// - Turn media streaming mode on.
// Note, these options may be ignored on some platforms.
void SetOptions(const base::DictionaryValue& options) final;
// CastTransportReceiver implementation.
void AddValidSsrc(uint32_t ssrc) final;
void SendRtcpFromRtpReceiver(
uint32_t ssrc,
uint32_t sender_ssrc,
const RtcpTimeData& time_data,
const RtcpCastMessage* cast_message,
base::TimeDelta target_delay,
const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events,
const RtpReceiverStatistics* rtp_receiver_statistics) final;
private:
FRIEND_TEST_ALL_PREFIXES(CastTransportSenderImplTest, NacksCancelRetransmits);
FRIEND_TEST_ALL_PREFIXES(CastTransportSenderImplTest, CancelRetransmits);
FRIEND_TEST_ALL_PREFIXES(CastTransportSenderImplTest, Kickstart);
FRIEND_TEST_ALL_PREFIXES(CastTransportSenderImplTest,
DedupRetransmissionWithAudio);
// Resend packets for the stream identified by |ssrc|.
// If |cancel_rtx_if_not_in_list| is true then transmission of packets for the
// frames but not in the list will be dropped.
// See PacedSender::ResendPackets() to see how |dedup_info| works.
void ResendPackets(uint32_t ssrc,
const MissingFramesAndPacketsMap& missing_packets,
bool cancel_rtx_if_not_in_list,
const DedupInfo& dedup_info);
// If |logging_flush_interval| is set, this is called at approximate periodic
// intervals.
void SendRawEvents();
// Called when a packet is received.
bool OnReceivedPacket(scoped_ptr<Packet> packet);
// Called when a log message is received.
void OnReceivedLogMessage(EventMediaType media_type,
const RtcpReceiverLogMessage& log);
// Called when a RTCP Cast message is received.
void OnReceivedCastMessage(uint32_t ssrc,
const RtcpCastMessageCallback& cast_message_cb,
const RtcpCastMessage& cast_message);
base::TickClock* const clock_; // Not owned by this class.
const base::TimeDelta logging_flush_interval_;
const scoped_ptr<Client> transport_client_;
const scoped_ptr<PacketSender> transport_;
const scoped_refptr<base::SingleThreadTaskRunner> transport_task_runner_;
// FrameEvents and PacketEvents pending delivery via raw events callback.
// Do not add elements to these when |logging_flush_interval| is
// |base::TimeDelta()|.
std::vector<FrameEvent> recent_frame_events_;
std::vector<PacketEvent> recent_packet_events_;
// Packet sender that performs pacing.
PacedSender pacer_;
// Packetizer for audio and video frames.
scoped_ptr<RtpSender> audio_sender_;
scoped_ptr<RtpSender> video_sender_;
// Maintains RTCP session for audio and video.
scoped_ptr<SenderRtcpSession> audio_rtcp_session_;
scoped_ptr<SenderRtcpSession> video_rtcp_session_;
// Encrypts data in EncodedFrames before they are sent. Note that it's
// important for the encryption to happen here, in code that would execute in
// the main browser process, for security reasons. This helps to mitigate
// the damage that could be caused by a compromised renderer process.
TransportEncryptionHandler audio_encryptor_;
TransportEncryptionHandler video_encryptor_;
// Right after a frame is sent we record the number of bytes sent to the
// socket. We record the corresponding bytes sent for the most recent ACKed
// audio packet.
int64_t last_byte_acked_for_audio_;
// Packets that don't match these ssrcs are ignored.
std::set<uint32_t> valid_ssrcs_;
// While non-null, global WiFi behavior modifications are in effect. This is
// used, for example, to turn off WiFi scanning that tends to interfere with
// the reliability of UDP packet transmission.
scoped_ptr<net::ScopedWifiOptions> wifi_options_autoreset_;
base::WeakPtrFactory<CastTransportSenderImpl> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(CastTransportSenderImpl);
};
} // namespace cast
} // namespace media
#endif // MEDIA_CAST_NET_CAST_TRANSPORT_SENDER_IMPL_H_
|
