blob: 91f5f8423c2b3411bad3cc5a49b332cad058597d [file] [log] [blame]
niklase@google.com470e71d2011-07-07 08:21:25 +00001/*
2 * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
Henrik Kjellander2557b862015-11-18 22:00:21 +010011#include "webrtc/modules/video_coding/timing.h"
stefan@webrtc.orga678a3b2013-01-21 07:42:11 +000012
philipel5908c712015-12-21 08:23:20 -080013#include <algorithm>
14
Henrik Kjellander2557b862015-11-18 22:00:21 +010015#include "webrtc/modules/video_coding/internal_defines.h"
16#include "webrtc/modules/video_coding/jitter_buffer_common.h"
Henrik Kjellander98f53512015-10-28 18:17:40 +010017#include "webrtc/system_wrappers/include/clock.h"
18#include "webrtc/system_wrappers/include/metrics.h"
19#include "webrtc/system_wrappers/include/timestamp_extrapolator.h"
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +000020
niklase@google.com470e71d2011-07-07 08:21:25 +000021namespace webrtc {
22
philipel5908c712015-12-21 08:23:20 -080023VCMTiming::VCMTiming(Clock* clock, VCMTiming* master_timing)
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +000024 : crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +000025 clock_(clock),
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +000026 master_(false),
27 ts_extrapolator_(),
magjed4bf0c712016-03-11 02:15:07 -080028 codec_timer_(new VCMCodecTimer()),
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +000029 render_delay_ms_(kDefaultRenderDelayMs),
mikhal@webrtc.orgadc64a72013-05-30 16:20:18 +000030 min_playout_delay_ms_(0),
31 jitter_delay_ms_(0),
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +000032 current_delay_ms_(0),
fischman@webrtc.org37bb4972013-10-23 23:59:45 +000033 last_decode_ms_(0),
asapersson@webrtc.orgf2447602014-12-09 14:13:26 +000034 prev_frame_timestamp_(0),
35 num_decoded_frames_(0),
36 num_delayed_decoded_frames_(0),
37 first_decoded_frame_ms_(-1),
38 sum_missed_render_deadline_ms_(0) {
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +000039 if (master_timing == NULL) {
40 master_ = true;
wu@webrtc.org66773a02014-05-07 17:09:44 +000041 ts_extrapolator_ = new TimestampExtrapolator(clock_->TimeInMilliseconds());
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +000042 } else {
43 ts_extrapolator_ = master_timing->ts_extrapolator_;
44 }
niklase@google.com470e71d2011-07-07 08:21:25 +000045}
46
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +000047VCMTiming::~VCMTiming() {
asapersson@webrtc.orgf2447602014-12-09 14:13:26 +000048 UpdateHistograms();
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +000049 if (master_) {
50 delete ts_extrapolator_;
51 }
52 delete crit_sect_;
niklase@google.com470e71d2011-07-07 08:21:25 +000053}
54
asapersson@webrtc.orgf2447602014-12-09 14:13:26 +000055void VCMTiming::UpdateHistograms() const {
56 CriticalSectionScoped cs(crit_sect_);
57 if (num_decoded_frames_ == 0) {
58 return;
59 }
60 int64_t elapsed_sec =
61 (clock_->TimeInMilliseconds() - first_decoded_frame_ms_) / 1000;
62 if (elapsed_sec < metrics::kMinRunTimeInSeconds) {
63 return;
64 }
asapersson28ba9272016-01-25 05:58:23 -080065 RTC_HISTOGRAM_COUNTS_100(
asapersson53805322015-12-21 01:46:20 -080066 "WebRTC.Video.DecodedFramesPerSecond",
asapersson@webrtc.orgf2447602014-12-09 14:13:26 +000067 static_cast<int>((num_decoded_frames_ / elapsed_sec) + 0.5f));
asapersson28ba9272016-01-25 05:58:23 -080068 RTC_HISTOGRAM_PERCENTAGE(
asapersson53805322015-12-21 01:46:20 -080069 "WebRTC.Video.DelayedFramesToRenderer",
asapersson@webrtc.orgf2447602014-12-09 14:13:26 +000070 num_delayed_decoded_frames_ * 100 / num_decoded_frames_);
71 if (num_delayed_decoded_frames_ > 0) {
asapersson28ba9272016-01-25 05:58:23 -080072 RTC_HISTOGRAM_COUNTS_1000(
asapersson@webrtc.orgf2447602014-12-09 14:13:26 +000073 "WebRTC.Video.DelayedFramesToRenderer_AvgDelayInMs",
asapersson53805322015-12-21 01:46:20 -080074 sum_missed_render_deadline_ms_ / num_delayed_decoded_frames_);
asapersson@webrtc.orgf2447602014-12-09 14:13:26 +000075 }
76}
77
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +000078void VCMTiming::Reset() {
79 CriticalSectionScoped cs(crit_sect_);
wu@webrtc.orged4cb562014-05-06 04:50:49 +000080 ts_extrapolator_->Reset(clock_->TimeInMilliseconds());
magjed4bf0c712016-03-11 02:15:07 -080081 codec_timer_.reset(new VCMCodecTimer());
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +000082 render_delay_ms_ = kDefaultRenderDelayMs;
mikhal@webrtc.orgadc64a72013-05-30 16:20:18 +000083 min_playout_delay_ms_ = 0;
84 jitter_delay_ms_ = 0;
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +000085 current_delay_ms_ = 0;
86 prev_frame_timestamp_ = 0;
niklase@google.com470e71d2011-07-07 08:21:25 +000087}
88
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +000089void VCMTiming::ResetDecodeTime() {
pbos@webrtc.org04221002014-07-10 15:25:37 +000090 CriticalSectionScoped lock(crit_sect_);
magjed4bf0c712016-03-11 02:15:07 -080091 codec_timer_.reset(new VCMCodecTimer());
niklase@google.com470e71d2011-07-07 08:21:25 +000092}
93
mikhal@webrtc.orgadc64a72013-05-30 16:20:18 +000094void VCMTiming::set_render_delay(uint32_t render_delay_ms) {
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +000095 CriticalSectionScoped cs(crit_sect_);
96 render_delay_ms_ = render_delay_ms;
niklase@google.com470e71d2011-07-07 08:21:25 +000097}
98
mikhal@webrtc.orgadc64a72013-05-30 16:20:18 +000099void VCMTiming::set_min_playout_delay(uint32_t min_playout_delay_ms) {
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000100 CriticalSectionScoped cs(crit_sect_);
mikhal@webrtc.orgadc64a72013-05-30 16:20:18 +0000101 min_playout_delay_ms_ = min_playout_delay_ms;
niklase@google.com470e71d2011-07-07 08:21:25 +0000102}
103
mikhal@webrtc.orgadc64a72013-05-30 16:20:18 +0000104void VCMTiming::SetJitterDelay(uint32_t jitter_delay_ms) {
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000105 CriticalSectionScoped cs(crit_sect_);
mikhal@webrtc.orgadc64a72013-05-30 16:20:18 +0000106 if (jitter_delay_ms != jitter_delay_ms_) {
mikhal@webrtc.orgadc64a72013-05-30 16:20:18 +0000107 jitter_delay_ms_ = jitter_delay_ms;
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000108 // When in initial state, set current delay to minimum delay.
109 if (current_delay_ms_ == 0) {
mikhal@webrtc.orgadc64a72013-05-30 16:20:18 +0000110 current_delay_ms_ = jitter_delay_ms_;
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000111 }
112 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000113}
114
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000115void VCMTiming::UpdateCurrentDelay(uint32_t frame_timestamp) {
116 CriticalSectionScoped cs(crit_sect_);
117 uint32_t target_delay_ms = TargetDelayInternal();
niklase@google.com470e71d2011-07-07 08:21:25 +0000118
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000119 if (current_delay_ms_ == 0) {
120 // Not initialized, set current delay to target.
121 current_delay_ms_ = target_delay_ms;
122 } else if (target_delay_ms != current_delay_ms_) {
philipel5908c712015-12-21 08:23:20 -0800123 int64_t delay_diff_ms =
124 static_cast<int64_t>(target_delay_ms) - current_delay_ms_;
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000125 // Never change the delay with more than 100 ms every second. If we're
126 // changing the delay in too large steps we will get noticeable freezes. By
127 // limiting the change we can increase the delay in smaller steps, which
128 // will be experienced as the video is played in slow motion. When lowering
129 // the delay the video will be played at a faster pace.
130 int64_t max_change_ms = 0;
131 if (frame_timestamp < 0x0000ffff && prev_frame_timestamp_ > 0xffff0000) {
132 // wrap
philipel5908c712015-12-21 08:23:20 -0800133 max_change_ms = kDelayMaxChangeMsPerS *
134 (frame_timestamp + (static_cast<int64_t>(1) << 32) -
135 prev_frame_timestamp_) /
136 90000;
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000137 } else {
138 max_change_ms = kDelayMaxChangeMsPerS *
philipel5908c712015-12-21 08:23:20 -0800139 (frame_timestamp - prev_frame_timestamp_) / 90000;
niklase@google.com470e71d2011-07-07 08:21:25 +0000140 }
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000141 if (max_change_ms <= 0) {
142 // Any changes less than 1 ms are truncated and
143 // will be postponed. Negative change will be due
144 // to reordering and should be ignored.
145 return;
146 }
147 delay_diff_ms = std::max(delay_diff_ms, -max_change_ms);
148 delay_diff_ms = std::min(delay_diff_ms, max_change_ms);
mikhal@webrtc.org6faba6e2013-04-30 15:39:34 +0000149
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000150 current_delay_ms_ = current_delay_ms_ + static_cast<int32_t>(delay_diff_ms);
151 }
152 prev_frame_timestamp_ = frame_timestamp;
niklase@google.com470e71d2011-07-07 08:21:25 +0000153}
154
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000155void VCMTiming::UpdateCurrentDelay(int64_t render_time_ms,
156 int64_t actual_decode_time_ms) {
157 CriticalSectionScoped cs(crit_sect_);
158 uint32_t target_delay_ms = TargetDelayInternal();
magjed4bf0c712016-03-11 02:15:07 -0800159 int64_t delayed_ms =
160 actual_decode_time_ms -
161 (render_time_ms - RequiredDecodeTimeMs() - render_delay_ms_);
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000162 if (delayed_ms < 0) {
163 return;
164 }
165 if (current_delay_ms_ + delayed_ms <= target_delay_ms) {
166 current_delay_ms_ += static_cast<uint32_t>(delayed_ms);
167 } else {
168 current_delay_ms_ = target_delay_ms;
169 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000170}
171
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000172int32_t VCMTiming::StopDecodeTimer(uint32_t time_stamp,
Per327d8ba2015-11-10 14:00:27 +0100173 int32_t decode_time_ms,
asapersson@webrtc.orgf2447602014-12-09 14:13:26 +0000174 int64_t now_ms,
175 int64_t render_time_ms) {
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000176 CriticalSectionScoped cs(crit_sect_);
magjed4bf0c712016-03-11 02:15:07 -0800177 codec_timer_->AddTiming(decode_time_ms, now_ms);
Per327d8ba2015-11-10 14:00:27 +0100178 assert(decode_time_ms >= 0);
179 last_decode_ms_ = decode_time_ms;
asapersson@webrtc.orgf2447602014-12-09 14:13:26 +0000180
181 // Update stats.
182 ++num_decoded_frames_;
183 if (num_decoded_frames_ == 1) {
184 first_decoded_frame_ms_ = now_ms;
185 }
186 int time_until_rendering_ms = render_time_ms - render_delay_ms_ - now_ms;
187 if (time_until_rendering_ms < 0) {
188 sum_missed_render_deadline_ms_ += -time_until_rendering_ms;
189 ++num_delayed_decoded_frames_;
190 }
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000191 return 0;
niklase@google.com470e71d2011-07-07 08:21:25 +0000192}
193
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000194void VCMTiming::IncomingTimestamp(uint32_t time_stamp, int64_t now_ms) {
195 CriticalSectionScoped cs(crit_sect_);
stefan@webrtc.org34c5da62014-04-11 14:08:35 +0000196 ts_extrapolator_->Update(now_ms, time_stamp);
niklase@google.com470e71d2011-07-07 08:21:25 +0000197}
198
philipel5908c712015-12-21 08:23:20 -0800199int64_t VCMTiming::RenderTimeMs(uint32_t frame_timestamp,
200 int64_t now_ms) const {
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000201 CriticalSectionScoped cs(crit_sect_);
202 const int64_t render_time_ms = RenderTimeMsInternal(frame_timestamp, now_ms);
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000203 return render_time_ms;
niklase@google.com470e71d2011-07-07 08:21:25 +0000204}
205
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000206int64_t VCMTiming::RenderTimeMsInternal(uint32_t frame_timestamp,
207 int64_t now_ms) const {
208 int64_t estimated_complete_time_ms =
philipel5908c712015-12-21 08:23:20 -0800209 ts_extrapolator_->ExtrapolateLocalTime(frame_timestamp);
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000210 if (estimated_complete_time_ms == -1) {
211 estimated_complete_time_ms = now_ms;
212 }
mikhal@webrtc.org6faba6e2013-04-30 15:39:34 +0000213
mikhal@webrtc.orgadc64a72013-05-30 16:20:18 +0000214 // Make sure that we have at least the playout delay.
215 uint32_t actual_delay = std::max(current_delay_ms_, min_playout_delay_ms_);
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000216 return estimated_complete_time_ms + actual_delay;
niklase@google.com470e71d2011-07-07 08:21:25 +0000217}
218
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000219// Must be called from inside a critical section.
magjed4bf0c712016-03-11 02:15:07 -0800220int64_t VCMTiming::RequiredDecodeTimeMs() const {
221 const int64_t decode_time_ms = codec_timer_->RequiredDecodeTimeMs();
stefan@webrtc.org34c5da62014-04-11 14:08:35 +0000222 assert(decode_time_ms >= 0);
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000223 return decode_time_ms;
niklase@google.com470e71d2011-07-07 08:21:25 +0000224}
225
philipel5908c712015-12-21 08:23:20 -0800226uint32_t VCMTiming::MaxWaitingTime(int64_t render_time_ms,
227 int64_t now_ms) const {
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000228 CriticalSectionScoped cs(crit_sect_);
niklase@google.com470e71d2011-07-07 08:21:25 +0000229
philipel5908c712015-12-21 08:23:20 -0800230 const int64_t max_wait_time_ms =
magjed4bf0c712016-03-11 02:15:07 -0800231 render_time_ms - now_ms - RequiredDecodeTimeMs() - render_delay_ms_;
niklase@google.com470e71d2011-07-07 08:21:25 +0000232
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000233 if (max_wait_time_ms < 0) {
234 return 0;
235 }
236 return static_cast<uint32_t>(max_wait_time_ms);
niklase@google.com470e71d2011-07-07 08:21:25 +0000237}
238
philipel5908c712015-12-21 08:23:20 -0800239bool VCMTiming::EnoughTimeToDecode(
240 uint32_t available_processing_time_ms) const {
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000241 CriticalSectionScoped cs(crit_sect_);
magjed4bf0c712016-03-11 02:15:07 -0800242 int64_t required_decode_time_ms = RequiredDecodeTimeMs();
243 if (required_decode_time_ms < 0) {
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000244 // Haven't decoded any frames yet, try decoding one to get an estimate
245 // of the decode time.
246 return true;
magjed4bf0c712016-03-11 02:15:07 -0800247 } else if (required_decode_time_ms == 0) {
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000248 // Decode time is less than 1, set to 1 for now since
249 // we don't have any better precision. Count ticks later?
magjed4bf0c712016-03-11 02:15:07 -0800250 required_decode_time_ms = 1;
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000251 }
magjed4bf0c712016-03-11 02:15:07 -0800252 return static_cast<int64_t>(available_processing_time_ms) -
253 required_decode_time_ms >
philipel5908c712015-12-21 08:23:20 -0800254 0;
niklase@google.com470e71d2011-07-07 08:21:25 +0000255}
256
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000257uint32_t VCMTiming::TargetVideoDelay() const {
258 CriticalSectionScoped cs(crit_sect_);
259 return TargetDelayInternal();
niklase@google.com470e71d2011-07-07 08:21:25 +0000260}
261
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000262uint32_t VCMTiming::TargetDelayInternal() const {
mikhal@webrtc.orgadc64a72013-05-30 16:20:18 +0000263 return std::max(min_playout_delay_ms_,
magjed4bf0c712016-03-11 02:15:07 -0800264 jitter_delay_ms_ +
265 static_cast<uint32_t>(RequiredDecodeTimeMs()) +
266 render_delay_ms_);
niklase@google.com470e71d2011-07-07 08:21:25 +0000267}
268
fischman@webrtc.org37bb4972013-10-23 23:59:45 +0000269void VCMTiming::GetTimings(int* decode_ms,
270 int* max_decode_ms,
271 int* current_delay_ms,
272 int* target_delay_ms,
273 int* jitter_buffer_ms,
274 int* min_playout_delay_ms,
275 int* render_delay_ms) const {
276 CriticalSectionScoped cs(crit_sect_);
277 *decode_ms = last_decode_ms_;
magjed4bf0c712016-03-11 02:15:07 -0800278 *max_decode_ms = static_cast<int>(RequiredDecodeTimeMs());
fischman@webrtc.org37bb4972013-10-23 23:59:45 +0000279 *current_delay_ms = current_delay_ms_;
280 *target_delay_ms = TargetDelayInternal();
281 *jitter_buffer_ms = jitter_delay_ms_;
282 *min_playout_delay_ms = min_playout_delay_ms_;
283 *render_delay_ms = render_delay_ms_;
284}
285
mikhal@webrtc.org2eaf98b2013-05-21 17:58:43 +0000286} // namespace webrtc