media/cast/cast_defines.h

   1 // Copyright 2013 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_CAST_DEFINES_H_
   6 #define MEDIA_CAST_CAST_DEFINES_H_
   7
   8 #include <map>
   9 #include <set>
  10
  11 #include "base/basictypes.h"
  12 #include "base/compiler_specific.h"
  13 #include "base/logging.h"
  14 #include "base/time/time.h"
  15
  16 namespace media {
  17 namespace cast {
  18
  19 const int64 kDontShowTimeoutMs = 33;
  20 const float kDefaultCongestionControlBackOff = 0.875f;
  21 const uint32 kVideoFrequency = 90000;
  22 const int64 kSkippedFramesCheckPeriodkMs = 10000;
  23 const uint32 kStartFrameId = GG_UINT32_C(0xffffffff);
  24
  25 // Number of skipped frames threshold in fps (as configured) per period above.
  26 const int kSkippedFramesThreshold = 3;
  27 const size_t kMaxIpPacketSize = 1500;
  28 const int kStartRttMs = 20;
  29 const int64 kCastMessageUpdateIntervalMs = 33;
  30 const int64 kNackRepeatIntervalMs = 30;
  31
  32 enum DefaultSettings {
  33   kDefaultAudioEncoderBitrate = 0,  // This means "auto," and may mean VBR.
  34   kDefaultAudioSamplingRate = 48000,
  35   kDefaultMaxQp = 56,
  36   kDefaultMinQp = 4,
  37   kDefaultMaxFrameRate = 30,
  38   kDefaultNumberOfVideoBuffers = 1,
  39   kDefaultRtcpIntervalMs = 500,
  40   kDefaultRtpHistoryMs = 1000,
  41   kDefaultRtpMaxDelayMs = 100,
  42 };
  43
  44 enum PacketType {
  45   kNewPacket,
  46   kNewPacketCompletingFrame,
  47   kDuplicatePacket,
  48   kTooOldPacket,
  49 };
  50
  51 const uint16 kRtcpCastAllPacketsLost = 0xffff;
  52
  53 const size_t kMinLengthOfRtcp = 8;
  54
  55 // Basic RTP header + cast header.
  56 const size_t kMinLengthOfRtp = 12 + 6;
  57
  58 const size_t kAesBlockSize = 16;
  59 const size_t kAesKeySize = 16;
  60
  61 // Each uint16 represents one packet id within a cast frame.
  62 typedef std::set<uint16> PacketIdSet;
  63 // Each uint8 represents one cast frame.
  64 typedef std::map<uint8, PacketIdSet> MissingFramesAndPacketsMap;
  65
  66 // TODO(pwestin): Re-factor the functions bellow into a class with static
  67 // methods.
  68
  69 // January 1970, in NTP seconds.
  70 // Network Time Protocol (NTP), which is in seconds relative to 0h UTC on
  71 // 1 January 1900.
  72 static const int64 kUnixEpochInNtpSeconds = GG_INT64_C(2208988800);
  73
  74 // Magic fractional unit. Used to convert time (in microseconds) to/from
  75 // fractional NTP seconds.
  76 static const double kMagicFractionalUnit = 4.294967296E3;
  77
  78 inline bool IsNewerFrameId(uint32 frame_id, uint32 prev_frame_id) {
  79   return (frame_id != prev_frame_id) &&
  80       static_cast<uint32>(frame_id - prev_frame_id) < 0x80000000;
  81 }
  82
  83 inline bool IsNewerRtpTimestamp(uint32 timestamp, uint32 prev_timestamp) {
  84   return (timestamp != prev_timestamp) &&
  85       static_cast<uint32>(timestamp - prev_timestamp) < 0x80000000;
  86 }
  87
  88 inline bool IsOlderFrameId(uint32 frame_id, uint32 prev_frame_id) {
  89   return (frame_id == prev_frame_id) || IsNewerFrameId(prev_frame_id, frame_id);
  90 }
  91
  92 inline bool IsNewerPacketId(uint16 packet_id, uint16 prev_packet_id) {
  93   return (packet_id != prev_packet_id) &&
  94       static_cast<uint16>(packet_id - prev_packet_id) < 0x8000;
  95 }
  96
  97 inline bool IsNewerSequenceNumber(uint16 sequence_number,
  98                                   uint16 prev_sequence_number) {
  99   // Same function as IsNewerPacketId just different data and name.
 100   return IsNewerPacketId(sequence_number, prev_sequence_number);
 101 }
 102
 103 // Create a NTP diff from seconds and fractions of seconds; delay_fraction is
 104 // fractions of a second where 0x80000000 is half a second.
 105 inline uint32 ConvertToNtpDiff(uint32 delay_seconds, uint32 delay_fraction) {
 106   return ((delay_seconds & 0x0000FFFF) << 16) +
 107          ((delay_fraction & 0xFFFF0000) >> 16);
 108 }
 109
 110 inline base::TimeDelta ConvertFromNtpDiff(uint32 ntp_delay) {
 111   uint32 delay_ms = (ntp_delay & 0x0000ffff) * 1000;
 112   delay_ms >>= 16;
 113   delay_ms += ((ntp_delay & 0xffff0000) >> 16) * 1000;
 114   return base::TimeDelta::FromMilliseconds(delay_ms);
 115 }
 116
 117 inline void ConvertTimeToFractions(int64 time_us,
 118                                    uint32* seconds,
 119                                    uint32* fractions) {
 120   DCHECK_GE(time_us, 0) << "Time must NOT be negative";
 121   *seconds = static_cast<uint32>(time_us / base::Time::kMicrosecondsPerSecond);
 122   *fractions = static_cast<uint32>(
 123       (time_us % base::Time::kMicrosecondsPerSecond) * kMagicFractionalUnit);
 124 }
 125
 126 inline void ConvertTimeTicksToNtp(const base::TimeTicks& time,
 127                                   uint32* ntp_seconds,
 128                                   uint32* ntp_fractions) {
 129   base::TimeDelta elapsed_since_unix_epoch =
 130       time - base::TimeTicks::UnixEpoch();
 131
 132   int64 ntp_time_us = elapsed_since_unix_epoch.InMicroseconds() +
 133       (kUnixEpochInNtpSeconds * base::Time::kMicrosecondsPerSecond);
 134
 135   ConvertTimeToFractions(ntp_time_us, ntp_seconds, ntp_fractions);
 136 }
 137
 138 inline base::TimeTicks ConvertNtpToTimeTicks(uint32 ntp_seconds,
 139                                              uint32 ntp_fractions) {
 140   int64 ntp_time_us = static_cast<int64>(ntp_seconds) *
 141       base::Time::kMicrosecondsPerSecond +
 142           static_cast<int64>(ntp_fractions) / kMagicFractionalUnit;
 143
 144   base::TimeDelta elapsed_since_unix_epoch =
 145       base::TimeDelta::FromMicroseconds(ntp_time_us -
 146           (kUnixEpochInNtpSeconds * base::Time::kMicrosecondsPerSecond));
 147   return base::TimeTicks::UnixEpoch() + elapsed_since_unix_epoch;
 148 }
 149
 150 inline std::string GetAesNonce(uint32 frame_id, const std::string& iv_mask) {
 151   std::string aes_nonce(kAesBlockSize, 0);
 152
 153   // Serializing frame_id in big-endian order (aes_nonce[8] is the most
 154   // significant byte of frame_id).
 155   aes_nonce[11] = frame_id & 0xff;
 156   aes_nonce[10] = (frame_id >> 8) & 0xff;
 157   aes_nonce[9] = (frame_id >> 16) & 0xff;
 158   aes_nonce[8] = (frame_id >> 24) & 0xff;
 159
 160   for (size_t i = 0; i < kAesBlockSize; ++i) {
 161     aes_nonce[i] ^= iv_mask[i];
 162   }
 163   return aes_nonce;
 164 }
 165
 166 inline uint32 GetVideoRtpTimestamp(const base::TimeTicks& time_ticks) {
 167   base::TimeTicks zero_time;
 168   base::TimeDelta recorded_delta = time_ticks - zero_time;
 169   // Timestamp is in 90 KHz for video.
 170   return static_cast<uint32>(recorded_delta.InMilliseconds() * 90);
 171 }
 172
 173 }  // namespace cast
 174 }  // namespace media
 175
 176 #endif  // MEDIA_CAST_CAST_DEFINES_H_