niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1 | /* |
stefan@webrtc.org | 91c6308 | 2012-01-31 10:49:08 +0000 | [diff] [blame] | 2 | * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 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 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 11 | #include "webrtc/modules/video_coding/main/source/receiver.h" |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 12 | |
| 13 | #include <assert.h> |
| 14 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 15 | #include "webrtc/modules/video_coding/main/interface/video_coding.h" |
| 16 | #include "webrtc/modules/video_coding/main/source/encoded_frame.h" |
| 17 | #include "webrtc/modules/video_coding/main/source/internal_defines.h" |
| 18 | #include "webrtc/modules/video_coding/main/source/media_opt_util.h" |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 19 | #include "webrtc/system_wrappers/interface/clock.h" |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 20 | #include "webrtc/system_wrappers/interface/trace.h" |
stefan@webrtc.org | 91c6308 | 2012-01-31 10:49:08 +0000 | [diff] [blame] | 21 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 22 | namespace webrtc { |
| 23 | |
mikhal@webrtc.org | ef9f76a | 2013-02-15 23:22:18 +0000 | [diff] [blame] | 24 | enum { kMaxReceiverDelayMs = 10000 }; |
| 25 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 26 | VCMReceiver::VCMReceiver(VCMTiming* timing, |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 27 | Clock* clock, |
stefan@webrtc.org | 2baf5f5 | 2013-03-13 08:46:25 +0000 | [diff] [blame^] | 28 | EventFactory* event_factory, |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 29 | int32_t vcm_id, |
| 30 | int32_t receiver_id, |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 31 | bool master) |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 32 | : crit_sect_(CriticalSectionWrapper::CreateCriticalSection()), |
| 33 | vcm_id_(vcm_id), |
| 34 | clock_(clock), |
| 35 | receiver_id_(receiver_id), |
| 36 | master_(master), |
stefan@webrtc.org | 2baf5f5 | 2013-03-13 08:46:25 +0000 | [diff] [blame^] | 37 | jitter_buffer_(clock_, event_factory, vcm_id, receiver_id, master), |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 38 | timing_(timing), |
stefan@webrtc.org | 2baf5f5 | 2013-03-13 08:46:25 +0000 | [diff] [blame^] | 39 | render_wait_event_(event_factory->CreateEvent()), |
mikhal@webrtc.org | ef9f76a | 2013-02-15 23:22:18 +0000 | [diff] [blame] | 40 | state_(kPassive), |
| 41 | max_video_delay_ms_(kMaxVideoDelayMs) {} |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 42 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 43 | VCMReceiver::~VCMReceiver() { |
stefan@webrtc.org | 2baf5f5 | 2013-03-13 08:46:25 +0000 | [diff] [blame^] | 44 | render_wait_event_->Set(); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 45 | delete crit_sect_; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 46 | } |
| 47 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 48 | void VCMReceiver::Reset() { |
| 49 | CriticalSectionScoped cs(crit_sect_); |
| 50 | if (!jitter_buffer_.Running()) { |
| 51 | jitter_buffer_.Start(); |
| 52 | } else { |
| 53 | jitter_buffer_.Flush(); |
| 54 | } |
stefan@webrtc.org | 2baf5f5 | 2013-03-13 08:46:25 +0000 | [diff] [blame^] | 55 | render_wait_event_->Reset(); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 56 | if (master_) { |
| 57 | state_ = kReceiving; |
| 58 | } else { |
| 59 | state_ = kPassive; |
| 60 | } |
henrik.lundin@webrtc.org | baf6db5 | 2011-11-02 18:58:39 +0000 | [diff] [blame] | 61 | } |
| 62 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 63 | int32_t VCMReceiver::Initialize() { |
| 64 | CriticalSectionScoped cs(crit_sect_); |
| 65 | Reset(); |
| 66 | if (!master_) { |
stefan@webrtc.org | a64300a | 2013-03-04 15:24:40 +0000 | [diff] [blame] | 67 | SetNackMode(kNoNack, -1, -1); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 68 | } |
| 69 | return VCM_OK; |
| 70 | } |
| 71 | |
| 72 | void VCMReceiver::UpdateRtt(uint32_t rtt) { |
| 73 | jitter_buffer_.UpdateRtt(rtt); |
| 74 | } |
| 75 | |
stefan@webrtc.org | a64300a | 2013-03-04 15:24:40 +0000 | [diff] [blame] | 76 | int32_t VCMReceiver::InsertPacket(const VCMPacket& packet, |
| 77 | uint16_t frame_width, |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 78 | uint16_t frame_height) { |
| 79 | // Find an empty frame. |
| 80 | VCMEncodedFrame* buffer = NULL; |
| 81 | const int32_t error = jitter_buffer_.GetFrame(packet, buffer); |
| 82 | if (error == VCM_OLD_PACKET_ERROR) { |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 83 | return VCM_OK; |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 84 | } else if (error != VCM_OK) { |
| 85 | return error; |
| 86 | } |
| 87 | assert(buffer); |
| 88 | { |
| 89 | CriticalSectionScoped cs(crit_sect_); |
| 90 | |
| 91 | if (frame_width && frame_height) { |
| 92 | buffer->SetEncodedSize(static_cast<uint32_t>(frame_width), |
| 93 | static_cast<uint32_t>(frame_height)); |
| 94 | } |
| 95 | |
| 96 | if (master_) { |
| 97 | // Only trace the primary receiver to make it possible to parse and plot |
| 98 | // the trace file. |
| 99 | WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCoding, |
| 100 | VCMId(vcm_id_, receiver_id_), |
| 101 | "Packet seq_no %u of frame %u at %u", |
| 102 | packet.seqNum, packet.timestamp, |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 103 | MaskWord64ToUWord32(clock_->TimeInMilliseconds())); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 104 | } |
| 105 | |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 106 | const int64_t now_ms = clock_->TimeInMilliseconds(); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 107 | |
| 108 | int64_t render_time_ms = timing_->RenderTimeMs(packet.timestamp, now_ms); |
| 109 | |
| 110 | if (render_time_ms < 0) { |
| 111 | // Render time error. Assume that this is due to some change in the |
| 112 | // incoming video stream and reset the JB and the timing. |
| 113 | jitter_buffer_.Flush(); |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 114 | timing_->Reset(clock_->TimeInMilliseconds()); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 115 | return VCM_FLUSH_INDICATOR; |
mikhal@webrtc.org | ef9f76a | 2013-02-15 23:22:18 +0000 | [diff] [blame] | 116 | } else if (render_time_ms < now_ms - max_video_delay_ms_) { |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 117 | WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideoCoding, |
| 118 | VCMId(vcm_id_, receiver_id_), |
| 119 | "This frame should have been rendered more than %u ms ago." |
| 120 | "Flushing jitter buffer and resetting timing.", |
mikhal@webrtc.org | ef9f76a | 2013-02-15 23:22:18 +0000 | [diff] [blame] | 121 | max_video_delay_ms_); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 122 | jitter_buffer_.Flush(); |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 123 | timing_->Reset(clock_->TimeInMilliseconds()); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 124 | return VCM_FLUSH_INDICATOR; |
mikhal@webrtc.org | ef9f76a | 2013-02-15 23:22:18 +0000 | [diff] [blame] | 125 | } else if (static_cast<int>(timing_->TargetVideoDelay()) > |
| 126 | max_video_delay_ms_) { |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 127 | WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideoCoding, |
| 128 | VCMId(vcm_id_, receiver_id_), |
| 129 | "More than %u ms target delay. Flushing jitter buffer and" |
mikhal@webrtc.org | ef9f76a | 2013-02-15 23:22:18 +0000 | [diff] [blame] | 130 | "resetting timing.", max_video_delay_ms_); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 131 | jitter_buffer_.Flush(); |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 132 | timing_->Reset(clock_->TimeInMilliseconds()); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 133 | return VCM_FLUSH_INDICATOR; |
| 134 | } |
| 135 | |
| 136 | // First packet received belonging to this frame. |
| 137 | if (buffer->Length() == 0) { |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 138 | const int64_t now_ms = clock_->TimeInMilliseconds(); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 139 | if (master_) { |
| 140 | // Only trace the primary receiver to make it possible to parse and plot |
| 141 | // the trace file. |
| 142 | WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCoding, |
| 143 | VCMId(vcm_id_, receiver_id_), |
| 144 | "First packet of frame %u at %u", packet.timestamp, |
| 145 | MaskWord64ToUWord32(now_ms)); |
| 146 | } |
| 147 | render_time_ms = timing_->RenderTimeMs(packet.timestamp, now_ms); |
| 148 | if (render_time_ms >= 0) { |
| 149 | buffer->SetRenderTime(render_time_ms); |
| 150 | } else { |
| 151 | buffer->SetRenderTime(now_ms); |
| 152 | } |
| 153 | } |
| 154 | |
| 155 | // Insert packet into the jitter buffer both media and empty packets. |
| 156 | const VCMFrameBufferEnum |
| 157 | ret = jitter_buffer_.InsertPacket(buffer, packet); |
| 158 | if (ret == kFlushIndicator) { |
| 159 | return VCM_FLUSH_INDICATOR; |
| 160 | } else if (ret < 0) { |
| 161 | WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCoding, |
| 162 | VCMId(vcm_id_, receiver_id_), |
| 163 | "Error inserting packet seq_no=%u, time_stamp=%u", |
| 164 | packet.seqNum, packet.timestamp); |
| 165 | return VCM_JITTER_BUFFER_ERROR; |
| 166 | } |
| 167 | } |
| 168 | return VCM_OK; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 169 | } |
| 170 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 171 | VCMEncodedFrame* VCMReceiver::FrameForDecoding( |
| 172 | uint16_t max_wait_time_ms, |
| 173 | int64_t& next_render_time_ms, |
| 174 | bool render_timing, |
| 175 | VCMReceiver* dual_receiver) { |
| 176 | // No need to enter the critical section here since the jitter buffer |
| 177 | // is thread-safe. |
| 178 | FrameType incoming_frame_type = kVideoFrameDelta; |
| 179 | next_render_time_ms = -1; |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 180 | const int64_t start_time_ms = clock_->TimeInMilliseconds(); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 181 | int64_t ret = jitter_buffer_.NextTimestamp(max_wait_time_ms, |
| 182 | &incoming_frame_type, |
| 183 | &next_render_time_ms); |
| 184 | if (ret < 0) { |
| 185 | // No timestamp in jitter buffer at the moment. |
| 186 | return NULL; |
| 187 | } |
| 188 | const uint32_t time_stamp = static_cast<uint32_t>(ret); |
| 189 | |
| 190 | // Update the timing. |
| 191 | timing_->SetRequiredDelay(jitter_buffer_.EstimatedJitterMs()); |
| 192 | timing_->UpdateCurrentDelay(time_stamp); |
| 193 | |
| 194 | const int32_t temp_wait_time = max_wait_time_ms - |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 195 | static_cast<int32_t>(clock_->TimeInMilliseconds() - start_time_ms); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 196 | uint16_t new_max_wait_time = static_cast<uint16_t>(VCM_MAX(temp_wait_time, |
| 197 | 0)); |
| 198 | |
| 199 | VCMEncodedFrame* frame = NULL; |
| 200 | |
| 201 | if (render_timing) { |
| 202 | frame = FrameForDecoding(new_max_wait_time, next_render_time_ms, |
| 203 | dual_receiver); |
| 204 | } else { |
| 205 | frame = FrameForRendering(new_max_wait_time, next_render_time_ms, |
| 206 | dual_receiver); |
| 207 | } |
| 208 | |
| 209 | if (frame != NULL) { |
| 210 | bool retransmitted = false; |
| 211 | const int64_t last_packet_time_ms = |
| 212 | jitter_buffer_.LastPacketTime(frame, &retransmitted); |
| 213 | if (last_packet_time_ms >= 0 && !retransmitted) { |
| 214 | // We don't want to include timestamps which have suffered from |
| 215 | // retransmission here, since we compensate with extra retransmission |
| 216 | // delay within the jitter estimate. |
| 217 | timing_->IncomingTimestamp(time_stamp, last_packet_time_ms); |
| 218 | } |
| 219 | if (dual_receiver != NULL) { |
| 220 | dual_receiver->UpdateState(*frame); |
| 221 | } |
| 222 | } |
| 223 | return frame; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 224 | } |
| 225 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 226 | VCMEncodedFrame* VCMReceiver::FrameForDecoding( |
| 227 | uint16_t max_wait_time_ms, |
| 228 | int64_t next_render_time_ms, |
| 229 | VCMReceiver* dual_receiver) { |
| 230 | // How long can we wait until we must decode the next frame. |
| 231 | uint32_t wait_time_ms = timing_->MaxWaitingTime( |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 232 | next_render_time_ms, clock_->TimeInMilliseconds()); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 233 | |
| 234 | // Try to get a complete frame from the jitter buffer. |
| 235 | VCMEncodedFrame* frame = jitter_buffer_.GetCompleteFrameForDecoding(0); |
| 236 | |
| 237 | if (frame == NULL && max_wait_time_ms == 0 && wait_time_ms > 0) { |
| 238 | // If we're not allowed to wait for frames to get complete we must |
| 239 | // calculate if it's time to decode, and if it's not we will just return |
| 240 | // for now. |
| 241 | return NULL; |
| 242 | } |
| 243 | |
| 244 | if (frame == NULL && VCM_MIN(wait_time_ms, max_wait_time_ms) == 0) { |
| 245 | // No time to wait for a complete frame, check if we have an incomplete. |
| 246 | const bool dual_receiver_enabled_and_passive = (dual_receiver != NULL && |
| 247 | dual_receiver->State() == kPassive && |
stefan@webrtc.org | a64300a | 2013-03-04 15:24:40 +0000 | [diff] [blame] | 248 | dual_receiver->NackMode() == kNack); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 249 | if (dual_receiver_enabled_and_passive && |
| 250 | !jitter_buffer_.CompleteSequenceWithNextFrame()) { |
| 251 | // Jitter buffer state might get corrupt with this frame. |
| 252 | dual_receiver->CopyJitterBufferStateFromReceiver(*this); |
| 253 | frame = jitter_buffer_.GetFrameForDecoding(); |
| 254 | assert(frame); |
| 255 | } else { |
| 256 | frame = jitter_buffer_.GetFrameForDecoding(); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 257 | } |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 258 | } |
| 259 | if (frame == NULL) { |
| 260 | // Wait for a complete frame. |
| 261 | frame = jitter_buffer_.GetCompleteFrameForDecoding(max_wait_time_ms); |
| 262 | } |
| 263 | if (frame == NULL) { |
| 264 | // Get an incomplete frame. |
| 265 | if (timing_->MaxWaitingTime(next_render_time_ms, |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 266 | clock_->TimeInMilliseconds()) > 0) { |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 267 | // Still time to wait for a complete frame. |
| 268 | return NULL; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 269 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 270 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 271 | // No time left to wait, we must decode this frame now. |
| 272 | const bool dual_receiver_enabled_and_passive = (dual_receiver != NULL && |
| 273 | dual_receiver->State() == kPassive && |
stefan@webrtc.org | a64300a | 2013-03-04 15:24:40 +0000 | [diff] [blame] | 274 | dual_receiver->NackMode() == kNack); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 275 | if (dual_receiver_enabled_and_passive && |
| 276 | !jitter_buffer_.CompleteSequenceWithNextFrame()) { |
| 277 | // Jitter buffer state might get corrupt with this frame. |
| 278 | dual_receiver->CopyJitterBufferStateFromReceiver(*this); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 279 | } |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 280 | |
| 281 | frame = jitter_buffer_.GetFrameForDecoding(); |
| 282 | } |
| 283 | return frame; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 284 | } |
| 285 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 286 | VCMEncodedFrame* VCMReceiver::FrameForRendering(uint16_t max_wait_time_ms, |
| 287 | int64_t next_render_time_ms, |
| 288 | VCMReceiver* dual_receiver) { |
| 289 | // How long MUST we wait until we must decode the next frame. This is |
| 290 | // different for the case where we have a renderer which can render at a |
| 291 | // specified time. Here we must wait as long as possible before giving the |
| 292 | // frame to the decoder, which will render the frame as soon as it has been |
| 293 | // decoded. |
| 294 | uint32_t wait_time_ms = timing_->MaxWaitingTime( |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 295 | next_render_time_ms, clock_->TimeInMilliseconds()); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 296 | if (max_wait_time_ms < wait_time_ms) { |
| 297 | // If we're not allowed to wait until the frame is supposed to be rendered |
| 298 | // we will have to return NULL for now. |
| 299 | return NULL; |
| 300 | } |
| 301 | // Wait until it's time to render. |
stefan@webrtc.org | 2baf5f5 | 2013-03-13 08:46:25 +0000 | [diff] [blame^] | 302 | render_wait_event_->Wait(wait_time_ms); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 303 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 304 | // Get a complete frame if possible. |
| 305 | VCMEncodedFrame* frame = jitter_buffer_.GetCompleteFrameForDecoding(0); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 306 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 307 | if (frame == NULL) { |
| 308 | // Get an incomplete frame. |
| 309 | const bool dual_receiver_enabled_and_passive = (dual_receiver != NULL && |
| 310 | dual_receiver->State() == kPassive && |
stefan@webrtc.org | a64300a | 2013-03-04 15:24:40 +0000 | [diff] [blame] | 311 | dual_receiver->NackMode() == kNack); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 312 | if (dual_receiver_enabled_and_passive && |
| 313 | !jitter_buffer_.CompleteSequenceWithNextFrame()) { |
| 314 | // Jitter buffer state might get corrupt with this frame. |
| 315 | dual_receiver->CopyJitterBufferStateFromReceiver(*this); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 316 | } |
| 317 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 318 | frame = jitter_buffer_.GetFrameForDecoding(); |
| 319 | } |
| 320 | return frame; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 321 | } |
| 322 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 323 | void VCMReceiver::ReleaseFrame(VCMEncodedFrame* frame) { |
| 324 | jitter_buffer_.ReleaseFrame(frame); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 325 | } |
| 326 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 327 | void VCMReceiver::ReceiveStatistics(uint32_t* bitrate, |
| 328 | uint32_t* framerate) { |
| 329 | assert(bitrate); |
| 330 | assert(framerate); |
| 331 | jitter_buffer_.IncomingRateStatistics(framerate, bitrate); |
| 332 | *bitrate /= 1000; // Should be in kbps. |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 333 | } |
| 334 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 335 | void VCMReceiver::ReceivedFrameCount(VCMFrameCount* frame_count) const { |
| 336 | assert(frame_count); |
| 337 | jitter_buffer_.FrameStatistics(&frame_count->numDeltaFrames, |
| 338 | &frame_count->numKeyFrames); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 339 | } |
| 340 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 341 | uint32_t VCMReceiver::DiscardedPackets() const { |
| 342 | return jitter_buffer_.num_discarded_packets(); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 343 | } |
| 344 | |
stefan@webrtc.org | a64300a | 2013-03-04 15:24:40 +0000 | [diff] [blame] | 345 | void VCMReceiver::SetNackMode(VCMNackMode nackMode, |
| 346 | int low_rtt_nack_threshold_ms, |
| 347 | int high_rtt_nack_threshold_ms) { |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 348 | CriticalSectionScoped cs(crit_sect_); |
| 349 | // Default to always having NACK enabled in hybrid mode. |
stefan@webrtc.org | a64300a | 2013-03-04 15:24:40 +0000 | [diff] [blame] | 350 | jitter_buffer_.SetNackMode(nackMode, low_rtt_nack_threshold_ms, |
| 351 | high_rtt_nack_threshold_ms); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 352 | if (!master_) { |
| 353 | state_ = kPassive; // The dual decoder defaults to passive. |
| 354 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 355 | } |
| 356 | |
stefan@webrtc.org | becf9c8 | 2013-02-01 15:09:57 +0000 | [diff] [blame] | 357 | void VCMReceiver::SetNackSettings(size_t max_nack_list_size, |
| 358 | int max_packet_age_to_nack) { |
| 359 | jitter_buffer_.SetNackSettings(max_nack_list_size, |
| 360 | max_packet_age_to_nack); |
| 361 | } |
| 362 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 363 | VCMNackMode VCMReceiver::NackMode() const { |
| 364 | CriticalSectionScoped cs(crit_sect_); |
| 365 | return jitter_buffer_.nack_mode(); |
stefan@webrtc.org | 791eec7 | 2011-10-11 07:53:43 +0000 | [diff] [blame] | 366 | } |
| 367 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 368 | VCMNackStatus VCMReceiver::NackList(uint16_t* nack_list, |
stefan@webrtc.org | a64300a | 2013-03-04 15:24:40 +0000 | [diff] [blame] | 369 | uint16_t size, |
| 370 | uint16_t* nack_list_length) { |
| 371 | bool request_key_frame = false; |
| 372 | uint16_t* internal_nack_list = jitter_buffer_.GetNackList( |
| 373 | nack_list_length, &request_key_frame); |
| 374 | if (request_key_frame) { |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 375 | // This combination is used to trigger key frame requests. |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 376 | return kNackKeyFrameRequest; |
| 377 | } |
stefan@webrtc.org | a64300a | 2013-03-04 15:24:40 +0000 | [diff] [blame] | 378 | if (*nack_list_length > size) { |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 379 | return kNackNeedMoreMemory; |
| 380 | } |
stefan@webrtc.org | a64300a | 2013-03-04 15:24:40 +0000 | [diff] [blame] | 381 | if (internal_nack_list != NULL && *nack_list_length > 0) { |
| 382 | memcpy(nack_list, internal_nack_list, *nack_list_length * sizeof(uint16_t)); |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 383 | } |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 384 | return kNackOk; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 385 | } |
| 386 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 387 | // Decide whether we should change decoder state. This should be done if the |
| 388 | // dual decoder has caught up with the decoder decoding with packet losses. |
| 389 | bool VCMReceiver::DualDecoderCaughtUp(VCMEncodedFrame* dual_frame, |
| 390 | VCMReceiver& dual_receiver) const { |
| 391 | if (dual_frame == NULL) { |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 392 | return false; |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 393 | } |
| 394 | if (jitter_buffer_.LastDecodedTimestamp() == dual_frame->TimeStamp()) { |
| 395 | dual_receiver.UpdateState(kWaitForPrimaryDecode); |
| 396 | return true; |
| 397 | } |
| 398 | return false; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 399 | } |
| 400 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 401 | void VCMReceiver::CopyJitterBufferStateFromReceiver( |
| 402 | const VCMReceiver& receiver) { |
| 403 | jitter_buffer_.CopyFrom(receiver.jitter_buffer_); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 404 | } |
| 405 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 406 | VCMReceiverState VCMReceiver::State() const { |
| 407 | CriticalSectionScoped cs(crit_sect_); |
| 408 | return state_; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 409 | } |
| 410 | |
mikhal@webrtc.org | ef9f76a | 2013-02-15 23:22:18 +0000 | [diff] [blame] | 411 | int VCMReceiver::SetMinReceiverDelay(int desired_delay_ms) { |
| 412 | CriticalSectionScoped cs(crit_sect_); |
| 413 | if (desired_delay_ms < 0 || desired_delay_ms > kMaxReceiverDelayMs) { |
| 414 | return -1; |
| 415 | } |
| 416 | jitter_buffer_.SetMaxJitterEstimate(desired_delay_ms); |
| 417 | max_video_delay_ms_ = desired_delay_ms + kMaxVideoDelayMs; |
| 418 | timing_->SetMaxVideoDelay(max_video_delay_ms_); |
| 419 | return 0; |
| 420 | } |
| 421 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 422 | void VCMReceiver::UpdateState(VCMReceiverState new_state) { |
| 423 | CriticalSectionScoped cs(crit_sect_); |
| 424 | assert(!(state_ == kPassive && new_state == kWaitForPrimaryDecode)); |
| 425 | state_ = new_state; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 426 | } |
| 427 | |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 428 | void VCMReceiver::UpdateState(const VCMEncodedFrame& frame) { |
| 429 | if (jitter_buffer_.nack_mode() == kNoNack) { |
| 430 | // Dual decoder mode has not been enabled. |
| 431 | return; |
| 432 | } |
| 433 | // Update the dual receiver state. |
| 434 | if (frame.Complete() && frame.FrameType() == kVideoFrameKey) { |
| 435 | UpdateState(kPassive); |
| 436 | } |
| 437 | if (State() == kWaitForPrimaryDecode && |
| 438 | frame.Complete() && !frame.MissingFrame()) { |
| 439 | UpdateState(kPassive); |
| 440 | } |
| 441 | if (frame.MissingFrame() || !frame.Complete()) { |
| 442 | // State was corrupted, enable dual receiver. |
| 443 | UpdateState(kReceiving); |
| 444 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 445 | } |
stefan@webrtc.org | 1ea4b50 | 2013-01-07 08:49:41 +0000 | [diff] [blame] | 446 | } // namespace webrtc |