blob: f1611d2290ac0ac4a49f6f599515f868a3ba0d88 [file] [log] [blame]
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "media/cast/test/receiver/cast_message_builder.h"
#include "base/logging.h"
#include "media/cast/constants.h"
#include "media/cast/test/receiver/framer.h"
namespace media {
namespace cast {
namespace {
// TODO(miu): These should probably be dynamic and computed base on configured
// end-to-end latency and packet loss rates. http://crbug.com/563784
enum {
// Number of milliseconds between sending of ACK/NACK Cast Message RTCP
// packets back to the sender.
kCastMessageUpdateIntervalMs = 33,
// Number of milliseconds between repeating a NACK for packets in the same
// frame.
kNackRepeatIntervalMs = 30,
};
} // namespace
CastMessageBuilder::CastMessageBuilder(
const base::TickClock* clock,
RtpPayloadFeedback* incoming_payload_feedback,
const Framer* framer,
uint32_t media_ssrc,
bool decoder_faster_than_max_frame_rate,
int max_unacked_frames)
: clock_(clock),
cast_feedback_(incoming_payload_feedback),
framer_(framer),
media_ssrc_(media_ssrc),
decoder_faster_than_max_frame_rate_(decoder_faster_than_max_frame_rate),
max_unacked_frames_(max_unacked_frames),
cast_msg_(media_ssrc),
slowing_down_ack_(false),
acked_last_frame_(true) {
cast_msg_.ack_frame_id = FrameId::first() - 1;
}
CastMessageBuilder::~CastMessageBuilder() = default;
void CastMessageBuilder::CompleteFrameReceived(FrameId frame_id) {
DCHECK_GE(frame_id, last_acked_frame_id());
VLOG(2) << "CompleteFrameReceived: " << frame_id;
if (last_update_time_.is_null()) {
// Our first update.
last_update_time_ = clock_->NowTicks();
}
if (!UpdateAckMessage(frame_id)) {
return;
}
BuildPacketList();
// Send cast message.
VLOG(2) << "Send cast message Ack:" << frame_id;
cast_feedback_->CastFeedback(cast_msg_);
}
bool CastMessageBuilder::UpdateAckMessage(FrameId frame_id) {
if (!decoder_faster_than_max_frame_rate_) {
int complete_frame_count = framer_->NumberOfCompleteFrames();
if (complete_frame_count > max_unacked_frames_) {
// We have too many frames pending in our framer; slow down ACK.
if (!slowing_down_ack_) {
slowing_down_ack_ = true;
ack_queue_.push_back(last_acked_frame_id());
}
} else if (complete_frame_count <= 1) {
// We are down to one or less frames in our framer; ACK normally.
slowing_down_ack_ = false;
ack_queue_.clear();
}
}
if (slowing_down_ack_) {
// We are slowing down acknowledgment by acknowledging every other frame.
// Note: frame skipping and slowdown ACK is not supported at the same
// time; and it's not needed since we can skip frames to catch up.
if (!ack_queue_.empty() && ack_queue_.back() == frame_id) {
return false;
}
ack_queue_.push_back(frame_id);
if (!acked_last_frame_) {
ack_queue_.pop_front();
}
frame_id = ack_queue_.front();
}
// Is it a new frame?
if (last_acked_frame_id() == frame_id) {
acked_last_frame_ = false;
return false;
}
acked_last_frame_ = true;
cast_msg_.ack_frame_id = frame_id;
cast_msg_.missing_frames_and_packets.clear();
last_update_time_ = clock_->NowTicks();
time_last_nacked_map_.erase(
time_last_nacked_map_.begin(),
time_last_nacked_map_.upper_bound(last_acked_frame_id()));
return true;
}
bool CastMessageBuilder::TimeToSendNextCastMessage(
base::TimeTicks* time_to_send) {
// We haven't received any packets.
if (last_update_time_.is_null() && framer_->Empty())
return false;
*time_to_send =
last_update_time_ + base::Milliseconds(kCastMessageUpdateIntervalMs);
return true;
}
void CastMessageBuilder::UpdateCastMessage() {
RtcpCastMessage message(media_ssrc_);
if (!UpdateCastMessageInternal(&message))
return;
// Send cast message.
cast_feedback_->CastFeedback(message);
}
bool CastMessageBuilder::UpdateCastMessageInternal(RtcpCastMessage* message) {
if (last_update_time_.is_null()) {
if (!framer_->Empty()) {
// We have received packets.
last_update_time_ = clock_->NowTicks();
}
return false;
}
// Is it time to update the cast message?
base::TimeTicks now = clock_->NowTicks();
if (now - last_update_time_ <
base::Milliseconds(kCastMessageUpdateIntervalMs)) {
return false;
}
last_update_time_ = now;
// Needed to cover when a frame is skipped.
UpdateAckMessage(last_acked_frame_id());
BuildPacketList();
*message = cast_msg_;
return true;
}
void CastMessageBuilder::BuildPacketList() {
base::TimeTicks now = clock_->NowTicks();
// Clear message NACK list.
cast_msg_.missing_frames_and_packets.clear();
// Are we missing packets?
if (framer_->Empty())
return;
const FrameId newest_frame_id = framer_->newest_frame_id();
FrameId next_expected_frame_id = last_acked_frame_id() + 1;
// Iterate over all frames.
for (; next_expected_frame_id <= newest_frame_id; ++next_expected_frame_id) {
const auto it = time_last_nacked_map_.find(next_expected_frame_id);
if (it != time_last_nacked_map_.end()) {
// We have sent a NACK in this frame before, make sure enough time have
// passed.
if (now - it->second < base::Milliseconds(kNackRepeatIntervalMs)) {
continue;
}
}
PacketIdSet missing;
if (framer_->FrameExists(next_expected_frame_id)) {
bool last_frame = (newest_frame_id == next_expected_frame_id);
framer_->GetMissingPackets(next_expected_frame_id, last_frame, &missing);
if (!missing.empty()) {
time_last_nacked_map_[next_expected_frame_id] = now;
cast_msg_.missing_frames_and_packets.insert(
std::make_pair(next_expected_frame_id, missing));
}
} else {
time_last_nacked_map_[next_expected_frame_id] = now;
missing.insert(kRtcpCastAllPacketsLost);
cast_msg_.missing_frames_and_packets[next_expected_frame_id] = missing;
}
}
}
} // namespace cast
} // namespace media