cast_defines.h revision 4e180b6a0b4720a9b8e9e959a882386f690f08ff 
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
16namespace media {
17namespace cast {
18
19const int64 kDontShowTimeoutMs = 33;
20const float kDefaultCongestionControlBackOff = 0.875f;
21const uint8 kStartFrameId = 255;
22const uint32 kVideoFrequency = 90000;
23const int64 kSkippedFramesCheckPeriodkMs = 10000;
24
25// Number of skipped frames threshold in fps (as configured) per period above.
26const int kSkippedFramesThreshold = 3;
27const size_t kIpPacketSize = 1500;
28const int kStartRttMs = 20;
29const int64 kCastMessageUpdateIntervalMs = 33;
30const int64 kNackRepeatIntervalMs = 30;
31
32enum DefaultSettings {
33  kDefaultMaxQp = 56,
34  kDefaultMinQp = 4,
35  kDefaultMaxFrameRate = 30,
36  kDefaultNumberOfVideoBuffers = 1,
37  kDefaultRtcpIntervalMs = 500,
38  kDefaultRtpHistoryMs = 1000,
39  kDefaultRtpMaxDelayMs = 100,
40};
41
42const uint16 kRtcpCastAllPacketsLost = 0xffff;
43
44// Each uint16 represents one packet id within a cast frame.
45typedef std::set<uint16> PacketIdSet;
46// Each uint8 represents one cast frame.
47typedef std::map<uint8, PacketIdSet> MissingFramesAndPacketsMap;
48
49// TODO(pwestin): Re-factor the functions bellow into a class with static
50// methods.
51
52// Magic fractional unit. Used to convert time (in microseconds) to/from
53// fractional NTP seconds.
54static const double kMagicFractionalUnit = 4.294967296E3;
55
56// Network Time Protocol (NTP), which is in seconds relative to 0h UTC on
57// 1 January 1900.
58static const int64 kNtpEpochDeltaSeconds = GG_INT64_C(9435484800);
59static const int64 kNtpEpochDeltaMicroseconds =
60    kNtpEpochDeltaSeconds * base::Time::kMicrosecondsPerSecond;
61
62inline bool IsNewerFrameId(uint8 frame_id, uint8 prev_frame_id) {
63  return (frame_id != prev_frame_id) &&
64      static_cast<uint8>(frame_id - prev_frame_id) < 0x80;
65}
66
67inline bool IsOlderFrameId(uint8 frame_id, uint8 prev_frame_id) {
68  return (frame_id == prev_frame_id) || IsNewerFrameId(prev_frame_id, frame_id);
69}
70
71inline bool IsNewerPacketId(uint16 packet_id, uint16 prev_packet_id) {
72  return (packet_id != prev_packet_id) &&
73      static_cast<uint16>(packet_id - prev_packet_id) < 0x8000;
74}
75
76inline bool IsNewerSequenceNumber(uint16 sequence_number,
77                                  uint16 prev_sequence_number) {
78  // Same function as IsNewerPacketId just different data and name.
79  return IsNewerPacketId(sequence_number, prev_sequence_number);
80}
81
82// Create a NTP diff from seconds and fractions of seconds; delay_fraction is
83// fractions of a second where 0x80000000 is half a second.
84inline uint32 ConvertToNtpDiff(uint32 delay_seconds, uint32 delay_fraction) {
85  return ((delay_seconds & 0x0000FFFF) << 16) +
86         ((delay_fraction & 0xFFFF0000) >> 16);
87}
88
89inline base::TimeDelta ConvertFromNtpDiff(uint32 ntp_delay) {
90  uint32 delay_ms = (ntp_delay & 0x0000ffff) * 1000;
91  delay_ms >>= 16;
92  delay_ms += ((ntp_delay & 0xffff0000) >> 16) * 1000;
93  return base::TimeDelta::FromMilliseconds(delay_ms);
94}
95
96inline void ConvertTimeToFractions(int64 time_us,
97                                   uint32* seconds,
98                                   uint32* fractions) {
99  DCHECK_GE(time_us, 0) << "Time must NOT be negative";
100  *seconds = static_cast<uint32>(time_us / base::Time::kMicrosecondsPerSecond);
101  *fractions = static_cast<uint32>(
102      (time_us % base::Time::kMicrosecondsPerSecond) * kMagicFractionalUnit);
103}
104
105inline void ConvertTimeToNtp(const base::TimeTicks& time,
106                             uint32* ntp_seconds,
107                             uint32* ntp_fractions) {
108  int64 time_us = time.ToInternalValue() - kNtpEpochDeltaMicroseconds;
109  ConvertTimeToFractions(time_us, ntp_seconds, ntp_fractions);
110}
111
112inline base::TimeTicks ConvertNtpToTime(uint32 ntp_seconds,
113                                        uint32 ntp_fractions) {
114  int64 ntp_time_us = static_cast<int64>(ntp_seconds) *
115       base::Time::kMicrosecondsPerSecond;
116  ntp_time_us += static_cast<int64>(ntp_fractions) / kMagicFractionalUnit;
117  return base::TimeTicks::FromInternalValue(ntp_time_us +
118      kNtpEpochDeltaMicroseconds);
119}
120
121}  // namespace cast
122}  // namespace media
123
124#endif  // MEDIA_CAST_CAST_DEFINES_H_
125