1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef MEDIA_CAST_NET_CAST_TRANSPORT_CONFIG_H_
6 #define MEDIA_CAST_NET_CAST_TRANSPORT_CONFIG_H_
11 #include "base/basictypes.h"
12 #include "base/callback.h"
13 #include "base/memory/linked_ptr.h"
14 #include "base/memory/ref_counted.h"
15 #include "base/stl_util.h"
16 #include "media/cast/net/cast_transport_defines.h"
29 CODEC_LAST = CODEC_VIDEO_H264
32 struct CastTransportRtpConfig {
33 CastTransportRtpConfig();
34 ~CastTransportRtpConfig();
36 // Identifier refering to this sender.
39 // Identifier for incoming RTCP traffic.
42 // RTP payload type enum: Specifies the type/encoding of frame data.
45 // The AES crypto key and initialization vector. Each of these strings
46 // contains the data in binary form, of size kAesKeySize. If they are empty
47 // strings, crypto is not being used.
49 std::string aes_iv_mask;
52 // A combination of metadata and data for one encoded frame. This can contain
53 // audio data or video data or other.
56 // "null" value, used to indicate whether |dependency| has been set.
59 // Not decodable without the reference frame indicated by
60 // |referenced_frame_id|.
63 // Independently decodable.
66 // Independently decodable, and no future frames will depend on any frames
76 // Convenience accessors to data as an array of uint8 elements.
77 const uint8* bytes() const {
78 return reinterpret_cast<uint8*>(string_as_array(
79 const_cast<std::string*>(&data)));
81 uint8* mutable_bytes() {
82 return reinterpret_cast<uint8*>(string_as_array(&data));
85 // Copies all data members except |data| to |dest|.
86 // Does not modify |dest->data|.
87 void CopyMetadataTo(EncodedFrame* dest) const;
89 // This frame's dependency relationship with respect to other frames.
90 Dependency dependency;
92 // The label associated with this frame. Implies an ordering relative to
93 // other frames in the same stream.
96 // The label associated with the frame upon which this frame depends. If
97 // this frame does not require any other frame in order to become decodable
98 // (e.g., key frames), |referenced_frame_id| must equal |frame_id|.
99 uint32 referenced_frame_id;
101 // The stream timestamp, on the timeline of the signal data. For example, RTP
102 // timestamps for audio are usually defined as the total number of audio
103 // samples encoded in all prior frames. A playback system uses this value to
104 // detect gaps in the stream, and otherwise stretch the signal to match
106 uint32 rtp_timestamp;
108 // The common reference clock timestamp for this frame. This value originates
109 // from a sender and is used to provide lip synchronization between streams in
110 // a receiver. Thus, in the sender context, this is set to the time at which
111 // the frame was captured/recorded. In the receiver context, this is set to
112 // the target playout time. Over a sequence of frames, this time value is
113 // expected to drift with respect to the elapsed time implied by the RTP
114 // timestamps; and it may not necessarily increment with precise regularity.
115 base::TimeTicks reference_time;
117 // Playout delay for this and all future frames. Used by the Adaptive
118 // Playout delay extension. Zero means no change.
119 uint16 new_playout_delay_ms;
121 // The encoded signal data.
125 typedef std::vector<uint8> Packet;
126 typedef scoped_refptr<base::RefCountedData<Packet> > PacketRef;
127 typedef std::vector<PacketRef> PacketList;
129 typedef base::Callback<void(scoped_ptr<Packet> packet)> PacketReceiverCallback;
133 // Send a packet to the network. Returns false if the network is blocked
134 // and we should wait for |cb| to be called. It is not allowed to called
135 // SendPacket again until |cb| has been called. Any other errors that
136 // occur will be reported through side channels, in such cases, this function
137 // will return true indicating that the channel is not blocked.
138 virtual bool SendPacket(PacketRef packet, const base::Closure& cb) = 0;
140 // Returns the number of bytes ever sent.
141 virtual int64 GetBytesSent() = 0;
143 virtual ~PacketSender() {}
146 struct RtcpSenderInfo {
149 // First three members are used for lipsync.
150 // First two members are used for rtt.
153 uint32 rtp_timestamp;
154 uint32 send_packet_count;
155 size_t send_octet_count;
158 struct RtcpReportBlock {
161 uint32 remote_ssrc; // SSRC of sender of this report.
162 uint32 media_ssrc; // SSRC of the RTP packet sender.
164 uint32 cumulative_lost; // 24 bits valid.
165 uint32 extended_high_sequence_number;
168 uint32 delay_since_last_sr;
171 struct RtcpDlrrReportBlock {
172 RtcpDlrrReportBlock();
173 ~RtcpDlrrReportBlock();
175 uint32 delay_since_last_rr;
178 inline bool operator==(RtcpSenderInfo lhs, RtcpSenderInfo rhs) {
179 return lhs.ntp_seconds == rhs.ntp_seconds &&
180 lhs.ntp_fraction == rhs.ntp_fraction &&
181 lhs.rtp_timestamp == rhs.rtp_timestamp &&
182 lhs.send_packet_count == rhs.send_packet_count &&
183 lhs.send_octet_count == rhs.send_octet_count;
189 #endif // MEDIA_CAST_NET_CAST_TRANSPORT_CONFIG_H_