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
18namespace media {
19namespace cast {
20
21enum 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
31struct 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.
53struct 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.
76  const uint8* bytes() const {
77    return reinterpret_cast<uint8*>(string_as_array(
78        const_cast<std::string*>(&data)));
79  }
80  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
124typedef std::vector<uint8> Packet;
125typedef scoped_refptr<base::RefCountedData<Packet> > PacketRef;
126typedef std::vector<PacketRef> PacketList;
127
128typedef base::Callback<void(scoped_ptr<Packet> packet)> PacketReceiverCallback;
129
130class 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
142  virtual ~PacketSender() {}
143};
144
145struct 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
157struct 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
170struct RtcpDlrrReportBlock {
171  RtcpDlrrReportBlock();
172  ~RtcpDlrrReportBlock();
173  uint32 last_rr;
174  uint32 delay_since_last_rr;
175};
176
177inline 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