blob: fe05b8682562ce1354efe021c73ca5c8cb80d883 [file] [log] [blame]
niklase@google.com470e71d2011-07-07 08:21:25 +00001/*
stefan@webrtc.org91c63082012-01-31 10:49:08 +00002 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
niklase@google.com470e71d2011-07-07 08:21:25 +00003 *
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/receiver.h"
niklase@google.com470e71d2011-07-07 08:21:25 +000012
13#include <assert.h>
14
pbos@webrtc.org3f655aa2014-03-18 11:10:11 +000015#include <cstdlib>
16
pbos854e84c2015-11-16 16:39:06 -080017#include "webrtc/base/logging.h"
tommie4f96502015-10-20 23:00:48 -070018#include "webrtc/base/trace_event.h"
Henrik Kjellander2557b862015-11-18 22:00:21 +010019#include "webrtc/modules/video_coding/encoded_frame.h"
20#include "webrtc/modules/video_coding/internal_defines.h"
21#include "webrtc/modules/video_coding/media_opt_util.h"
Henrik Kjellander98f53512015-10-28 18:17:40 +010022#include "webrtc/system_wrappers/include/clock.h"
stefan@webrtc.org91c63082012-01-31 10:49:08 +000023
niklase@google.com470e71d2011-07-07 08:21:25 +000024namespace webrtc {
25
mikhal@webrtc.orgef9f76a2013-02-15 23:22:18 +000026enum { kMaxReceiverDelayMs = 10000 };
27
stefan@webrtc.org1ea4b502013-01-07 08:49:41 +000028VCMReceiver::VCMReceiver(VCMTiming* timing,
stefan@webrtc.orga678a3b2013-01-21 07:42:11 +000029 Clock* clock,
Wan-Teh Chang92d94892015-05-28 13:36:06 -070030 EventFactory* event_factory)
Qiang Chend4cec152015-06-19 09:17:00 -070031 : VCMReceiver(timing,
32 clock,
33 rtc::scoped_ptr<EventWrapper>(event_factory->CreateEvent()),
34 rtc::scoped_ptr<EventWrapper>(event_factory->CreateEvent())) {
35}
36
37VCMReceiver::VCMReceiver(VCMTiming* timing,
38 Clock* clock,
39 rtc::scoped_ptr<EventWrapper> receiver_event,
40 rtc::scoped_ptr<EventWrapper> jitter_buffer_event)
stefan@webrtc.org1ea4b502013-01-07 08:49:41 +000041 : crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
stefan@webrtc.org1ea4b502013-01-07 08:49:41 +000042 clock_(clock),
Qiang Chend4cec152015-06-19 09:17:00 -070043 jitter_buffer_(clock_, jitter_buffer_event.Pass()),
stefan@webrtc.org1ea4b502013-01-07 08:49:41 +000044 timing_(timing),
Qiang Chend4cec152015-06-19 09:17:00 -070045 render_wait_event_(receiver_event.Pass()),
Peter Boström5464a6e2015-04-21 16:35:50 +020046 max_video_delay_ms_(kMaxVideoDelayMs) {
47 Reset();
48}
niklase@google.com470e71d2011-07-07 08:21:25 +000049
stefan@webrtc.org1ea4b502013-01-07 08:49:41 +000050VCMReceiver::~VCMReceiver() {
stefan@webrtc.org2baf5f52013-03-13 08:46:25 +000051 render_wait_event_->Set();
stefan@webrtc.org1ea4b502013-01-07 08:49:41 +000052 delete crit_sect_;
niklase@google.com470e71d2011-07-07 08:21:25 +000053}
54
stefan@webrtc.org1ea4b502013-01-07 08:49:41 +000055void VCMReceiver::Reset() {
56 CriticalSectionScoped cs(crit_sect_);
57 if (!jitter_buffer_.Running()) {
58 jitter_buffer_.Start();
59 } else {
60 jitter_buffer_.Flush();
61 }
henrik.lundin@webrtc.orgbaf6db52011-11-02 18:58:39 +000062}
63
pkasting@chromium.org16825b12015-01-12 21:51:21 +000064void VCMReceiver::UpdateRtt(int64_t rtt) {
stefan@webrtc.org1ea4b502013-01-07 08:49:41 +000065 jitter_buffer_.UpdateRtt(rtt);
66}
67
stefan@webrtc.orga64300a2013-03-04 15:24:40 +000068int32_t VCMReceiver::InsertPacket(const VCMPacket& packet,
69 uint16_t frame_width,
stefan@webrtc.org1ea4b502013-01-07 08:49:41 +000070 uint16_t frame_height) {
stefan@webrtc.org3417eb42013-05-21 15:25:53 +000071 // Insert the packet into the jitter buffer. The packet can either be empty or
72 // contain media at this point.
73 bool retransmitted = false;
74 const VCMFrameBufferEnum ret = jitter_buffer_.InsertPacket(packet,
75 &retransmitted);
76 if (ret == kOldPacket) {
niklase@google.com470e71d2011-07-07 08:21:25 +000077 return VCM_OK;
stefan@webrtc.org3417eb42013-05-21 15:25:53 +000078 } else if (ret == kFlushIndicator) {
79 return VCM_FLUSH_INDICATOR;
80 } else if (ret < 0) {
stefan@webrtc.org3417eb42013-05-21 15:25:53 +000081 return VCM_JITTER_BUFFER_ERROR;
stefan@webrtc.org1ea4b502013-01-07 08:49:41 +000082 }
stefan@webrtc.org3417eb42013-05-21 15:25:53 +000083 if (ret == kCompleteSession && !retransmitted) {
84 // We don't want to include timestamps which have suffered from
85 // retransmission here, since we compensate with extra retransmission
86 // delay within the jitter estimate.
87 timing_->IncomingTimestamp(packet.timestamp, clock_->TimeInMilliseconds());
88 }
stefan@webrtc.org1ea4b502013-01-07 08:49:41 +000089 return VCM_OK;
niklase@google.com470e71d2011-07-07 08:21:25 +000090}
91
pbos@webrtc.org4dd40d62015-02-17 13:22:43 +000092void VCMReceiver::TriggerDecoderShutdown() {
93 jitter_buffer_.Stop();
94 render_wait_event_->Set();
95}
96
pbos@webrtc.org4f16c872014-11-24 09:06:48 +000097VCMEncodedFrame* VCMReceiver::FrameForDecoding(uint16_t max_wait_time_ms,
98 int64_t& next_render_time_ms,
perkj796cfaf2015-12-10 09:27:38 -080099 bool prefer_late_decoding) {
stefan@webrtc.orga678a3b2013-01-21 07:42:11 +0000100 const int64_t start_time_ms = clock_->TimeInMilliseconds();
mikhal@webrtc.org759b0412013-05-07 16:36:00 +0000101 uint32_t frame_timestamp = 0;
102 // Exhaust wait time to get a complete frame for decoding.
103 bool found_frame = jitter_buffer_.NextCompleteTimestamp(
104 max_wait_time_ms, &frame_timestamp);
105
pbos@webrtc.org4f16c872014-11-24 09:06:48 +0000106 if (!found_frame)
107 found_frame = jitter_buffer_.NextMaybeIncompleteTimestamp(&frame_timestamp);
mikhal@webrtc.org759b0412013-05-07 16:36:00 +0000108
pbos@webrtc.org4f16c872014-11-24 09:06:48 +0000109 if (!found_frame)
stefan@webrtc.org4ce19b12013-05-06 13:16:51 +0000110 return NULL;
mikhal@webrtc.orgd3cd5652013-05-03 17:54:18 +0000111
mikhal@webrtc.org759b0412013-05-07 16:36:00 +0000112 // We have a frame - Set timing and render timestamp.
mikhal@webrtc.orgadc64a72013-05-30 16:20:18 +0000113 timing_->SetJitterDelay(jitter_buffer_.EstimatedJitterMs());
mikhal@webrtc.org759b0412013-05-07 16:36:00 +0000114 const int64_t now_ms = clock_->TimeInMilliseconds();
115 timing_->UpdateCurrentDelay(frame_timestamp);
116 next_render_time_ms = timing_->RenderTimeMs(frame_timestamp, now_ms);
117 // Check render timing.
118 bool timing_error = false;
119 // Assume that render timing errors are due to changes in the video stream.
120 if (next_render_time_ms < 0) {
121 timing_error = true;
pbos@webrtc.orgb5f30292014-03-13 08:53:39 +0000122 } else if (std::abs(next_render_time_ms - now_ms) > max_video_delay_ms_) {
stefan@webrtc.org34c5da62014-04-11 14:08:35 +0000123 int frame_delay = static_cast<int>(std::abs(next_render_time_ms - now_ms));
124 LOG(LS_WARNING) << "A frame about to be decoded is out of the configured "
125 << "delay bounds (" << frame_delay << " > "
126 << max_video_delay_ms_
127 << "). Resetting the video jitter buffer.";
mikhal@webrtc.org759b0412013-05-07 16:36:00 +0000128 timing_error = true;
129 } else if (static_cast<int>(timing_->TargetVideoDelay()) >
130 max_video_delay_ms_) {
stefan@webrtc.org34c5da62014-04-11 14:08:35 +0000131 LOG(LS_WARNING) << "The video target delay has grown larger than "
132 << max_video_delay_ms_ << " ms. Resetting jitter buffer.";
mikhal@webrtc.org759b0412013-05-07 16:36:00 +0000133 timing_error = true;
stefan@webrtc.org4ce19b12013-05-06 13:16:51 +0000134 }
135
mikhal@webrtc.org759b0412013-05-07 16:36:00 +0000136 if (timing_error) {
137 // Timing error => reset timing and flush the jitter buffer.
138 jitter_buffer_.Flush();
stefan@webrtc.org9f557c12013-05-17 12:55:07 +0000139 timing_->Reset();
mikhal@webrtc.org759b0412013-05-07 16:36:00 +0000140 return NULL;
141 }
142
perkj796cfaf2015-12-10 09:27:38 -0800143 if (prefer_late_decoding) {
mikhal@webrtc.org759b0412013-05-07 16:36:00 +0000144 // Decode frame as close as possible to the render timestamp.
mikhal@webrtc.org759b0412013-05-07 16:36:00 +0000145 const int32_t available_wait_time = max_wait_time_ms -
146 static_cast<int32_t>(clock_->TimeInMilliseconds() - start_time_ms);
147 uint16_t new_max_wait_time = static_cast<uint16_t>(
148 VCM_MAX(available_wait_time, 0));
149 uint32_t wait_time_ms = timing_->MaxWaitingTime(
150 next_render_time_ms, clock_->TimeInMilliseconds());
151 if (new_max_wait_time < wait_time_ms) {
152 // We're not allowed to wait until the frame is supposed to be rendered,
153 // waiting as long as we're allowed to avoid busy looping, and then return
154 // NULL. Next call to this function might return the frame.
Niklas Enbomb4c5eaa2015-06-03 09:34:25 -0700155 render_wait_event_->Wait(new_max_wait_time);
mikhal@webrtc.org759b0412013-05-07 16:36:00 +0000156 return NULL;
157 }
158 // Wait until it's time to render.
159 render_wait_event_->Wait(wait_time_ms);
160 }
161
162 // Extract the frame from the jitter buffer and set the render time.
163 VCMEncodedFrame* frame = jitter_buffer_.ExtractAndSetDecode(frame_timestamp);
mikhal@webrtc.org8f86cc82013-05-07 18:05:21 +0000164 if (frame == NULL) {
165 return NULL;
166 }
mikhal@webrtc.org759b0412013-05-07 16:36:00 +0000167 frame->SetRenderTime(next_render_time_ms);
hclam@chromium.org1a7b9b92013-07-08 21:31:18 +0000168 TRACE_EVENT_ASYNC_STEP1("webrtc", "Video", frame->TimeStamp(),
169 "SetRenderTS", "render_time", next_render_time_ms);
mikhal@webrtc.org759b0412013-05-07 16:36:00 +0000170 if (!frame->Complete()) {
171 // Update stats for incomplete frames.
stefan@webrtc.org4ce19b12013-05-06 13:16:51 +0000172 bool retransmitted = false;
173 const int64_t last_packet_time_ms =
mikhal@webrtc.org759b0412013-05-07 16:36:00 +0000174 jitter_buffer_.LastPacketTime(frame, &retransmitted);
stefan@webrtc.org4ce19b12013-05-06 13:16:51 +0000175 if (last_packet_time_ms >= 0 && !retransmitted) {
176 // We don't want to include timestamps which have suffered from
177 // retransmission here, since we compensate with extra retransmission
178 // delay within the jitter estimate.
mikhal@webrtc.org759b0412013-05-07 16:36:00 +0000179 timing_->IncomingTimestamp(frame_timestamp, last_packet_time_ms);
stefan@webrtc.org4ce19b12013-05-06 13:16:51 +0000180 }
stefan@webrtc.org1ea4b502013-01-07 08:49:41 +0000181 }
182 return frame;
niklase@google.com470e71d2011-07-07 08:21:25 +0000183}
184
stefan@webrtc.org1ea4b502013-01-07 08:49:41 +0000185void VCMReceiver::ReleaseFrame(VCMEncodedFrame* frame) {
186 jitter_buffer_.ReleaseFrame(frame);
niklase@google.com470e71d2011-07-07 08:21:25 +0000187}
188
stefan@webrtc.org1ea4b502013-01-07 08:49:41 +0000189void VCMReceiver::ReceiveStatistics(uint32_t* bitrate,
190 uint32_t* framerate) {
191 assert(bitrate);
192 assert(framerate);
193 jitter_buffer_.IncomingRateStatistics(framerate, bitrate);
niklase@google.com470e71d2011-07-07 08:21:25 +0000194}
195
stefan@webrtc.org1ea4b502013-01-07 08:49:41 +0000196uint32_t VCMReceiver::DiscardedPackets() const {
197 return jitter_buffer_.num_discarded_packets();
niklase@google.com470e71d2011-07-07 08:21:25 +0000198}
199
stefan@webrtc.orga64300a2013-03-04 15:24:40 +0000200void VCMReceiver::SetNackMode(VCMNackMode nackMode,
pkasting@chromium.org16825b12015-01-12 21:51:21 +0000201 int64_t low_rtt_nack_threshold_ms,
202 int64_t high_rtt_nack_threshold_ms) {
stefan@webrtc.org1ea4b502013-01-07 08:49:41 +0000203 CriticalSectionScoped cs(crit_sect_);
204 // Default to always having NACK enabled in hybrid mode.
stefan@webrtc.orga64300a2013-03-04 15:24:40 +0000205 jitter_buffer_.SetNackMode(nackMode, low_rtt_nack_threshold_ms,
206 high_rtt_nack_threshold_ms);
niklase@google.com470e71d2011-07-07 08:21:25 +0000207}
208
stefan@webrtc.orgbecf9c82013-02-01 15:09:57 +0000209void VCMReceiver::SetNackSettings(size_t max_nack_list_size,
stefan@webrtc.orgef144882013-05-07 19:16:33 +0000210 int max_packet_age_to_nack,
211 int max_incomplete_time_ms) {
stefan@webrtc.orgbecf9c82013-02-01 15:09:57 +0000212 jitter_buffer_.SetNackSettings(max_nack_list_size,
stefan@webrtc.orgef144882013-05-07 19:16:33 +0000213 max_packet_age_to_nack,
214 max_incomplete_time_ms);
stefan@webrtc.orgbecf9c82013-02-01 15:09:57 +0000215}
216
stefan@webrtc.org1ea4b502013-01-07 08:49:41 +0000217VCMNackMode VCMReceiver::NackMode() const {
218 CriticalSectionScoped cs(crit_sect_);
219 return jitter_buffer_.nack_mode();
stefan@webrtc.org791eec72011-10-11 07:53:43 +0000220}
221
Wan-Teh Changb1825a42015-06-03 15:03:35 -0700222std::vector<uint16_t> VCMReceiver::NackList(bool* request_key_frame) {
223 return jitter_buffer_.GetNackList(request_key_frame);
niklase@google.com470e71d2011-07-07 08:21:25 +0000224}
225
mikhal@webrtc.orgdbf6a812013-08-21 20:40:47 +0000226void VCMReceiver::SetDecodeErrorMode(VCMDecodeErrorMode decode_error_mode) {
227 jitter_buffer_.SetDecodeErrorMode(decode_error_mode);
mikhal@webrtc.orgdc3cd212013-04-25 20:27:04 +0000228}
229
agalusza@google.coma7e360e2013-08-01 03:15:08 +0000230VCMDecodeErrorMode VCMReceiver::DecodeErrorMode() const {
agalusza@google.coma7e360e2013-08-01 03:15:08 +0000231 return jitter_buffer_.decode_error_mode();
mikhal@webrtc.orgdc3cd212013-04-25 20:27:04 +0000232}
233
mikhal@webrtc.orgef9f76a2013-02-15 23:22:18 +0000234int VCMReceiver::SetMinReceiverDelay(int desired_delay_ms) {
235 CriticalSectionScoped cs(crit_sect_);
236 if (desired_delay_ms < 0 || desired_delay_ms > kMaxReceiverDelayMs) {
237 return -1;
238 }
mikhal@webrtc.orgef9f76a2013-02-15 23:22:18 +0000239 max_video_delay_ms_ = desired_delay_ms + kMaxVideoDelayMs;
mikhal@webrtc.orgdbd6a6d2013-04-17 16:23:22 +0000240 // Initializing timing to the desired delay.
mikhal@webrtc.orgadc64a72013-05-30 16:20:18 +0000241 timing_->set_min_playout_delay(desired_delay_ms);
mikhal@webrtc.orgef9f76a2013-02-15 23:22:18 +0000242 return 0;
243}
244
mikhal@webrtc.org381da4b2013-04-25 21:45:29 +0000245int VCMReceiver::RenderBufferSizeMs() {
mikhal@webrtc.org759b0412013-05-07 16:36:00 +0000246 uint32_t timestamp_start = 0u;
247 uint32_t timestamp_end = 0u;
248 // Render timestamps are computed just prior to decoding. Therefore this is
249 // only an estimate based on frames' timestamps and current timing state.
250 jitter_buffer_.RenderBufferSize(&timestamp_start, &timestamp_end);
251 if (timestamp_start == timestamp_end) {
252 return 0;
253 }
254 // Update timing.
255 const int64_t now_ms = clock_->TimeInMilliseconds();
mikhal@webrtc.orgadc64a72013-05-30 16:20:18 +0000256 timing_->SetJitterDelay(jitter_buffer_.EstimatedJitterMs());
mikhal@webrtc.org759b0412013-05-07 16:36:00 +0000257 // Get render timestamps.
258 uint32_t render_start = timing_->RenderTimeMs(timestamp_start, now_ms);
259 uint32_t render_end = timing_->RenderTimeMs(timestamp_end, now_ms);
260 return render_end - render_start;
mikhal@webrtc.org381da4b2013-04-25 21:45:29 +0000261}
pbos@webrtc.orgce4e9a32014-12-18 13:50:16 +0000262
pbos@webrtc.org55707692014-12-19 15:45:03 +0000263void VCMReceiver::RegisterStatsCallback(
264 VCMReceiveStatisticsCallback* callback) {
265 jitter_buffer_.RegisterStatsCallback(callback);
pbos@webrtc.orgce4e9a32014-12-18 13:50:16 +0000266}
267
stefan@webrtc.org1ea4b502013-01-07 08:49:41 +0000268} // namespace webrtc