| OLD | NEW |
| (Empty) |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "media/cast/framer/cast_message_builder.h" | |
| 6 | |
| 7 #include "media/cast/cast_defines.h" | |
| 8 | |
| 9 namespace media { | |
| 10 namespace cast { | |
| 11 | |
| 12 CastMessageBuilder::CastMessageBuilder( | |
| 13 base::TickClock* clock, | |
| 14 RtpPayloadFeedback* incoming_payload_feedback, | |
| 15 FrameIdMap* frame_id_map, | |
| 16 uint32 media_ssrc, | |
| 17 bool decoder_faster_than_max_frame_rate, | |
| 18 int max_unacked_frames) | |
| 19 : clock_(clock), | |
| 20 cast_feedback_(incoming_payload_feedback), | |
| 21 frame_id_map_(frame_id_map), | |
| 22 media_ssrc_(media_ssrc), | |
| 23 decoder_faster_than_max_frame_rate_(decoder_faster_than_max_frame_rate), | |
| 24 max_unacked_frames_(max_unacked_frames), | |
| 25 cast_msg_(media_ssrc), | |
| 26 slowing_down_ack_(false), | |
| 27 acked_last_frame_(true), | |
| 28 last_acked_frame_id_(kStartFrameId) { | |
| 29 cast_msg_.ack_frame_id_ = kStartFrameId; | |
| 30 } | |
| 31 | |
| 32 CastMessageBuilder::~CastMessageBuilder() {} | |
| 33 | |
| 34 void CastMessageBuilder::CompleteFrameReceived(uint32 frame_id) { | |
| 35 DCHECK_GE(static_cast<int32>(frame_id - last_acked_frame_id_), 0); | |
| 36 VLOG(2) << "CompleteFrameReceived: " << frame_id; | |
| 37 if (last_update_time_.is_null()) { | |
| 38 // Our first update. | |
| 39 last_update_time_ = clock_->NowTicks(); | |
| 40 } | |
| 41 | |
| 42 if (!UpdateAckMessage(frame_id)) { | |
| 43 return; | |
| 44 } | |
| 45 BuildPacketList(); | |
| 46 | |
| 47 // Send cast message. | |
| 48 VLOG(2) << "Send cast message Ack:" << static_cast<int>(frame_id); | |
| 49 cast_feedback_->CastFeedback(cast_msg_); | |
| 50 } | |
| 51 | |
| 52 bool CastMessageBuilder::UpdateAckMessage(uint32 frame_id) { | |
| 53 if (!decoder_faster_than_max_frame_rate_) { | |
| 54 int complete_frame_count = frame_id_map_->NumberOfCompleteFrames(); | |
| 55 if (complete_frame_count > max_unacked_frames_) { | |
| 56 // We have too many frames pending in our framer; slow down ACK. | |
| 57 if (!slowing_down_ack_) { | |
| 58 slowing_down_ack_ = true; | |
| 59 ack_queue_.push_back(last_acked_frame_id_); | |
| 60 } | |
| 61 } else if (complete_frame_count <= 1) { | |
| 62 // We are down to one or less frames in our framer; ACK normally. | |
| 63 slowing_down_ack_ = false; | |
| 64 ack_queue_.clear(); | |
| 65 } | |
| 66 } | |
| 67 | |
| 68 if (slowing_down_ack_) { | |
| 69 // We are slowing down acknowledgment by acknowledging every other frame. | |
| 70 // Note: frame skipping and slowdown ACK is not supported at the same | |
| 71 // time; and it's not needed since we can skip frames to catch up. | |
| 72 if (!ack_queue_.empty() && ack_queue_.back() == frame_id) { | |
| 73 return false; | |
| 74 } | |
| 75 ack_queue_.push_back(frame_id); | |
| 76 if (!acked_last_frame_) { | |
| 77 ack_queue_.pop_front(); | |
| 78 } | |
| 79 frame_id = ack_queue_.front(); | |
| 80 } | |
| 81 | |
| 82 acked_last_frame_ = false; | |
| 83 // Is it a new frame? | |
| 84 if (last_acked_frame_id_ == frame_id) { | |
| 85 return false; | |
| 86 } | |
| 87 acked_last_frame_ = true; | |
| 88 last_acked_frame_id_ = frame_id; | |
| 89 cast_msg_.ack_frame_id_ = last_acked_frame_id_; | |
| 90 cast_msg_.missing_frames_and_packets_.clear(); | |
| 91 last_update_time_ = clock_->NowTicks(); | |
| 92 return true; | |
| 93 } | |
| 94 | |
| 95 bool CastMessageBuilder::TimeToSendNextCastMessage( | |
| 96 base::TimeTicks* time_to_send) { | |
| 97 // We haven't received any packets. | |
| 98 if (last_update_time_.is_null() && frame_id_map_->Empty()) | |
| 99 return false; | |
| 100 | |
| 101 *time_to_send = last_update_time_ + base::TimeDelta::FromMilliseconds( | |
| 102 kCastMessageUpdateIntervalMs); | |
| 103 return true; | |
| 104 } | |
| 105 | |
| 106 void CastMessageBuilder::UpdateCastMessage() { | |
| 107 RtcpCastMessage message(media_ssrc_); | |
| 108 if (!UpdateCastMessageInternal(&message)) | |
| 109 return; | |
| 110 | |
| 111 // Send cast message. | |
| 112 cast_feedback_->CastFeedback(message); | |
| 113 } | |
| 114 | |
| 115 void CastMessageBuilder::Reset() { | |
| 116 cast_msg_.ack_frame_id_ = kStartFrameId; | |
| 117 cast_msg_.missing_frames_and_packets_.clear(); | |
| 118 time_last_nacked_map_.clear(); | |
| 119 } | |
| 120 | |
| 121 bool CastMessageBuilder::UpdateCastMessageInternal(RtcpCastMessage* message) { | |
| 122 if (last_update_time_.is_null()) { | |
| 123 if (!frame_id_map_->Empty()) { | |
| 124 // We have received packets. | |
| 125 last_update_time_ = clock_->NowTicks(); | |
| 126 } | |
| 127 return false; | |
| 128 } | |
| 129 // Is it time to update the cast message? | |
| 130 base::TimeTicks now = clock_->NowTicks(); | |
| 131 if (now - last_update_time_ < | |
| 132 base::TimeDelta::FromMilliseconds(kCastMessageUpdateIntervalMs)) { | |
| 133 return false; | |
| 134 } | |
| 135 last_update_time_ = now; | |
| 136 | |
| 137 // Needed to cover when a frame is skipped. | |
| 138 UpdateAckMessage(last_acked_frame_id_); | |
| 139 BuildPacketList(); | |
| 140 message->Copy(cast_msg_); | |
| 141 return true; | |
| 142 } | |
| 143 | |
| 144 void CastMessageBuilder::BuildPacketList() { | |
| 145 base::TimeTicks now = clock_->NowTicks(); | |
| 146 | |
| 147 // Clear message NACK list. | |
| 148 cast_msg_.missing_frames_and_packets_.clear(); | |
| 149 | |
| 150 // Are we missing packets? | |
| 151 if (frame_id_map_->Empty()) | |
| 152 return; | |
| 153 | |
| 154 uint32 newest_frame_id = frame_id_map_->NewestFrameId(); | |
| 155 uint32 next_expected_frame_id = cast_msg_.ack_frame_id_ + 1; | |
| 156 | |
| 157 // Iterate over all frames. | |
| 158 for (; !IsNewerFrameId(next_expected_frame_id, newest_frame_id); | |
| 159 ++next_expected_frame_id) { | |
| 160 TimeLastNackMap::iterator it = | |
| 161 time_last_nacked_map_.find(next_expected_frame_id); | |
| 162 if (it != time_last_nacked_map_.end()) { | |
| 163 // We have sent a NACK in this frame before, make sure enough time have | |
| 164 // passed. | |
| 165 if (now - it->second < | |
| 166 base::TimeDelta::FromMilliseconds(kNackRepeatIntervalMs)) { | |
| 167 continue; | |
| 168 } | |
| 169 } | |
| 170 | |
| 171 PacketIdSet missing; | |
| 172 if (frame_id_map_->FrameExists(next_expected_frame_id)) { | |
| 173 bool last_frame = (newest_frame_id == next_expected_frame_id); | |
| 174 frame_id_map_->GetMissingPackets( | |
| 175 next_expected_frame_id, last_frame, &missing); | |
| 176 if (!missing.empty()) { | |
| 177 time_last_nacked_map_[next_expected_frame_id] = now; | |
| 178 cast_msg_.missing_frames_and_packets_.insert( | |
| 179 std::make_pair(next_expected_frame_id, missing)); | |
| 180 } | |
| 181 } else { | |
| 182 time_last_nacked_map_[next_expected_frame_id] = now; | |
| 183 missing.insert(kRtcpCastAllPacketsLost); | |
| 184 cast_msg_.missing_frames_and_packets_[next_expected_frame_id] = missing; | |
| 185 } | |
| 186 } | |
| 187 } | |
| 188 | |
| 189 } // namespace cast | |
| 190 } // namespace media | |
| OLD | NEW |