blob: 129a1b5c45048fced43cb7ab1492aaa6d28f66ac [file] [log] [blame]
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +00001/*
2 * Copyright (c) 2013 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
pbosba8c15b2015-07-14 09:36:34 -070011#include "webrtc/base/checks.h"
pbos854e84c2015-11-16 16:39:06 -080012#include "webrtc/base/logging.h"
tommie4f96502015-10-20 23:00:48 -070013#include "webrtc/base/trace_event.h"
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000014#include "webrtc/common_types.h"
15#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
Henrik Kjellander2557b862015-11-18 22:00:21 +010016#include "webrtc/modules/video_coding/include/video_codec_interface.h"
17#include "webrtc/modules/video_coding/encoded_frame.h"
18#include "webrtc/modules/video_coding/jitter_buffer.h"
19#include "webrtc/modules/video_coding/packet.h"
20#include "webrtc/modules/video_coding/video_coding_impl.h"
Henrik Kjellander98f53512015-10-28 18:17:40 +010021#include "webrtc/system_wrappers/include/clock.h"
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000022
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000023namespace webrtc {
24namespace vcm {
25
philipel83f831a2016-03-12 03:30:23 -080026VideoReceiver::VideoReceiver(Clock* clock,
27 EventFactory* event_factory,
sprang3911c262016-04-15 01:24:14 -070028 EncodedImageCallback* pre_decode_image_callback,
philipel721d4022016-12-15 07:10:57 -080029 VCMTiming* timing,
philipel83f831a2016-03-12 03:30:23 -080030 NackSender* nack_sender,
31 KeyFrameRequestSender* keyframe_request_sender)
stefan@webrtc.org34c5da62014-04-11 14:08:35 +000032 : clock_(clock),
philipel721d4022016-12-15 07:10:57 -080033 _timing(timing),
34 _receiver(_timing,
philipel83f831a2016-03-12 03:30:23 -080035 clock_,
36 event_factory,
37 nack_sender,
38 keyframe_request_sender),
philipel721d4022016-12-15 07:10:57 -080039 _decodedFrameCallback(_timing, clock_),
sprang3911c262016-04-15 01:24:14 -070040 _frameTypeCallback(nullptr),
41 _receiveStatsCallback(nullptr),
42 _decoderTimingCallback(nullptr),
43 _packetRequestCallback(nullptr),
sprang3911c262016-04-15 01:24:14 -070044 _decoder(nullptr),
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000045 _frameFromFile(),
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000046 _scheduleKeyRequest(false),
Peter Boströmed3277b2016-02-02 15:40:04 +010047 drop_frames_until_keyframe_(false),
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000048 max_nack_list_size_(0),
perkjf5b2e512016-07-05 08:34:04 -070049 _codecDataBase(nullptr),
sprang3911c262016-04-15 01:24:14 -070050 pre_decode_image_callback_(pre_decode_image_callback),
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000051 _receiveStatsTimer(1000, clock_),
52 _retransmissionTimer(10, clock_),
sprang3911c262016-04-15 01:24:14 -070053 _keyRequestTimer(500, clock_) {}
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000054
sprang3911c262016-04-15 01:24:14 -070055VideoReceiver::~VideoReceiver() {}
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000056
pbosa26ac922016-02-25 04:50:01 -080057void VideoReceiver::Process() {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000058 // Receive-side statistics
59 if (_receiveStatsTimer.TimeUntilProcess() == 0) {
60 _receiveStatsTimer.Processed();
sprang3911c262016-04-15 01:24:14 -070061 rtc::CritScope cs(&process_crit_);
62 if (_receiveStatsCallback != nullptr) {
philipel27378f32017-01-27 02:19:05 -080063 uint32_t bitRate;
64 uint32_t frameRate;
65 _receiver.ReceiveStatistics(&bitRate, &frameRate);
66 _receiveStatsCallback->OnReceiveRatesUpdated(bitRate, frameRate);
67 }
68
69 if (_decoderTimingCallback != nullptr) {
70 int decode_ms;
71 int max_decode_ms;
72 int current_delay_ms;
73 int target_delay_ms;
74 int jitter_buffer_ms;
75 int min_playout_delay_ms;
76 int render_delay_ms;
77 if (_timing->GetTimings(&decode_ms, &max_decode_ms, &current_delay_ms,
78 &target_delay_ms, &jitter_buffer_ms,
79 &min_playout_delay_ms, &render_delay_ms)) {
80 _decoderTimingCallback->OnDecoderTiming(
81 decode_ms, max_decode_ms, current_delay_ms, target_delay_ms,
82 jitter_buffer_ms, min_playout_delay_ms, render_delay_ms);
83 }
fischman@webrtc.org37bb4972013-10-23 23:59:45 +000084 }
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000085 }
86
87 // Key frame requests
88 if (_keyRequestTimer.TimeUntilProcess() == 0) {
89 _keyRequestTimer.Processed();
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +000090 bool request_key_frame = false;
91 {
sprang3911c262016-04-15 01:24:14 -070092 rtc::CritScope cs(&process_crit_);
93 request_key_frame = _scheduleKeyRequest && _frameTypeCallback != nullptr;
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +000094 }
pbosa26ac922016-02-25 04:50:01 -080095 if (request_key_frame)
96 RequestKeyFrame();
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000097 }
98
99 // Packet retransmission requests
100 // TODO(holmer): Add API for changing Process interval and make sure it's
101 // disabled when NACK is off.
102 if (_retransmissionTimer.TimeUntilProcess() == 0) {
103 _retransmissionTimer.Processed();
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +0000104 bool callback_registered = false;
105 uint16_t length;
106 {
sprang3911c262016-04-15 01:24:14 -0700107 rtc::CritScope cs(&process_crit_);
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +0000108 length = max_nack_list_size_;
sprang3911c262016-04-15 01:24:14 -0700109 callback_registered = _packetRequestCallback != nullptr;
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +0000110 }
111 if (callback_registered && length > 0) {
Wan-Teh Changb1825a42015-06-03 15:03:35 -0700112 // Collect sequence numbers from the default receiver.
113 bool request_key_frame = false;
114 std::vector<uint16_t> nackList = _receiver.NackList(&request_key_frame);
115 int32_t ret = VCM_OK;
116 if (request_key_frame) {
117 ret = RequestKeyFrame();
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000118 }
Wan-Teh Changb1825a42015-06-03 15:03:35 -0700119 if (ret == VCM_OK && !nackList.empty()) {
sprang3911c262016-04-15 01:24:14 -0700120 rtc::CritScope cs(&process_crit_);
121 if (_packetRequestCallback != nullptr) {
Wan-Teh Changb1825a42015-06-03 15:03:35 -0700122 _packetRequestCallback->ResendPackets(&nackList[0], nackList.size());
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +0000123 }
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000124 }
125 }
126 }
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000127}
128
pkasting@chromium.org0b1534c2014-12-15 22:09:40 +0000129int64_t VideoReceiver::TimeUntilNextProcess() {
130 int64_t timeUntilNextProcess = _receiveStatsTimer.TimeUntilProcess();
pbos@webrtc.org4f16c872014-11-24 09:06:48 +0000131 if (_receiver.NackMode() != kNoNack) {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000132 // We need a Process call more often if we are relying on
133 // retransmissions
134 timeUntilNextProcess =
135 VCM_MIN(timeUntilNextProcess, _retransmissionTimer.TimeUntilProcess());
136 }
137 timeUntilNextProcess =
138 VCM_MIN(timeUntilNextProcess, _keyRequestTimer.TimeUntilProcess());
139
140 return timeUntilNextProcess;
141}
142
pkasting@chromium.org16825b12015-01-12 21:51:21 +0000143int32_t VideoReceiver::SetReceiveChannelParameters(int64_t rtt) {
sprang3911c262016-04-15 01:24:14 -0700144 rtc::CritScope cs(&receive_crit_);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000145 _receiver.UpdateRtt(rtt);
146 return 0;
147}
148
149// Enable or disable a video protection method.
150// Note: This API should be deprecated, as it does not offer a distinction
151// between the protection method and decoding with or without errors. If such a
152// behavior is desired, use the following API: SetReceiverRobustnessMode.
153int32_t VideoReceiver::SetVideoProtection(VCMVideoProtection videoProtection,
154 bool enable) {
155 // By default, do not decode with errors.
156 _receiver.SetDecodeErrorMode(kNoErrors);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000157 switch (videoProtection) {
pbosba8c15b2015-07-14 09:36:34 -0700158 case kProtectionNack: {
henrikg91d6ede2015-09-17 00:24:34 -0700159 RTC_DCHECK(enable);
pbosba8c15b2015-07-14 09:36:34 -0700160 _receiver.SetNackMode(kNack, -1, -1);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000161 break;
162 }
163
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000164 case kProtectionNackFEC: {
sprang3911c262016-04-15 01:24:14 -0700165 rtc::CritScope cs(&receive_crit_);
henrikg91d6ede2015-09-17 00:24:34 -0700166 RTC_DCHECK(enable);
philipelae284082016-05-09 12:14:29 +0200167 _receiver.SetNackMode(kNack,
168 media_optimization::kLowRttNackMs,
169 media_optimization::kMaxRttDelayThreshold);
pbosba8c15b2015-07-14 09:36:34 -0700170 _receiver.SetDecodeErrorMode(kNoErrors);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000171 break;
172 }
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000173 case kProtectionFEC:
pbos@webrtc.orgcade82c2015-03-12 10:39:24 +0000174 case kProtectionNone:
pbosba8c15b2015-07-14 09:36:34 -0700175 // No receiver-side protection.
henrikg91d6ede2015-09-17 00:24:34 -0700176 RTC_DCHECK(enable);
pbosba8c15b2015-07-14 09:36:34 -0700177 _receiver.SetNackMode(kNoNack, -1, -1);
178 _receiver.SetDecodeErrorMode(kWithErrors);
pbos@webrtc.orgcade82c2015-03-12 10:39:24 +0000179 break;
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000180 }
181 return VCM_OK;
182}
183
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000184// Register a receive callback. Will be called whenever there is a new frame
185// ready for rendering.
186int32_t VideoReceiver::RegisterReceiveCallback(
187 VCMReceiveCallback* receiveCallback) {
sprang3911c262016-04-15 01:24:14 -0700188 rtc::CritScope cs(&receive_crit_);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000189 _decodedFrameCallback.SetUserReceiveCallback(receiveCallback);
190 return VCM_OK;
191}
192
193int32_t VideoReceiver::RegisterReceiveStatisticsCallback(
194 VCMReceiveStatisticsCallback* receiveStats) {
sprang3911c262016-04-15 01:24:14 -0700195 rtc::CritScope cs(&process_crit_);
pbos@webrtc.org55707692014-12-19 15:45:03 +0000196 _receiver.RegisterStatsCallback(receiveStats);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000197 _receiveStatsCallback = receiveStats;
198 return VCM_OK;
199}
200
fischman@webrtc.org37bb4972013-10-23 23:59:45 +0000201int32_t VideoReceiver::RegisterDecoderTimingCallback(
202 VCMDecoderTimingCallback* decoderTiming) {
sprang3911c262016-04-15 01:24:14 -0700203 rtc::CritScope cs(&process_crit_);
fischman@webrtc.org37bb4972013-10-23 23:59:45 +0000204 _decoderTimingCallback = decoderTiming;
205 return VCM_OK;
206}
207
perkj796cfaf2015-12-10 09:27:38 -0800208// Register an externally defined decoder object.
Peter Boström795dbe42015-11-27 14:09:07 +0100209void VideoReceiver::RegisterExternalDecoder(VideoDecoder* externalDecoder,
perkj796cfaf2015-12-10 09:27:38 -0800210 uint8_t payloadType) {
sprang3911c262016-04-15 01:24:14 -0700211 rtc::CritScope cs(&receive_crit_);
212 if (externalDecoder == nullptr) {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000213 // Make sure the VCM updates the decoder next time it decodes.
sprang3911c262016-04-15 01:24:14 -0700214 _decoder = nullptr;
Peter Boström795dbe42015-11-27 14:09:07 +0100215 RTC_CHECK(_codecDataBase.DeregisterExternalDecoder(payloadType));
Peter Boström395c7c62015-11-27 15:23:12 +0100216 return;
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000217 }
perkj796cfaf2015-12-10 09:27:38 -0800218 _codecDataBase.RegisterExternalDecoder(externalDecoder, payloadType);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000219}
220
221// Register a frame type request callback.
222int32_t VideoReceiver::RegisterFrameTypeCallback(
223 VCMFrameTypeCallback* frameTypeCallback) {
sprang3911c262016-04-15 01:24:14 -0700224 rtc::CritScope cs(&process_crit_);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000225 _frameTypeCallback = frameTypeCallback;
226 return VCM_OK;
227}
228
229int32_t VideoReceiver::RegisterPacketRequestCallback(
230 VCMPacketRequestCallback* callback) {
sprang3911c262016-04-15 01:24:14 -0700231 rtc::CritScope cs(&process_crit_);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000232 _packetRequestCallback = callback;
233 return VCM_OK;
234}
235
pbos@webrtc.org4dd40d62015-02-17 13:22:43 +0000236void VideoReceiver::TriggerDecoderShutdown() {
237 _receiver.TriggerDecoderShutdown();
238}
239
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000240// Decode next frame, blocking.
241// Should be called as often as possible to get the most out of the decoder.
242int32_t VideoReceiver::Decode(uint16_t maxWaitTimeMs) {
perkj796cfaf2015-12-10 09:27:38 -0800243 bool prefer_late_decoding = false;
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000244 {
sprang3911c262016-04-15 01:24:14 -0700245 rtc::CritScope cs(&receive_crit_);
perkj796cfaf2015-12-10 09:27:38 -0800246 prefer_late_decoding = _codecDataBase.PrefersLateDecoding();
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000247 }
248
Johan Ahlers31b2ec42016-06-28 13:32:49 +0200249 VCMEncodedFrame* frame =
250 _receiver.FrameForDecoding(maxWaitTimeMs, prefer_late_decoding);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000251
Peter Boströmb7d9a972015-12-18 16:01:11 +0100252 if (!frame)
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000253 return VCM_FRAME_NOT_READY;
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000254
Peter Boströmed3277b2016-02-02 15:40:04 +0100255 {
sprang3911c262016-04-15 01:24:14 -0700256 rtc::CritScope cs(&process_crit_);
Peter Boströmed3277b2016-02-02 15:40:04 +0100257 if (drop_frames_until_keyframe_) {
258 // Still getting delta frames, schedule another keyframe request as if
259 // decode failed.
260 if (frame->FrameType() != kVideoFrameKey) {
261 _scheduleKeyRequest = true;
262 _receiver.ReleaseFrame(frame);
263 return VCM_FRAME_NOT_READY;
264 }
265 drop_frames_until_keyframe_ = false;
266 }
267 }
Peter Boströmb7d9a972015-12-18 16:01:11 +0100268
269 if (pre_decode_image_callback_) {
270 EncodedImage encoded_image(frame->EncodedImage());
271 int qp = -1;
272 if (qp_parser_.GetQp(*frame, &qp)) {
273 encoded_image.qp_ = qp;
sprang@webrtc.org40709352013-11-26 11:41:59 +0000274 }
sergeyu2cb155a2016-11-04 11:39:29 -0700275 pre_decode_image_callback_->OnEncodedImage(encoded_image,
276 frame->CodecSpecific(), nullptr);
Peter Boströmb7d9a972015-12-18 16:01:11 +0100277 }
sprang@webrtc.org40709352013-11-26 11:41:59 +0000278
sprang3911c262016-04-15 01:24:14 -0700279 rtc::CritScope cs(&receive_crit_);
280 // If this frame was too late, we should adjust the delay accordingly
philipel721d4022016-12-15 07:10:57 -0800281 _timing->UpdateCurrentDelay(frame->RenderTimeMs(),
282 clock_->TimeInMilliseconds());
skvlad98bb6642016-04-07 15:36:45 -0700283
284 if (first_frame_received_()) {
285 LOG(LS_INFO) << "Received first "
286 << (frame->Complete() ? "complete" : "incomplete")
287 << " decodable video frame";
288 }
289
Peter Boströmb7d9a972015-12-18 16:01:11 +0100290 const int32_t ret = Decode(*frame);
291 _receiver.ReleaseFrame(frame);
292 return ret;
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000293}
294
philipel27378f32017-01-27 02:19:05 -0800295// Used for the WebRTC-NewVideoJitterBuffer experiment.
philipelfd5a20f2016-11-15 00:57:57 -0800296// TODO(philipel): Clean up among the Decode functions as we replace
297// VCMEncodedFrame with FrameObject.
298int32_t VideoReceiver::Decode(const webrtc::VCMEncodedFrame* frame) {
299 rtc::CritScope lock(&receive_crit_);
philipel266f0a42016-11-28 08:49:07 -0800300 if (pre_decode_image_callback_) {
301 EncodedImage encoded_image(frame->EncodedImage());
302 int qp = -1;
303 if (qp_parser_.GetQp(*frame, &qp)) {
304 encoded_image.qp_ = qp;
305 }
306 pre_decode_image_callback_->OnEncodedImage(encoded_image,
307 frame->CodecSpecific(), nullptr);
308 }
philipelfd5a20f2016-11-15 00:57:57 -0800309 return Decode(*frame);
310}
311
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000312int32_t VideoReceiver::RequestSliceLossIndication(
313 const uint64_t pictureID) const {
314 TRACE_EVENT1("webrtc", "RequestSLI", "picture_id", pictureID);
sprang3911c262016-04-15 01:24:14 -0700315 rtc::CritScope cs(&process_crit_);
316 if (_frameTypeCallback != nullptr) {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000317 const int32_t ret =
318 _frameTypeCallback->SliceLossIndicationRequest(pictureID);
319 if (ret < 0) {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000320 return ret;
321 }
322 } else {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000323 return VCM_MISSING_CALLBACK;
324 }
325 return VCM_OK;
326}
327
328int32_t VideoReceiver::RequestKeyFrame() {
329 TRACE_EVENT0("webrtc", "RequestKeyFrame");
sprang3911c262016-04-15 01:24:14 -0700330 rtc::CritScope cs(&process_crit_);
331 if (_frameTypeCallback != nullptr) {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000332 const int32_t ret = _frameTypeCallback->RequestKeyFrame();
333 if (ret < 0) {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000334 return ret;
335 }
336 _scheduleKeyRequest = false;
337 } else {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000338 return VCM_MISSING_CALLBACK;
339 }
340 return VCM_OK;
341}
342
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000343// Must be called from inside the receive side critical section.
344int32_t VideoReceiver::Decode(const VCMEncodedFrame& frame) {
philipel9d3ab612015-12-21 04:12:39 -0800345 TRACE_EVENT_ASYNC_STEP1("webrtc", "Video", frame.TimeStamp(), "Decode",
346 "type", frame.FrameType());
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000347 // Change decoder if payload type has changed
Peter Boströme997a7d2015-11-27 14:23:21 +0100348 _decoder = _codecDataBase.GetDecoder(frame, &_decodedFrameCallback);
sprang3911c262016-04-15 01:24:14 -0700349 if (_decoder == nullptr) {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000350 return VCM_NO_CODEC_REGISTERED;
351 }
352 // Decode a frame
353 int32_t ret = _decoder->Decode(frame, clock_->TimeInMilliseconds());
354
355 // Check for failed decoding, run frame type request callback if needed.
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +0000356 bool request_key_frame = false;
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000357 if (ret < 0) {
358 if (ret == VCM_ERROR_REQUEST_SLI) {
359 return RequestSliceLossIndication(
360 _decodedFrameCallback.LastReceivedPictureID() + 1);
361 } else {
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +0000362 request_key_frame = true;
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000363 }
364 } else if (ret == VCM_REQUEST_SLI) {
365 ret = RequestSliceLossIndication(
366 _decodedFrameCallback.LastReceivedPictureID() + 1);
367 }
368 if (!frame.Complete() || frame.MissingFrame()) {
pbos081af252015-07-27 08:02:22 -0700369 request_key_frame = true;
370 ret = VCM_OK;
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000371 }
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +0000372 if (request_key_frame) {
sprang3911c262016-04-15 01:24:14 -0700373 rtc::CritScope cs(&process_crit_);
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +0000374 _scheduleKeyRequest = true;
375 }
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000376 TRACE_EVENT_ASYNC_END0("webrtc", "Video", frame.TimeStamp());
377 return ret;
378}
379
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000380// Register possible receive codecs, can be called multiple times
381int32_t VideoReceiver::RegisterReceiveCodec(const VideoCodec* receiveCodec,
382 int32_t numberOfCores,
383 bool requireKeyFrame) {
sprang3911c262016-04-15 01:24:14 -0700384 rtc::CritScope cs(&receive_crit_);
385 if (receiveCodec == nullptr) {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000386 return VCM_PARAMETER_ERROR;
387 }
philipel9d3ab612015-12-21 04:12:39 -0800388 if (!_codecDataBase.RegisterReceiveCodec(receiveCodec, numberOfCores,
389 requireKeyFrame)) {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000390 return -1;
391 }
392 return 0;
393}
394
395// Get current received codec
396int32_t VideoReceiver::ReceiveCodec(VideoCodec* currentReceiveCodec) const {
sprang3911c262016-04-15 01:24:14 -0700397 rtc::CritScope cs(&receive_crit_);
398 if (currentReceiveCodec == nullptr) {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000399 return VCM_PARAMETER_ERROR;
400 }
401 return _codecDataBase.ReceiveCodec(currentReceiveCodec) ? 0 : -1;
402}
403
404// Get current received codec
405VideoCodecType VideoReceiver::ReceiveCodec() const {
sprang3911c262016-04-15 01:24:14 -0700406 rtc::CritScope cs(&receive_crit_);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000407 return _codecDataBase.ReceiveCodec();
408}
409
410// Incoming packet from network parsed and ready for decode, non blocking.
411int32_t VideoReceiver::IncomingPacket(const uint8_t* incomingPayload,
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000412 size_t payloadLength,
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000413 const WebRtcRTPHeader& rtpInfo) {
414 if (rtpInfo.frameType == kVideoFrameKey) {
philipel9d3ab612015-12-21 04:12:39 -0800415 TRACE_EVENT1("webrtc", "VCM::PacketKeyFrame", "seqnum",
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000416 rtpInfo.header.sequenceNumber);
417 }
sprang3911c262016-04-15 01:24:14 -0700418 if (incomingPayload == nullptr) {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000419 // The jitter buffer doesn't handle non-zero payload lengths for packets
420 // without payload.
421 // TODO(holmer): We should fix this in the jitter buffer.
422 payloadLength = 0;
423 }
424 const VCMPacket packet(incomingPayload, payloadLength, rtpInfo);
Johan Ahlers95348f72016-06-28 11:11:28 +0200425 int32_t ret = _receiver.InsertPacket(packet);
sprang3911c262016-04-15 01:24:14 -0700426
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000427 // TODO(holmer): Investigate if this somehow should use the key frame
428 // request scheduling to throttle the requests.
429 if (ret == VCM_FLUSH_INDICATOR) {
Peter Boströmed3277b2016-02-02 15:40:04 +0100430 {
sprang3911c262016-04-15 01:24:14 -0700431 rtc::CritScope cs(&process_crit_);
Peter Boströmed3277b2016-02-02 15:40:04 +0100432 drop_frames_until_keyframe_ = true;
433 }
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000434 RequestKeyFrame();
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000435 } else if (ret < 0) {
436 return ret;
437 }
438 return VCM_OK;
439}
440
441// Minimum playout delay (used for lip-sync). This is the minimum delay required
442// to sync with audio. Not included in VideoCodingModule::Delay()
443// Defaults to 0 ms.
444int32_t VideoReceiver::SetMinimumPlayoutDelay(uint32_t minPlayoutDelayMs) {
philipel721d4022016-12-15 07:10:57 -0800445 _timing->set_min_playout_delay(minPlayoutDelayMs);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000446 return VCM_OK;
447}
448
449// The estimated delay caused by rendering, defaults to
450// kDefaultRenderDelayMs = 10 ms
451int32_t VideoReceiver::SetRenderDelay(uint32_t timeMS) {
philipel721d4022016-12-15 07:10:57 -0800452 _timing->set_render_delay(timeMS);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000453 return VCM_OK;
454}
455
456// Current video delay
philipel9d3ab612015-12-21 04:12:39 -0800457int32_t VideoReceiver::Delay() const {
philipel721d4022016-12-15 07:10:57 -0800458 return _timing->TargetVideoDelay();
philipel9d3ab612015-12-21 04:12:39 -0800459}
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000460
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000461uint32_t VideoReceiver::DiscardedPackets() const {
462 return _receiver.DiscardedPackets();
463}
464
465int VideoReceiver::SetReceiverRobustnessMode(
466 ReceiverRobustness robustnessMode,
467 VCMDecodeErrorMode decode_error_mode) {
sprang3911c262016-04-15 01:24:14 -0700468 rtc::CritScope cs(&receive_crit_);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000469 switch (robustnessMode) {
470 case VideoCodingModule::kNone:
471 _receiver.SetNackMode(kNoNack, -1, -1);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000472 break;
473 case VideoCodingModule::kHardNack:
474 // Always wait for retransmissions (except when decoding with errors).
475 _receiver.SetNackMode(kNack, -1, -1);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000476 break;
477 case VideoCodingModule::kSoftNack:
pbos@webrtc.org0e65fda2014-03-21 10:26:42 +0000478#if 1
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000479 assert(false); // TODO(hlundin): Not completed.
480 return VCM_NOT_IMPLEMENTED;
pbos@webrtc.org0e65fda2014-03-21 10:26:42 +0000481#else
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000482 // Enable hybrid NACK/FEC. Always wait for retransmissions and don't add
483 // extra delay when RTT is above kLowRttNackMs.
484 _receiver.SetNackMode(kNack, media_optimization::kLowRttNackMs, -1);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000485 break;
pbos@webrtc.org0e65fda2014-03-21 10:26:42 +0000486#endif
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000487 case VideoCodingModule::kReferenceSelection:
pbos@webrtc.org0e65fda2014-03-21 10:26:42 +0000488#if 1
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000489 assert(false); // TODO(hlundin): Not completed.
490 return VCM_NOT_IMPLEMENTED;
pbos@webrtc.org0e65fda2014-03-21 10:26:42 +0000491#else
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000492 if (decode_error_mode == kNoErrors) {
493 return VCM_PARAMETER_ERROR;
494 }
495 _receiver.SetNackMode(kNoNack, -1, -1);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000496 break;
pbos@webrtc.org0e65fda2014-03-21 10:26:42 +0000497#endif
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000498 }
499 _receiver.SetDecodeErrorMode(decode_error_mode);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000500 return VCM_OK;
501}
502
503void VideoReceiver::SetDecodeErrorMode(VCMDecodeErrorMode decode_error_mode) {
sprang3911c262016-04-15 01:24:14 -0700504 rtc::CritScope cs(&receive_crit_);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000505 _receiver.SetDecodeErrorMode(decode_error_mode);
506}
507
508void VideoReceiver::SetNackSettings(size_t max_nack_list_size,
509 int max_packet_age_to_nack,
510 int max_incomplete_time_ms) {
511 if (max_nack_list_size != 0) {
sprang3911c262016-04-15 01:24:14 -0700512 rtc::CritScope cs(&process_crit_);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000513 max_nack_list_size_ = max_nack_list_size;
514 }
philipel9d3ab612015-12-21 04:12:39 -0800515 _receiver.SetNackSettings(max_nack_list_size, max_packet_age_to_nack,
516 max_incomplete_time_ms);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000517}
518
519int VideoReceiver::SetMinReceiverDelay(int desired_delay_ms) {
520 return _receiver.SetMinReceiverDelay(desired_delay_ms);
521}
522
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000523} // namespace vcm
524} // namespace webrtc