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 <stdint.h> 9 10#include <map> 11#include <set> 12 13#include "base/basictypes.h" 14#include "base/compiler_specific.h" 15#include "base/logging.h" 16#include "base/time/time.h" 17#include "media/cast/net/cast_transport_config.h" 18 19namespace media { 20namespace cast { 21 22const int64 kDontShowTimeoutMs = 33; 23const float kDefaultCongestionControlBackOff = 0.875f; 24const uint32 kVideoFrequency = 90000; 25const uint32 kStartFrameId = UINT32_C(0xffffffff); 26 27// This is an important system-wide constant. This limits how much history the 28// implementation must retain in order to process the acknowledgements of past 29// frames. 30// This value is carefully choosen such that it fits in the 8-bits range for 31// frame IDs. It is also less than half of the full 8-bits range such that we 32// can handle wrap around and compare two frame IDs. 33const int kMaxUnackedFrames = 120; 34 35const int64 kCastMessageUpdateIntervalMs = 33; 36const int64 kNackRepeatIntervalMs = 30; 37 38enum CastInitializationStatus { 39 STATUS_AUDIO_UNINITIALIZED, 40 STATUS_VIDEO_UNINITIALIZED, 41 STATUS_AUDIO_INITIALIZED, 42 STATUS_VIDEO_INITIALIZED, 43 STATUS_INVALID_CAST_ENVIRONMENT, 44 STATUS_INVALID_CRYPTO_CONFIGURATION, 45 STATUS_UNSUPPORTED_AUDIO_CODEC, 46 STATUS_UNSUPPORTED_VIDEO_CODEC, 47 STATUS_INVALID_AUDIO_CONFIGURATION, 48 STATUS_INVALID_VIDEO_CONFIGURATION, 49 STATUS_HW_VIDEO_ENCODER_NOT_SUPPORTED, 50}; 51 52enum DefaultSettings { 53 kDefaultAudioEncoderBitrate = 0, // This means "auto," and may mean VBR. 54 kDefaultAudioSamplingRate = 48000, 55 kDefaultMaxQp = 56, 56 kDefaultMinQp = 4, 57 kDefaultMaxFrameRate = 30, 58 kDefaultNumberOfVideoBuffers = 1, 59 kDefaultRtcpIntervalMs = 500, 60 kDefaultRtpHistoryMs = 1000, 61 kDefaultRtpMaxDelayMs = 100, 62}; 63 64enum PacketType { 65 kNewPacket, 66 kNewPacketCompletingFrame, 67 kDuplicatePacket, 68 kTooOldPacket, 69}; 70 71// kRtcpCastAllPacketsLost is used in PacketIDSet and 72// on the wire to mean that ALL packets for a particular 73// frame are lost. 74const uint16 kRtcpCastAllPacketsLost = 0xffff; 75 76// kRtcpCastLastPacket is used in PacketIDSet to ask for 77// the last packet of a frame to be retransmitted. 78const uint16 kRtcpCastLastPacket = 0xfffe; 79 80const size_t kMinLengthOfRtcp = 8; 81 82// Basic RTP header + cast header. 83const size_t kMinLengthOfRtp = 12 + 6; 84 85// Each uint16 represents one packet id within a cast frame. 86// Can also contain kRtcpCastAllPacketsLost and kRtcpCastLastPacket. 87typedef std::set<uint16> PacketIdSet; 88// Each uint8 represents one cast frame. 89typedef std::map<uint8, PacketIdSet> MissingFramesAndPacketsMap; 90 91// TODO(pwestin): Re-factor the functions bellow into a class with static 92// methods. 93 94// January 1970, in NTP seconds. 95// Network Time Protocol (NTP), which is in seconds relative to 0h UTC on 96// 1 January 1900. 97static const int64 kUnixEpochInNtpSeconds = INT64_C(2208988800); 98 99// Magic fractional unit. Used to convert time (in microseconds) to/from 100// fractional NTP seconds. 101static const double kMagicFractionalUnit = 4.294967296E3; 102 103// The maximum number of Cast receiver events to keep in history for the 104// purpose of sending the events through RTCP. 105// The number chosen should be more than the number of events that can be 106// stored in a RTCP packet. 107static const size_t kReceiverRtcpEventHistorySize = 512; 108 109inline bool IsNewerFrameId(uint32 frame_id, uint32 prev_frame_id) { 110 return (frame_id != prev_frame_id) && 111 static_cast<uint32>(frame_id - prev_frame_id) < 0x80000000; 112} 113 114inline bool IsNewerRtpTimestamp(uint32 timestamp, uint32 prev_timestamp) { 115 return (timestamp != prev_timestamp) && 116 static_cast<uint32>(timestamp - prev_timestamp) < 0x80000000; 117} 118 119inline bool IsOlderFrameId(uint32 frame_id, uint32 prev_frame_id) { 120 return (frame_id == prev_frame_id) || IsNewerFrameId(prev_frame_id, frame_id); 121} 122 123inline bool IsNewerPacketId(uint16 packet_id, uint16 prev_packet_id) { 124 return (packet_id != prev_packet_id) && 125 static_cast<uint16>(packet_id - prev_packet_id) < 0x8000; 126} 127 128inline bool IsNewerSequenceNumber(uint16 sequence_number, 129 uint16 prev_sequence_number) { 130 // Same function as IsNewerPacketId just different data and name. 131 return IsNewerPacketId(sequence_number, prev_sequence_number); 132} 133 134// Create a NTP diff from seconds and fractions of seconds; delay_fraction is 135// fractions of a second where 0x80000000 is half a second. 136inline uint32 ConvertToNtpDiff(uint32 delay_seconds, uint32 delay_fraction) { 137 return ((delay_seconds & 0x0000FFFF) << 16) + 138 ((delay_fraction & 0xFFFF0000) >> 16); 139} 140 141inline base::TimeDelta ConvertFromNtpDiff(uint32 ntp_delay) { 142 uint32 delay_ms = (ntp_delay & 0x0000ffff) * 1000; 143 delay_ms >>= 16; 144 delay_ms += ((ntp_delay & 0xffff0000) >> 16) * 1000; 145 return base::TimeDelta::FromMilliseconds(delay_ms); 146} 147 148inline void ConvertTimeToFractions(int64 ntp_time_us, 149 uint32* seconds, 150 uint32* fractions) { 151 DCHECK_GE(ntp_time_us, 0) << "Time must NOT be negative"; 152 const int64 seconds_component = 153 ntp_time_us / base::Time::kMicrosecondsPerSecond; 154 // NTP time will overflow in the year 2036. Also, make sure unit tests don't 155 // regress and use an origin past the year 2036. If this overflows here, the 156 // inverse calculation fails to compute the correct TimeTicks value, throwing 157 // off the entire system. 158 DCHECK_LT(seconds_component, INT64_C(4263431296)) 159 << "One year left to fix the NTP year 2036 wrap-around issue!"; 160 *seconds = static_cast<uint32>(seconds_component); 161 *fractions = static_cast<uint32>( 162 (ntp_time_us % base::Time::kMicrosecondsPerSecond) * 163 kMagicFractionalUnit); 164} 165 166inline void ConvertTimeTicksToNtp(const base::TimeTicks& time, 167 uint32* ntp_seconds, 168 uint32* ntp_fractions) { 169 base::TimeDelta elapsed_since_unix_epoch = 170 time - base::TimeTicks::UnixEpoch(); 171 172 int64 ntp_time_us = 173 elapsed_since_unix_epoch.InMicroseconds() + 174 (kUnixEpochInNtpSeconds * base::Time::kMicrosecondsPerSecond); 175 176 ConvertTimeToFractions(ntp_time_us, ntp_seconds, ntp_fractions); 177} 178 179inline base::TimeTicks ConvertNtpToTimeTicks(uint32 ntp_seconds, 180 uint32 ntp_fractions) { 181 int64 ntp_time_us = 182 static_cast<int64>(ntp_seconds) * base::Time::kMicrosecondsPerSecond + 183 static_cast<int64>(ntp_fractions) / kMagicFractionalUnit; 184 185 base::TimeDelta elapsed_since_unix_epoch = base::TimeDelta::FromMicroseconds( 186 ntp_time_us - 187 (kUnixEpochInNtpSeconds * base::Time::kMicrosecondsPerSecond)); 188 return base::TimeTicks::UnixEpoch() + elapsed_since_unix_epoch; 189} 190 191inline base::TimeDelta RtpDeltaToTimeDelta(int64 rtp_delta, int rtp_timebase) { 192 DCHECK_GT(rtp_timebase, 0); 193 return rtp_delta * base::TimeDelta::FromSeconds(1) / rtp_timebase; 194} 195 196inline int64 TimeDeltaToRtpDelta(base::TimeDelta delta, int rtp_timebase) { 197 DCHECK_GT(rtp_timebase, 0); 198 return delta * rtp_timebase / base::TimeDelta::FromSeconds(1); 199} 200 201} // namespace cast 202} // namespace media 203 204#endif // MEDIA_CAST_CAST_DEFINES_H_ 205