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. 4 5 #ifndef MEDIA_CAST_NET_CAST_TRANSPORT_CONFIG_H_ 6 #define MEDIA_CAST_NET_CAST_TRANSPORT_CONFIG_H_ 7 8 #include <string> 9 #include <vector> 10 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" 17 18 namespace media { 19 namespace cast { 20 21 enum Codec { 22 CODEC_UNKNOWN, 23 CODEC_AUDIO_OPUS, 24 CODEC_AUDIO_PCM16, 25 CODEC_VIDEO_FAKE, 26 CODEC_VIDEO_VP8, 27 CODEC_VIDEO_H264, 28 CODEC_LAST = CODEC_VIDEO_H264 29 }; 30 31 struct CastTransportRtpConfig { 32 CastTransportRtpConfig(); 33 ~CastTransportRtpConfig(); 34 35 // Identifier refering to this sender. 36 uint32 ssrc; 37 38 // Identifier for incoming RTCP traffic. 39 uint32 feedback_ssrc; 40 41 // RTP payload type enum: Specifies the type/encoding of frame data. 42 int rtp_payload_type; 43 44 // The AES crypto key and initialization vector. Each of these strings 45 // contains the data in binary form, of size kAesKeySize. If they are empty 46 // strings, crypto is not being used. 47 std::string aes_key; 48 std::string aes_iv_mask; 49 }; 50 51 // A combination of metadata and data for one encoded frame. This can contain 52 // audio data or video data or other. 53 struct EncodedFrame { 54 enum Dependency { 55 // "null" value, used to indicate whether |dependency| has been set. 56 UNKNOWN_DEPENDENCY, 57 58 // Not decodable without the reference frame indicated by 59 // |referenced_frame_id|. 60 DEPENDENT, 61 62 // Independently decodable. 63 INDEPENDENT, 64 65 // Independently decodable, and no future frames will depend on any frames 66 // before this one. 67 KEY, 68 69 DEPENDENCY_LAST = KEY 70 }; 71 72 EncodedFrame(); 73 ~EncodedFrame(); 74 75 // Convenience accessors to data as an array of uint8 elements. bytesEncodedFrame76 const uint8* bytes() const { 77 return reinterpret_cast<uint8*>(string_as_array( 78 const_cast<std::string*>(&data))); 79 } mutable_bytesEncodedFrame80 uint8* mutable_bytes() { 81 return reinterpret_cast<uint8*>(string_as_array(&data)); 82 } 83 84 // Copies all data members except |data| to |dest|. 85 // Does not modify |dest->data|. 86 void CopyMetadataTo(EncodedFrame* dest) const; 87 88 // This frame's dependency relationship with respect to other frames. 89 Dependency dependency; 90 91 // The label associated with this frame. Implies an ordering relative to 92 // other frames in the same stream. 93 uint32 frame_id; 94 95 // The label associated with the frame upon which this frame depends. If 96 // this frame does not require any other frame in order to become decodable 97 // (e.g., key frames), |referenced_frame_id| must equal |frame_id|. 98 uint32 referenced_frame_id; 99 100 // The stream timestamp, on the timeline of the signal data. For example, RTP 101 // timestamps for audio are usually defined as the total number of audio 102 // samples encoded in all prior frames. A playback system uses this value to 103 // detect gaps in the stream, and otherwise stretch the signal to match 104 // playout targets. 105 uint32 rtp_timestamp; 106 107 // The common reference clock timestamp for this frame. This value originates 108 // from a sender and is used to provide lip synchronization between streams in 109 // a receiver. Thus, in the sender context, this is set to the time at which 110 // the frame was captured/recorded. In the receiver context, this is set to 111 // the target playout time. Over a sequence of frames, this time value is 112 // expected to drift with respect to the elapsed time implied by the RTP 113 // timestamps; and it may not necessarily increment with precise regularity. 114 base::TimeTicks reference_time; 115 116 // Playout delay for this and all future frames. Used by the Adaptive 117 // Playout delay extension. Zero means no change. 118 uint16 new_playout_delay_ms; 119 120 // The encoded signal data. 121 std::string data; 122 }; 123 124 typedef std::vector<uint8> Packet; 125 typedef scoped_refptr<base::RefCountedData<Packet> > PacketRef; 126 typedef std::vector<PacketRef> PacketList; 127 128 typedef base::Callback<void(scoped_ptr<Packet> packet)> PacketReceiverCallback; 129 130 class PacketSender { 131 public: 132 // Send a packet to the network. Returns false if the network is blocked 133 // and we should wait for |cb| to be called. It is not allowed to called 134 // SendPacket again until |cb| has been called. Any other errors that 135 // occur will be reported through side channels, in such cases, this function 136 // will return true indicating that the channel is not blocked. 137 virtual bool SendPacket(PacketRef packet, const base::Closure& cb) = 0; 138 139 // Returns the number of bytes ever sent. 140 virtual int64 GetBytesSent() = 0; 141 ~PacketSender()142 virtual ~PacketSender() {} 143 }; 144 145 struct RtcpSenderInfo { 146 RtcpSenderInfo(); 147 ~RtcpSenderInfo(); 148 // First three members are used for lipsync. 149 // First two members are used for rtt. 150 uint32 ntp_seconds; 151 uint32 ntp_fraction; 152 uint32 rtp_timestamp; 153 uint32 send_packet_count; 154 size_t send_octet_count; 155 }; 156 157 struct RtcpReportBlock { 158 RtcpReportBlock(); 159 ~RtcpReportBlock(); 160 uint32 remote_ssrc; // SSRC of sender of this report. 161 uint32 media_ssrc; // SSRC of the RTP packet sender. 162 uint8 fraction_lost; 163 uint32 cumulative_lost; // 24 bits valid. 164 uint32 extended_high_sequence_number; 165 uint32 jitter; 166 uint32 last_sr; 167 uint32 delay_since_last_sr; 168 }; 169 170 struct RtcpDlrrReportBlock { 171 RtcpDlrrReportBlock(); 172 ~RtcpDlrrReportBlock(); 173 uint32 last_rr; 174 uint32 delay_since_last_rr; 175 }; 176 177 inline bool operator==(RtcpSenderInfo lhs, RtcpSenderInfo rhs) { 178 return lhs.ntp_seconds == rhs.ntp_seconds && 179 lhs.ntp_fraction == rhs.ntp_fraction && 180 lhs.rtp_timestamp == rhs.rtp_timestamp && 181 lhs.send_packet_count == rhs.send_packet_count && 182 lhs.send_octet_count == rhs.send_octet_count; 183 } 184 185 } // namespace cast 186 } // namespace media 187 188 #endif // MEDIA_CAST_NET_CAST_TRANSPORT_CONFIG_H_ 189