blob: 1c0a9c2829e94d104bf1339d4191b9ba7d41ff4d [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
23// #define DEBUG_DECODER_BIT_STREAM
24
25namespace webrtc {
26namespace vcm {
27
stefan@webrtc.org34c5da62014-04-11 14:08:35 +000028VideoReceiver::VideoReceiver(Clock* clock, EventFactory* event_factory)
29 : clock_(clock),
stefan@webrtc.org8db81c52013-09-18 11:57:34 +000030 process_crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000031 _receiveCritSect(CriticalSectionWrapper::CreateCriticalSection()),
stefan@webrtc.org34c5da62014-04-11 14:08:35 +000032 _timing(clock_),
Wan-Teh Chang92d94892015-05-28 13:36:06 -070033 _receiver(&_timing, clock_, event_factory),
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000034 _decodedFrameCallback(_timing, clock_),
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000035 _frameTypeCallback(NULL),
36 _receiveStatsCallback(NULL),
fischman@webrtc.org37bb4972013-10-23 23:59:45 +000037 _decoderTimingCallback(NULL),
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000038 _packetRequestCallback(NULL),
39 render_buffer_callback_(NULL),
40 _decoder(NULL),
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000041#ifdef DEBUG_DECODER_BIT_STREAM
42 _bitStreamBeforeDecoder(NULL),
43#endif
44 _frameFromFile(),
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000045 _scheduleKeyRequest(false),
46 max_nack_list_size_(0),
sprang@webrtc.org40709352013-11-26 11:41:59 +000047 pre_decode_image_callback_(NULL),
Peter Boström4f5db112015-10-29 16:53:59 +010048 _codecDataBase(nullptr, nullptr),
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000049 _receiveStatsTimer(1000, clock_),
50 _retransmissionTimer(10, clock_),
51 _keyRequestTimer(500, clock_) {
52 assert(clock_);
53#ifdef DEBUG_DECODER_BIT_STREAM
54 _bitStreamBeforeDecoder = fopen("decoderBitStream.bit", "wb");
55#endif
56}
57
58VideoReceiver::~VideoReceiver() {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000059 delete _receiveCritSect;
60#ifdef DEBUG_DECODER_BIT_STREAM
61 fclose(_bitStreamBeforeDecoder);
62#endif
63}
64
65int32_t VideoReceiver::Process() {
66 int32_t returnValue = VCM_OK;
67
68 // Receive-side statistics
69 if (_receiveStatsTimer.TimeUntilProcess() == 0) {
70 _receiveStatsTimer.Processed();
stefan@webrtc.org8db81c52013-09-18 11:57:34 +000071 CriticalSectionScoped cs(process_crit_sect_.get());
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000072 if (_receiveStatsCallback != NULL) {
73 uint32_t bitRate;
74 uint32_t frameRate;
75 _receiver.ReceiveStatistics(&bitRate, &frameRate);
pbos@webrtc.org55707692014-12-19 15:45:03 +000076 _receiveStatsCallback->OnReceiveRatesUpdated(bitRate, frameRate);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +000077 }
78
fischman@webrtc.org37bb4972013-10-23 23:59:45 +000079 if (_decoderTimingCallback != NULL) {
80 int decode_ms;
81 int max_decode_ms;
82 int current_delay_ms;
83 int target_delay_ms;
84 int jitter_buffer_ms;
85 int min_playout_delay_ms;
86 int render_delay_ms;
87 _timing.GetTimings(&decode_ms,
88 &max_decode_ms,
89 &current_delay_ms,
90 &target_delay_ms,
91 &jitter_buffer_ms,
92 &min_playout_delay_ms,
93 &render_delay_ms);
94 _decoderTimingCallback->OnDecoderTiming(decode_ms,
95 max_decode_ms,
96 current_delay_ms,
97 target_delay_ms,
98 jitter_buffer_ms,
99 min_playout_delay_ms,
100 render_delay_ms);
101 }
102
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000103 // Size of render buffer.
104 if (render_buffer_callback_) {
105 int buffer_size_ms = _receiver.RenderBufferSizeMs();
106 render_buffer_callback_->RenderBufferSizeMs(buffer_size_ms);
107 }
108 }
109
110 // Key frame requests
111 if (_keyRequestTimer.TimeUntilProcess() == 0) {
112 _keyRequestTimer.Processed();
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +0000113 bool request_key_frame = false;
114 {
115 CriticalSectionScoped cs(process_crit_sect_.get());
116 request_key_frame = _scheduleKeyRequest && _frameTypeCallback != NULL;
117 }
118 if (request_key_frame) {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000119 const int32_t ret = RequestKeyFrame();
120 if (ret != VCM_OK && returnValue == VCM_OK) {
121 returnValue = ret;
122 }
123 }
124 }
125
126 // Packet retransmission requests
127 // TODO(holmer): Add API for changing Process interval and make sure it's
128 // disabled when NACK is off.
129 if (_retransmissionTimer.TimeUntilProcess() == 0) {
130 _retransmissionTimer.Processed();
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +0000131 bool callback_registered = false;
132 uint16_t length;
133 {
134 CriticalSectionScoped cs(process_crit_sect_.get());
135 length = max_nack_list_size_;
136 callback_registered = _packetRequestCallback != NULL;
137 }
138 if (callback_registered && length > 0) {
Wan-Teh Changb1825a42015-06-03 15:03:35 -0700139 // Collect sequence numbers from the default receiver.
140 bool request_key_frame = false;
141 std::vector<uint16_t> nackList = _receiver.NackList(&request_key_frame);
142 int32_t ret = VCM_OK;
143 if (request_key_frame) {
144 ret = RequestKeyFrame();
145 if (ret != VCM_OK && returnValue == VCM_OK) {
146 returnValue = ret;
147 }
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000148 }
Wan-Teh Changb1825a42015-06-03 15:03:35 -0700149 if (ret == VCM_OK && !nackList.empty()) {
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +0000150 CriticalSectionScoped cs(process_crit_sect_.get());
151 if (_packetRequestCallback != NULL) {
Wan-Teh Changb1825a42015-06-03 15:03:35 -0700152 _packetRequestCallback->ResendPackets(&nackList[0], nackList.size());
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +0000153 }
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000154 }
155 }
156 }
157
158 return returnValue;
159}
160
pkasting@chromium.org0b1534c2014-12-15 22:09:40 +0000161int64_t VideoReceiver::TimeUntilNextProcess() {
162 int64_t timeUntilNextProcess = _receiveStatsTimer.TimeUntilProcess();
pbos@webrtc.org4f16c872014-11-24 09:06:48 +0000163 if (_receiver.NackMode() != kNoNack) {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000164 // We need a Process call more often if we are relying on
165 // retransmissions
166 timeUntilNextProcess =
167 VCM_MIN(timeUntilNextProcess, _retransmissionTimer.TimeUntilProcess());
168 }
169 timeUntilNextProcess =
170 VCM_MIN(timeUntilNextProcess, _keyRequestTimer.TimeUntilProcess());
171
172 return timeUntilNextProcess;
173}
174
pkasting@chromium.org16825b12015-01-12 21:51:21 +0000175int32_t VideoReceiver::SetReceiveChannelParameters(int64_t rtt) {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000176 CriticalSectionScoped receiveCs(_receiveCritSect);
177 _receiver.UpdateRtt(rtt);
178 return 0;
179}
180
181// Enable or disable a video protection method.
182// Note: This API should be deprecated, as it does not offer a distinction
183// between the protection method and decoding with or without errors. If such a
184// behavior is desired, use the following API: SetReceiverRobustnessMode.
185int32_t VideoReceiver::SetVideoProtection(VCMVideoProtection videoProtection,
186 bool enable) {
187 // By default, do not decode with errors.
188 _receiver.SetDecodeErrorMode(kNoErrors);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000189 switch (videoProtection) {
pbosba8c15b2015-07-14 09:36:34 -0700190 case kProtectionNack: {
henrikg91d6ede2015-09-17 00:24:34 -0700191 RTC_DCHECK(enable);
pbosba8c15b2015-07-14 09:36:34 -0700192 _receiver.SetNackMode(kNack, -1, -1);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000193 break;
194 }
195
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000196 case kProtectionNackFEC: {
197 CriticalSectionScoped cs(_receiveCritSect);
henrikg91d6ede2015-09-17 00:24:34 -0700198 RTC_DCHECK(enable);
pbosba8c15b2015-07-14 09:36:34 -0700199 _receiver.SetNackMode(kNack, media_optimization::kLowRttNackMs, -1);
200 _receiver.SetDecodeErrorMode(kNoErrors);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000201 break;
202 }
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000203 case kProtectionFEC:
pbos@webrtc.orgcade82c2015-03-12 10:39:24 +0000204 case kProtectionNone:
pbosba8c15b2015-07-14 09:36:34 -0700205 // No receiver-side protection.
henrikg91d6ede2015-09-17 00:24:34 -0700206 RTC_DCHECK(enable);
pbosba8c15b2015-07-14 09:36:34 -0700207 _receiver.SetNackMode(kNoNack, -1, -1);
208 _receiver.SetDecodeErrorMode(kWithErrors);
pbos@webrtc.orgcade82c2015-03-12 10:39:24 +0000209 break;
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000210 }
211 return VCM_OK;
212}
213
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000214// Register a receive callback. Will be called whenever there is a new frame
215// ready for rendering.
216int32_t VideoReceiver::RegisterReceiveCallback(
217 VCMReceiveCallback* receiveCallback) {
218 CriticalSectionScoped cs(_receiveCritSect);
219 _decodedFrameCallback.SetUserReceiveCallback(receiveCallback);
220 return VCM_OK;
221}
222
223int32_t VideoReceiver::RegisterReceiveStatisticsCallback(
224 VCMReceiveStatisticsCallback* receiveStats) {
stefan@webrtc.org8db81c52013-09-18 11:57:34 +0000225 CriticalSectionScoped cs(process_crit_sect_.get());
pbos@webrtc.org55707692014-12-19 15:45:03 +0000226 _receiver.RegisterStatsCallback(receiveStats);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000227 _receiveStatsCallback = receiveStats;
228 return VCM_OK;
229}
230
fischman@webrtc.org37bb4972013-10-23 23:59:45 +0000231int32_t VideoReceiver::RegisterDecoderTimingCallback(
232 VCMDecoderTimingCallback* decoderTiming) {
233 CriticalSectionScoped cs(process_crit_sect_.get());
234 _decoderTimingCallback = decoderTiming;
235 return VCM_OK;
236}
237
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000238// Register an externally defined decoder/render object.
239// Can be a decoder only or a decoder coupled with a renderer.
Peter Boström795dbe42015-11-27 14:09:07 +0100240void VideoReceiver::RegisterExternalDecoder(VideoDecoder* externalDecoder,
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000241 uint8_t payloadType,
242 bool internalRenderTiming) {
243 CriticalSectionScoped cs(_receiveCritSect);
244 if (externalDecoder == NULL) {
245 // Make sure the VCM updates the decoder next time it decodes.
246 _decoder = NULL;
Peter Boström795dbe42015-11-27 14:09:07 +0100247 RTC_CHECK(_codecDataBase.DeregisterExternalDecoder(payloadType));
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000248 }
Peter Boström795dbe42015-11-27 14:09:07 +0100249 _codecDataBase.RegisterExternalDecoder(externalDecoder, payloadType,
250 internalRenderTiming);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000251}
252
253// Register a frame type request callback.
254int32_t VideoReceiver::RegisterFrameTypeCallback(
255 VCMFrameTypeCallback* frameTypeCallback) {
stefan@webrtc.org8db81c52013-09-18 11:57:34 +0000256 CriticalSectionScoped cs(process_crit_sect_.get());
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000257 _frameTypeCallback = frameTypeCallback;
258 return VCM_OK;
259}
260
261int32_t VideoReceiver::RegisterPacketRequestCallback(
262 VCMPacketRequestCallback* callback) {
stefan@webrtc.org8db81c52013-09-18 11:57:34 +0000263 CriticalSectionScoped cs(process_crit_sect_.get());
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000264 _packetRequestCallback = callback;
265 return VCM_OK;
266}
267
268int VideoReceiver::RegisterRenderBufferSizeCallback(
269 VCMRenderBufferSizeCallback* callback) {
stefan@webrtc.org8db81c52013-09-18 11:57:34 +0000270 CriticalSectionScoped cs(process_crit_sect_.get());
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000271 render_buffer_callback_ = callback;
272 return VCM_OK;
273}
274
pbos@webrtc.org4dd40d62015-02-17 13:22:43 +0000275void VideoReceiver::TriggerDecoderShutdown() {
276 _receiver.TriggerDecoderShutdown();
277}
278
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000279// Decode next frame, blocking.
280// Should be called as often as possible to get the most out of the decoder.
281int32_t VideoReceiver::Decode(uint16_t maxWaitTimeMs) {
282 int64_t nextRenderTimeMs;
pbos@webrtc.org776e6f22014-10-29 15:28:39 +0000283 bool supports_render_scheduling;
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000284 {
285 CriticalSectionScoped cs(_receiveCritSect);
pbos@webrtc.org776e6f22014-10-29 15:28:39 +0000286 supports_render_scheduling = _codecDataBase.SupportsRenderScheduling();
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000287 }
288
pbos@webrtc.org4f16c872014-11-24 09:06:48 +0000289 VCMEncodedFrame* frame = _receiver.FrameForDecoding(
290 maxWaitTimeMs, nextRenderTimeMs, supports_render_scheduling);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000291
292 if (frame == NULL) {
293 return VCM_FRAME_NOT_READY;
294 } else {
295 CriticalSectionScoped cs(_receiveCritSect);
296
297 // If this frame was too late, we should adjust the delay accordingly
298 _timing.UpdateCurrentDelay(frame->RenderTimeMs(),
299 clock_->TimeInMilliseconds());
300
sprang@webrtc.org40709352013-11-26 11:41:59 +0000301 if (pre_decode_image_callback_) {
302 EncodedImage encoded_image(frame->EncodedImage());
asapersson86b01602015-10-20 23:55:26 -0700303 int qp = -1;
304 if (qp_parser_.GetQp(*frame, &qp)) {
305 encoded_image.qp_ = qp;
306 }
307 pre_decode_image_callback_->Encoded(
308 encoded_image, frame->CodecSpecific(), NULL);
sprang@webrtc.org40709352013-11-26 11:41:59 +0000309 }
310
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000311#ifdef DEBUG_DECODER_BIT_STREAM
312 if (_bitStreamBeforeDecoder != NULL) {
313 // Write bit stream to file for debugging purposes
314 if (fwrite(
315 frame->Buffer(), 1, frame->Length(), _bitStreamBeforeDecoder) !=
316 frame->Length()) {
317 return -1;
318 }
319 }
320#endif
321 const int32_t ret = Decode(*frame);
322 _receiver.ReleaseFrame(frame);
323 frame = NULL;
324 if (ret != VCM_OK) {
325 return ret;
326 }
327 }
328 return VCM_OK;
329}
330
331int32_t VideoReceiver::RequestSliceLossIndication(
332 const uint64_t pictureID) const {
333 TRACE_EVENT1("webrtc", "RequestSLI", "picture_id", pictureID);
stefan@webrtc.org8db81c52013-09-18 11:57:34 +0000334 CriticalSectionScoped cs(process_crit_sect_.get());
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000335 if (_frameTypeCallback != NULL) {
336 const int32_t ret =
337 _frameTypeCallback->SliceLossIndicationRequest(pictureID);
338 if (ret < 0) {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000339 return ret;
340 }
341 } else {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000342 return VCM_MISSING_CALLBACK;
343 }
344 return VCM_OK;
345}
346
347int32_t VideoReceiver::RequestKeyFrame() {
348 TRACE_EVENT0("webrtc", "RequestKeyFrame");
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +0000349 CriticalSectionScoped process_cs(process_crit_sect_.get());
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000350 if (_frameTypeCallback != NULL) {
351 const int32_t ret = _frameTypeCallback->RequestKeyFrame();
352 if (ret < 0) {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000353 return ret;
354 }
355 _scheduleKeyRequest = false;
356 } else {
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000357 return VCM_MISSING_CALLBACK;
358 }
359 return VCM_OK;
360}
361
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000362// Must be called from inside the receive side critical section.
363int32_t VideoReceiver::Decode(const VCMEncodedFrame& frame) {
364 TRACE_EVENT_ASYNC_STEP1("webrtc",
365 "Video",
366 frame.TimeStamp(),
367 "Decode",
368 "type",
369 frame.FrameType());
370 // Change decoder if payload type has changed
371 const bool renderTimingBefore = _codecDataBase.SupportsRenderScheduling();
372 _decoder =
373 _codecDataBase.GetDecoder(frame.PayloadType(), &_decodedFrameCallback);
374 if (renderTimingBefore != _codecDataBase.SupportsRenderScheduling()) {
375 // Make sure we reset the decode time estimate since it will
376 // be zero for codecs without render timing.
377 _timing.ResetDecodeTime();
378 }
379 if (_decoder == NULL) {
380 return VCM_NO_CODEC_REGISTERED;
381 }
382 // Decode a frame
383 int32_t ret = _decoder->Decode(frame, clock_->TimeInMilliseconds());
384
385 // Check for failed decoding, run frame type request callback if needed.
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +0000386 bool request_key_frame = false;
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000387 if (ret < 0) {
388 if (ret == VCM_ERROR_REQUEST_SLI) {
389 return RequestSliceLossIndication(
390 _decodedFrameCallback.LastReceivedPictureID() + 1);
391 } else {
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +0000392 request_key_frame = true;
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000393 }
394 } else if (ret == VCM_REQUEST_SLI) {
395 ret = RequestSliceLossIndication(
396 _decodedFrameCallback.LastReceivedPictureID() + 1);
397 }
398 if (!frame.Complete() || frame.MissingFrame()) {
pbos081af252015-07-27 08:02:22 -0700399 request_key_frame = true;
400 ret = VCM_OK;
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000401 }
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +0000402 if (request_key_frame) {
403 CriticalSectionScoped cs(process_crit_sect_.get());
404 _scheduleKeyRequest = true;
405 }
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000406 TRACE_EVENT_ASYNC_END0("webrtc", "Video", frame.TimeStamp());
407 return ret;
408}
409
410// Reset the decoder state
411int32_t VideoReceiver::ResetDecoder() {
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +0000412 bool reset_key_request = false;
413 {
414 CriticalSectionScoped cs(_receiveCritSect);
415 if (_decoder != NULL) {
Peter Boström5464a6e2015-04-21 16:35:50 +0200416 _receiver.Reset();
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +0000417 _timing.Reset();
418 reset_key_request = true;
419 _decoder->Reset();
stefan@webrtc.org8db81c52013-09-18 11:57:34 +0000420 }
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000421 }
stefan@webrtc.orgf7c6e742014-01-29 10:27:51 +0000422 if (reset_key_request) {
423 CriticalSectionScoped cs(process_crit_sect_.get());
424 _scheduleKeyRequest = false;
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000425 }
426 return VCM_OK;
427}
428
429// Register possible receive codecs, can be called multiple times
430int32_t VideoReceiver::RegisterReceiveCodec(const VideoCodec* receiveCodec,
431 int32_t numberOfCores,
432 bool requireKeyFrame) {
433 CriticalSectionScoped cs(_receiveCritSect);
434 if (receiveCodec == NULL) {
435 return VCM_PARAMETER_ERROR;
436 }
437 if (!_codecDataBase.RegisterReceiveCodec(
438 receiveCodec, numberOfCores, requireKeyFrame)) {
439 return -1;
440 }
441 return 0;
442}
443
444// Get current received codec
445int32_t VideoReceiver::ReceiveCodec(VideoCodec* currentReceiveCodec) const {
446 CriticalSectionScoped cs(_receiveCritSect);
447 if (currentReceiveCodec == NULL) {
448 return VCM_PARAMETER_ERROR;
449 }
450 return _codecDataBase.ReceiveCodec(currentReceiveCodec) ? 0 : -1;
451}
452
453// Get current received codec
454VideoCodecType VideoReceiver::ReceiveCodec() const {
455 CriticalSectionScoped cs(_receiveCritSect);
456 return _codecDataBase.ReceiveCodec();
457}
458
459// Incoming packet from network parsed and ready for decode, non blocking.
460int32_t VideoReceiver::IncomingPacket(const uint8_t* incomingPayload,
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000461 size_t payloadLength,
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000462 const WebRtcRTPHeader& rtpInfo) {
463 if (rtpInfo.frameType == kVideoFrameKey) {
464 TRACE_EVENT1("webrtc",
465 "VCM::PacketKeyFrame",
466 "seqnum",
467 rtpInfo.header.sequenceNumber);
468 }
469 if (incomingPayload == NULL) {
470 // The jitter buffer doesn't handle non-zero payload lengths for packets
471 // without payload.
472 // TODO(holmer): We should fix this in the jitter buffer.
473 payloadLength = 0;
474 }
475 const VCMPacket packet(incomingPayload, payloadLength, rtpInfo);
pbos@webrtc.org4f16c872014-11-24 09:06:48 +0000476 int32_t ret = _receiver.InsertPacket(packet, rtpInfo.type.Video.width,
477 rtpInfo.type.Video.height);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000478 // TODO(holmer): Investigate if this somehow should use the key frame
479 // request scheduling to throttle the requests.
480 if (ret == VCM_FLUSH_INDICATOR) {
481 RequestKeyFrame();
482 ResetDecoder();
483 } else if (ret < 0) {
484 return ret;
485 }
486 return VCM_OK;
487}
488
489// Minimum playout delay (used for lip-sync). This is the minimum delay required
490// to sync with audio. Not included in VideoCodingModule::Delay()
491// Defaults to 0 ms.
492int32_t VideoReceiver::SetMinimumPlayoutDelay(uint32_t minPlayoutDelayMs) {
493 _timing.set_min_playout_delay(minPlayoutDelayMs);
494 return VCM_OK;
495}
496
497// The estimated delay caused by rendering, defaults to
498// kDefaultRenderDelayMs = 10 ms
499int32_t VideoReceiver::SetRenderDelay(uint32_t timeMS) {
500 _timing.set_render_delay(timeMS);
501 return VCM_OK;
502}
503
504// Current video delay
505int32_t VideoReceiver::Delay() const { return _timing.TargetVideoDelay(); }
506
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000507uint32_t VideoReceiver::DiscardedPackets() const {
508 return _receiver.DiscardedPackets();
509}
510
511int VideoReceiver::SetReceiverRobustnessMode(
512 ReceiverRobustness robustnessMode,
513 VCMDecodeErrorMode decode_error_mode) {
514 CriticalSectionScoped cs(_receiveCritSect);
515 switch (robustnessMode) {
516 case VideoCodingModule::kNone:
517 _receiver.SetNackMode(kNoNack, -1, -1);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000518 break;
519 case VideoCodingModule::kHardNack:
520 // Always wait for retransmissions (except when decoding with errors).
521 _receiver.SetNackMode(kNack, -1, -1);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000522 break;
523 case VideoCodingModule::kSoftNack:
pbos@webrtc.org0e65fda2014-03-21 10:26:42 +0000524#if 1
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000525 assert(false); // TODO(hlundin): Not completed.
526 return VCM_NOT_IMPLEMENTED;
pbos@webrtc.org0e65fda2014-03-21 10:26:42 +0000527#else
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000528 // Enable hybrid NACK/FEC. Always wait for retransmissions and don't add
529 // extra delay when RTT is above kLowRttNackMs.
530 _receiver.SetNackMode(kNack, media_optimization::kLowRttNackMs, -1);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000531 break;
pbos@webrtc.org0e65fda2014-03-21 10:26:42 +0000532#endif
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000533 case VideoCodingModule::kReferenceSelection:
pbos@webrtc.org0e65fda2014-03-21 10:26:42 +0000534#if 1
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000535 assert(false); // TODO(hlundin): Not completed.
536 return VCM_NOT_IMPLEMENTED;
pbos@webrtc.org0e65fda2014-03-21 10:26:42 +0000537#else
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000538 if (decode_error_mode == kNoErrors) {
539 return VCM_PARAMETER_ERROR;
540 }
541 _receiver.SetNackMode(kNoNack, -1, -1);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000542 break;
pbos@webrtc.org0e65fda2014-03-21 10:26:42 +0000543#endif
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000544 }
545 _receiver.SetDecodeErrorMode(decode_error_mode);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000546 return VCM_OK;
547}
548
549void VideoReceiver::SetDecodeErrorMode(VCMDecodeErrorMode decode_error_mode) {
550 CriticalSectionScoped cs(_receiveCritSect);
551 _receiver.SetDecodeErrorMode(decode_error_mode);
552}
553
554void VideoReceiver::SetNackSettings(size_t max_nack_list_size,
555 int max_packet_age_to_nack,
556 int max_incomplete_time_ms) {
557 if (max_nack_list_size != 0) {
stefan@webrtc.org8db81c52013-09-18 11:57:34 +0000558 CriticalSectionScoped process_cs(process_crit_sect_.get());
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000559 max_nack_list_size_ = max_nack_list_size;
560 }
561 _receiver.SetNackSettings(
562 max_nack_list_size, max_packet_age_to_nack, max_incomplete_time_ms);
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000563}
564
565int VideoReceiver::SetMinReceiverDelay(int desired_delay_ms) {
566 return _receiver.SetMinReceiverDelay(desired_delay_ms);
567}
568
sprang@webrtc.org40709352013-11-26 11:41:59 +0000569void VideoReceiver::RegisterPreDecodeImageCallback(
570 EncodedImageCallback* observer) {
571 CriticalSectionScoped cs(_receiveCritSect);
572 pre_decode_image_callback_ = observer;
573}
574
andresp@webrtc.orgf7eb75b2013-09-14 00:25:28 +0000575} // namespace vcm
576} // namespace webrtc