blob: 0277bd1feafbea0b8e3d3e61a2886c4c82f7d2a7 (
plain)
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
|
// Copyright 2013 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_CAST_RTCP_RTCP_DEFINES_H_
#define MEDIA_CAST_RTCP_RTCP_DEFINES_H_
#include <list>
#include <map>
#include <set>
#include "media/cast/cast_config.h"
#include "media/cast/cast_defines.h"
#include "media/cast/logging/logging_defines.h"
namespace media {
namespace cast {
// Handle the per frame ACK and NACK messages.
class RtcpCastMessage {
public:
explicit RtcpCastMessage(uint32 media_ssrc);
~RtcpCastMessage();
uint32 media_ssrc_;
uint32 ack_frame_id_;
MissingFramesAndPacketsMap missing_frames_and_packets_;
};
// Log messages form sender to receiver.
enum RtcpSenderFrameStatus {
kRtcpSenderFrameStatusUnknown = 0,
kRtcpSenderFrameStatusDroppedByEncoder = 1,
kRtcpSenderFrameStatusDroppedByFlowControl = 2,
kRtcpSenderFrameStatusSentToNetwork = 3,
};
struct RtcpSenderFrameLogMessage {
RtcpSenderFrameStatus frame_status;
uint32 rtp_timestamp;
};
typedef std::list<RtcpSenderFrameLogMessage> RtcpSenderLogMessage;
// Log messages from receiver to sender.
struct RtcpReceiverEventLogMessage {
CastLoggingEvent type;
base::TimeTicks event_timestamp;
base::TimeDelta delay_delta;
uint16 packet_id;
};
typedef std::list<RtcpReceiverEventLogMessage> RtcpReceiverEventLogMessages;
class RtcpReceiverFrameLogMessage {
public:
explicit RtcpReceiverFrameLogMessage(uint32 rtp_timestamp);
~RtcpReceiverFrameLogMessage();
uint32 rtp_timestamp_;
RtcpReceiverEventLogMessages event_log_messages_;
};
typedef std::list<RtcpReceiverFrameLogMessage> RtcpReceiverLogMessage;
struct RtcpSenderInfo {
// First three members are used for lipsync.
// First two members are used for rtt.
uint32 ntp_seconds;
uint32 ntp_fraction;
uint32 rtp_timestamp;
uint32 send_packet_count;
size_t send_octet_count;
};
struct RtcpReportBlock {
uint32 remote_ssrc; // SSRC of sender of this report.
uint32 media_ssrc; // SSRC of the RTP packet sender.
uint8 fraction_lost;
uint32 cumulative_lost; // 24 bits valid.
uint32 extended_high_sequence_number;
uint32 jitter;
uint32 last_sr;
uint32 delay_since_last_sr;
};
struct RtcpRpsiMessage {
uint32 remote_ssrc;
uint8 payload_type;
uint64 picture_id;
};
class RtcpNackMessage {
public:
RtcpNackMessage();
~RtcpNackMessage();
uint32 remote_ssrc;
std::list<uint16> nack_list;
};
class RtcpRembMessage {
public:
RtcpRembMessage();
~RtcpRembMessage();
uint32 remb_bitrate;
std::list<uint32> remb_ssrcs;
};
struct RtcpReceiverReferenceTimeReport {
uint32 remote_ssrc;
uint32 ntp_seconds;
uint32 ntp_fraction;
};
struct RtcpDlrrReportBlock {
uint32 last_rr;
uint32 delay_since_last_rr;
};
inline bool operator==(RtcpReportBlock lhs, RtcpReportBlock rhs) {
return lhs.remote_ssrc == rhs.remote_ssrc &&
lhs.media_ssrc == rhs.media_ssrc &&
lhs.fraction_lost == rhs.fraction_lost &&
lhs.cumulative_lost == rhs.cumulative_lost &&
lhs.extended_high_sequence_number == rhs.extended_high_sequence_number &&
lhs.jitter == rhs.jitter &&
lhs.last_sr == rhs.last_sr &&
lhs.delay_since_last_sr == rhs.delay_since_last_sr;
}
inline bool operator==(RtcpSenderInfo lhs, RtcpSenderInfo rhs) {
return lhs.ntp_seconds == rhs.ntp_seconds &&
lhs.ntp_fraction == rhs.ntp_fraction &&
lhs.rtp_timestamp == rhs.rtp_timestamp &&
lhs.send_packet_count == rhs.send_packet_count &&
lhs.send_octet_count == rhs.send_octet_count;
}
inline bool operator==(RtcpReceiverReferenceTimeReport lhs,
RtcpReceiverReferenceTimeReport rhs) {
return lhs.remote_ssrc == rhs.remote_ssrc &&
lhs.ntp_seconds == rhs.ntp_seconds &&
lhs.ntp_fraction == rhs.ntp_fraction;
}
} // namespace cast
} // namespace media
#endif // MEDIA_CAST_RTCP_RTCP_DEFINES_H_
|
