src/media/cast/transport/cast_transport_config.h

   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
  19 namespace media {
  20 namespace cast {
  21 namespace transport {
  22
  23 enum RtcpMode {
  24   kRtcpCompound,     // Compound RTCP mode is described by RFC 4585.
  25   kRtcpReducedSize,  // Reduced-size RTCP mode is described by RFC 5506.
  26 };
  27
  28 enum VideoCodec {
  29   kUnknownVideoCodec,
  30   kFakeSoftwareVideo,
  31   kVp8,
  32   kH264,
  33   kVideoCodecLast = kH264
  34 };
  35
  36 enum AudioCodec {
  37   kUnknownAudioCodec,
  38   kOpus,
  39   kPcm16,
  40   kAudioCodecLast = kPcm16
  41 };
  42
  43 struct 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
  53 struct CastTransportRtpConfig {
  54   CastTransportRtpConfig();
  55   ~CastTransportRtpConfig();
  56   RtpConfig config;
  57   int max_outstanding_frames;
  58 };
  59
  60 struct CastTransportAudioConfig {
  61   CastTransportAudioConfig();
  62   ~CastTransportAudioConfig();
  63
  64   CastTransportRtpConfig rtp;
  65   AudioCodec codec;
  66   int frequency;
  67   int channels;
  68 };
  69
  70 struct 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.
  80 struct 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
 147 typedef std::vector<uint8> Packet;
 148 typedef scoped_refptr<base::RefCountedData<Packet> > PacketRef;
 149 typedef std::vector<PacketRef> PacketList;
 150
 151 typedef base::Callback<void(scoped_ptr<Packet> packet)> PacketReceiverCallback;
 152
 153 class 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
 164 struct 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
 176 struct 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
 189 struct 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.
 198 struct 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
 209 inline 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_