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_TRANSPORT_CAST_TRANSPORT_CONFIG_H_
6#define MEDIA_CAST_TRANSPORT_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/transport/cast_transport_defines.h"
17#include "net/base/ip_endpoint.h"
18
19namespace media {
20namespace cast {
21namespace transport {
22
23enum RtcpMode {
24  kRtcpCompound,     // Compound RTCP mode is described by RFC 4585.
25  kRtcpReducedSize,  // Reduced-size RTCP mode is described by RFC 5506.
26};
27
28enum VideoCodec {
29  kUnknownVideoCodec,
30  kFakeSoftwareVideo,
31  kVp8,
32  kH264,
33  kVideoCodecLast = kH264
34};
35
36enum AudioCodec {
37  kUnknownAudioCodec,
38  kOpus,
39  kPcm16,
40  kAudioCodecLast = kPcm16
41};
42
43struct RtpConfig {
44  RtpConfig();
45  ~RtpConfig();
46  uint32 ssrc;
47  int max_delay_ms;
48  int payload_type;
49  std::string aes_key;      // Binary string of size kAesKeySize.
50  std::string aes_iv_mask;  // Binary string of size kAesBlockSize.
51};
52
53struct CastTransportRtpConfig {
54  CastTransportRtpConfig();
55  ~CastTransportRtpConfig();
56  RtpConfig config;
57  int max_outstanding_frames;
58};
59
60struct CastTransportAudioConfig {
61  CastTransportAudioConfig();
62  ~CastTransportAudioConfig();
63
64  CastTransportRtpConfig rtp;
65  AudioCodec codec;
66  int frequency;
67  int channels;
68};
69
70struct CastTransportVideoConfig {
71  CastTransportVideoConfig();
72  ~CastTransportVideoConfig();
73
74  CastTransportRtpConfig rtp;
75  VideoCodec codec;
76};
77
78// A combination of metadata and data for one encoded frame.  This can contain
79// audio data or video data or other.
80struct EncodedFrame {
81  enum Dependency {
82    // "null" value, used to indicate whether |dependency| has been set.
83    UNKNOWN_DEPENDENCY,
84
85    // Not decodable without the reference frame indicated by
86    // |referenced_frame_id|.
87    DEPENDENT,
88
89    // Independently decodable.
90    INDEPENDENT,
91
92    // Independently decodable, and no future frames will depend on any frames
93    // before this one.
94    KEY,
95
96    DEPENDENCY_LAST = KEY
97  };
98
99  EncodedFrame();
100  ~EncodedFrame();
101
102  // Convenience accessors to data as an array of uint8 elements.
103  const uint8* bytes() const {
104    return reinterpret_cast<uint8*>(string_as_array(
105        const_cast<std::string*>(&data)));
106  }
107  uint8* mutable_bytes() {
108    return reinterpret_cast<uint8*>(string_as_array(&data));
109  }
110
111  // Copies all data members except |data| to |dest|.
112  // Does not modify |dest->data|.
113  void CopyMetadataTo(EncodedFrame* dest) const;
114
115  // This frame's dependency relationship with respect to other frames.
116  Dependency dependency;
117
118  // The label associated with this frame.  Implies an ordering relative to
119  // other frames in the same stream.
120  uint32 frame_id;
121
122  // The label associated with the frame upon which this frame depends.  If
123  // this frame does not require any other frame in order to become decodable
124  // (e.g., key frames), |referenced_frame_id| must equal |frame_id|.
125  uint32 referenced_frame_id;
126
127  // The stream timestamp, on the timeline of the signal data.  For example, RTP
128  // timestamps for audio are usually defined as the total number of audio
129  // samples encoded in all prior frames.  A playback system uses this value to
130  // detect gaps in the stream, and otherwise stretch the signal to match
131  // playout targets.
132  uint32 rtp_timestamp;
133
134  // The common reference clock timestamp for this frame.  This value originates
135  // from a sender and is used to provide lip synchronization between streams in
136  // a receiver.  Thus, in the sender context, this is set to the time at which
137  // the frame was captured/recorded.  In the receiver context, this is set to
138  // the target playout time.  Over a sequence of frames, this time value is
139  // expected to drift with respect to the elapsed time implied by the RTP
140  // timestamps; and it may not necessarily increment with precise regularity.
141  base::TimeTicks reference_time;
142
143  // The encoded signal data.
144  std::string data;
145};
146
147typedef std::vector<uint8> Packet;
148typedef scoped_refptr<base::RefCountedData<Packet> > PacketRef;
149typedef std::vector<PacketRef> PacketList;
150
151typedef base::Callback<void(scoped_ptr<Packet> packet)> PacketReceiverCallback;
152
153class PacketSender {
154 public:
155  // Send a packet to the network. Returns false if the network is blocked
156  // and we should wait for |cb| to be called. It is not allowed to called
157  // SendPacket again until |cb| has been called. Any other errors that
158  // occur will be reported through side channels, in such cases, this function
159  // will return true indicating that the channel is not blocked.
160  virtual bool SendPacket(PacketRef packet, const base::Closure& cb) = 0;
161  virtual ~PacketSender() {}
162};
163
164struct RtcpSenderInfo {
165  RtcpSenderInfo();
166  ~RtcpSenderInfo();
167  // First three members are used for lipsync.
168  // First two members are used for rtt.
169  uint32 ntp_seconds;
170  uint32 ntp_fraction;
171  uint32 rtp_timestamp;
172  uint32 send_packet_count;
173  size_t send_octet_count;
174};
175
176struct RtcpReportBlock {
177  RtcpReportBlock();
178  ~RtcpReportBlock();
179  uint32 remote_ssrc;  // SSRC of sender of this report.
180  uint32 media_ssrc;   // SSRC of the RTP packet sender.
181  uint8 fraction_lost;
182  uint32 cumulative_lost;  // 24 bits valid.
183  uint32 extended_high_sequence_number;
184  uint32 jitter;
185  uint32 last_sr;
186  uint32 delay_since_last_sr;
187};
188
189struct RtcpDlrrReportBlock {
190  RtcpDlrrReportBlock();
191  ~RtcpDlrrReportBlock();
192  uint32 last_rr;
193  uint32 delay_since_last_rr;
194};
195
196// This is only needed because IPC messages don't support more than
197// 5 arguments.
198struct SendRtcpFromRtpSenderData {
199  SendRtcpFromRtpSenderData();
200  ~SendRtcpFromRtpSenderData();
201  uint32 packet_type_flags;
202  uint32 sending_ssrc;
203  std::string c_name;
204  uint32 ntp_seconds;
205  uint32 ntp_fraction;
206  uint32 rtp_timestamp;
207};
208
209inline bool operator==(RtcpSenderInfo lhs, RtcpSenderInfo rhs) {
210  return lhs.ntp_seconds == rhs.ntp_seconds &&
211         lhs.ntp_fraction == rhs.ntp_fraction &&
212         lhs.rtp_timestamp == rhs.rtp_timestamp &&
213         lhs.send_packet_count == rhs.send_packet_count &&
214         lhs.send_octet_count == rhs.send_octet_count;
215}
216
217}  // namespace transport
218}  // namespace cast
219}  // namespace media
220
221#endif  // MEDIA_CAST_TRANSPORT_CAST_TRANSPORT_CONFIG_H_
222