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