class LocalRtcpRttFeedback : public RtcpRttFeedback {
public:
- explicit LocalRtcpRttFeedback(Rtcp* rtcp)
- : rtcp_(rtcp) {
- }
+ explicit LocalRtcpRttFeedback(Rtcp* rtcp) : rtcp_(rtcp) {}
virtual void OnReceivedDelaySinceLastReport(
- uint32 receivers_ssrc,
- uint32 last_report,
+ uint32 receivers_ssrc, uint32 last_report,
uint32 delay_since_last_report) OVERRIDE {
- rtcp_->OnReceivedDelaySinceLastReport(receivers_ssrc,
- last_report,
+ rtcp_->OnReceivedDelaySinceLastReport(receivers_ssrc, last_report,
delay_since_last_report);
}
Rtcp* rtcp_;
};
-RtcpCastMessage::RtcpCastMessage(uint32 media_ssrc)
- : media_ssrc_(media_ssrc) {}
-
-RtcpCastMessage::~RtcpCastMessage() {}
-
-RtcpNackMessage::RtcpNackMessage() {}
-RtcpNackMessage::~RtcpNackMessage() {}
-
-RtcpRembMessage::RtcpRembMessage() {}
-RtcpRembMessage::~RtcpRembMessage() {}
-
-RtcpReceiverFrameLogMessage::RtcpReceiverFrameLogMessage(uint32 timestamp)
- : rtp_timestamp_(timestamp) {}
-
-RtcpReceiverFrameLogMessage::~RtcpReceiverFrameLogMessage() {}
-
class LocalRtcpReceiverFeedback : public RtcpReceiverFeedback {
public:
LocalRtcpReceiverFeedback(Rtcp* rtcp,
scoped_refptr<CastEnvironment> cast_environment)
- : rtcp_(rtcp), cast_environment_(cast_environment) {
- }
+ : rtcp_(rtcp), cast_environment_(cast_environment) {}
virtual void OnReceivedSenderReport(
const transport::RtcpSenderInfo& remote_sender_info) OVERRIDE {
rtcp_->OnReceivedSendReportRequest();
}
- virtual void OnReceivedReceiverLog(
- const RtcpReceiverLogMessage& receiver_log) OVERRIDE {
+ virtual void OnReceivedReceiverLog(const RtcpReceiverLogMessage& receiver_log)
+ OVERRIDE {
// Add received log messages into our log system.
RtcpReceiverLogMessage::const_iterator it = receiver_log.begin();
switch (event_it->type) {
case kAudioPacketReceived:
case kVideoPacketReceived:
- case kDuplicatePacketReceived:
+ case kDuplicateAudioPacketReceived:
+ case kDuplicateVideoPacketReceived:
cast_environment_->Logging()->InsertPacketEvent(
event_it->event_timestamp, event_it->type, rtp_timestamp,
kFrameIdUnknown, event_it->packet_id, 0, 0);
}
virtual void OnReceivedSenderLog(
- const transport::RtcpSenderLogMessage& sender_log) OVERRIDE {
+ const transport::RtcpSenderLogMessage& sender_log) OVERRIDE {
transport::RtcpSenderLogMessage::const_iterator it = sender_log.begin();
for (; it != sender_log.end(); ++it) {
// TODO(pwestin): how do we handle the time? we don't care about it but
// we need to send in one.
base::TimeTicks now = cast_environment_->Clock()->NowTicks();
- cast_environment_->Logging()->InsertFrameEvent(now, log_event,
- rtp_timestamp, kFrameIdUnknown);
+ cast_environment_->Logging()->InsertFrameEvent(
+ now, log_event, rtp_timestamp, kFrameIdUnknown);
}
}
transport::CastTransportSender* const transport_sender,
transport::PacedPacketSender* paced_packet_sender,
RtpSenderStatistics* rtp_sender_statistics,
- RtpReceiverStatistics* rtp_receiver_statistics,
- RtcpMode rtcp_mode,
- const base::TimeDelta& rtcp_interval,
- uint32 local_ssrc,
- uint32 remote_ssrc,
- const std::string& c_name)
+ RtpReceiverStatistics* rtp_receiver_statistics, RtcpMode rtcp_mode,
+ const base::TimeDelta& rtcp_interval, uint32 local_ssrc,
+ uint32 remote_ssrc, const std::string& c_name)
: cast_environment_(cast_environment),
transport_sender_(transport_sender),
rtcp_interval_(rtcp_interval),
last_received_ntp_fraction_(0),
min_rtt_(base::TimeDelta::FromMilliseconds(kMaxRttMs)),
number_of_rtt_in_avg_(0) {
- rtcp_receiver_.reset(new RtcpReceiver(cast_environment,
- sender_feedback,
+ rtcp_receiver_.reset(new RtcpReceiver(cast_environment, sender_feedback,
receiver_feedback_.get(),
- rtt_feedback_.get(),
- local_ssrc));
+ rtt_feedback_.get(), local_ssrc));
rtcp_receiver_->SetRemoteSSRC(remote_ssrc);
}
rtcp_receiver_->IncomingRtcpPacket(&rtcp_parser);
}
-void Rtcp::SendRtcpFromRtpReceiver(const RtcpCastMessage* cast_message,
- RtcpReceiverLogMessage* receiver_log) {
+void Rtcp::SendRtcpFromRtpReceiver(
+ const RtcpCastMessage* cast_message,
+ ReceiverRtcpEventSubscriber* event_subscriber) {
DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
uint32 packet_type_flags = 0;
if (cast_message) {
packet_type_flags |= RtcpSender::kRtcpCast;
}
- if (receiver_log) {
+ if (event_subscriber) {
packet_type_flags |= RtcpSender::kRtcpReceiverLog;
}
if (rtcp_mode_ == kRtcpCompound || now >= next_time_to_send_rtcp_) {
packet_type_flags |= RtcpSender::kRtcpRr;
- report_block.remote_ssrc = 0; // Not needed to set send side.
+ report_block.remote_ssrc = 0; // Not needed to set send side.
report_block.media_ssrc = remote_ssrc_; // SSRC of the RTP packet sender.
if (rtp_receiver_statistics_) {
rtp_receiver_statistics_->GetStatistics(
- &report_block.fraction_lost,
- &report_block.cumulative_lost,
- &report_block.extended_high_sequence_number,
- &report_block.jitter);
+ &report_block.fraction_lost, &report_block.cumulative_lost,
+ &report_block.extended_high_sequence_number, &report_block.jitter);
cast_environment_->Logging()->InsertGenericEvent(now, kJitterMs,
- report_block.jitter);
- cast_environment_->Logging()->InsertGenericEvent(now, kPacketLoss,
- report_block.fraction_lost);
+ report_block.jitter);
+ cast_environment_->Logging()->InsertGenericEvent(
+ now, kPacketLoss, report_block.fraction_lost);
}
report_block.last_sr = last_report_received_;
uint32 delay_seconds = 0;
uint32 delay_fraction = 0;
base::TimeDelta delta = now - time_last_report_received_;
- ConvertTimeToFractions(delta.InMicroseconds(),
- &delay_seconds,
+ ConvertTimeToFractions(delta.InMicroseconds(), &delay_seconds,
&delay_fraction);
report_block.delay_since_last_sr =
ConvertToNtpDiff(delay_seconds, delay_fraction);
SaveLastSentNtpTime(now, rrtr.ntp_seconds, rrtr.ntp_fraction);
UpdateNextTimeToSendRtcp();
}
- rtcp_sender_->SendRtcpFromRtpReceiver(packet_type_flags,
- &report_block,
- &rrtr,
- cast_message,
- receiver_log);
+ rtcp_sender_->SendRtcpFromRtpReceiver(
+ packet_type_flags, &report_block, &rrtr, cast_message, event_subscriber);
}
void Rtcp::SendRtcpFromRtpSender(
uint32 delay_seconds = 0;
uint32 delay_fraction = 0;
base::TimeDelta delta = now - time_last_report_received_;
- ConvertTimeToFractions(delta.InMicroseconds(),
- &delay_seconds,
+ ConvertTimeToFractions(delta.InMicroseconds(), &delay_seconds,
&delay_fraction);
dlrr.delay_since_last_rr = ConvertToNtpDiff(delay_seconds, delay_fraction);
}
- cast_environment_->PostTask(CastEnvironment::TRANSPORT, FROM_HERE,
+ cast_environment_->PostTask(
+ CastEnvironment::TRANSPORT, FROM_HERE,
base::Bind(&Rtcp::SendRtcpFromRtpSenderOnTransportThread,
base::Unretained(this), packet_type_flags, sender_info, dlrr,
sender_log_message, local_ssrc_, c_name_));
}
void Rtcp::SendRtcpFromRtpSenderOnTransportThread(
- uint32 packet_type_flags,
- const transport::RtcpSenderInfo& sender_info,
+ uint32 packet_type_flags, const transport::RtcpSenderInfo& sender_info,
const transport::RtcpDlrrReportBlock& dlrr,
- const transport::RtcpSenderLogMessage& sender_log,
- uint32 sending_ssrc,
+ const transport::RtcpSenderLogMessage& sender_log, uint32 sending_ssrc,
std::string c_name) {
DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::TRANSPORT));
- transport_sender_->SendRtcpFromRtpSender(packet_type_flags,
- sender_info,
- dlrr,
- sender_log,
- sending_ssrc,
- c_name);
-
+ transport_sender_->SendRtcpFromRtpSender(packet_type_flags, sender_info, dlrr,
+ sender_log, sending_ssrc, c_name);
}
void Rtcp::OnReceivedNtp(uint32 ntp_seconds, uint32 ntp_fraction) {
time_last_report_received_ = now;
}
-void Rtcp::OnReceivedLipSyncInfo(uint32 rtp_timestamp,
- uint32 ntp_seconds,
+void Rtcp::OnReceivedLipSyncInfo(uint32 rtp_timestamp, uint32 ntp_seconds,
uint32 ntp_fraction) {
last_received_rtp_timestamp_ = rtp_timestamp;
last_received_ntp_seconds_ = ntp_seconds;
}
bool Rtcp::RtpTimestampInSenderTime(int frequency, uint32 rtp_timestamp,
- base::TimeTicks* rtp_timestamp_in_ticks) const {
- if (last_received_ntp_seconds_ == 0) return false;
+ base::TimeTicks* rtp_timestamp_in_ticks)
+ const {
+ if (last_received_ntp_seconds_ == 0)
+ return false;
int wrap = CheckForWrapAround(rtp_timestamp, last_received_rtp_timestamp_);
int64 rtp_timestamp_int64 = rtp_timestamp;
int64 rtp_time_diff_ms = rtp_timestamp_diff / frequency_khz;
// Sanity check.
- if (abs(rtp_time_diff_ms) > kMaxDiffSinceReceivedRtcpMs) return false;
+ if (abs(rtp_time_diff_ms) > kMaxDiffSinceReceivedRtcpMs)
+ return false;
*rtp_timestamp_in_ticks = ConvertNtpToTimeTicks(last_received_ntp_seconds_,
- last_received_ntp_fraction_) +
- base::TimeDelta::FromMilliseconds(rtp_time_diff_ms);
+ last_received_ntp_fraction_) +
+ base::TimeDelta::FromMilliseconds(rtp_time_diff_ms);
return true;
}
return; // Feedback on another report.
}
- base::TimeDelta sender_delay = cast_environment_->Clock()->NowTicks()
- - it->second;
+ base::TimeDelta sender_delay =
+ cast_environment_->Clock()->NowTicks() - it->second;
UpdateRtt(sender_delay, ConvertFromNtpDiff(delay_since_last_report));
}
uint32 last_ntp_fraction) {
// Make sure |now| is always greater than the last element in
// |last_reports_sent_queue_|.
- if (!last_reports_sent_queue_.empty()) {
+ if (!last_reports_sent_queue_.empty())
DCHECK(now >= last_reports_sent_queue_.back().second);
- }
uint32 last_report = ConvertToNtpDiff(last_ntp_seconds, last_ntp_fraction);
last_reports_sent_map_[last_report] = now;
if (number_of_rtt_in_avg_ != 0) {
float ac = static_cast<float>(number_of_rtt_in_avg_);
- avg_rtt_ms_= ((ac / (ac + 1.0)) * avg_rtt_ms_) +
- ((1.0 / (ac + 1.0)) * rtt.InMilliseconds());
+ avg_rtt_ms_ = ((ac / (ac + 1.0)) * avg_rtt_ms_) +
+ ((1.0 / (ac + 1.0)) * rtt.InMilliseconds());
} else {
avg_rtt_ms_ = rtt.InMilliseconds();
}
number_of_rtt_in_avg_++;
}
-bool Rtcp::Rtt(base::TimeDelta* rtt,
- base::TimeDelta* avg_rtt,
- base::TimeDelta* min_rtt,
- base::TimeDelta* max_rtt) const {
+bool Rtcp::Rtt(base::TimeDelta* rtt, base::TimeDelta* avg_rtt,
+ base::TimeDelta* min_rtt, base::TimeDelta* max_rtt) const {
DCHECK(rtt) << "Invalid argument";
DCHECK(avg_rtt) << "Invalid argument";
DCHECK(min_rtt) << "Invalid argument";
return true;
}
-int Rtcp::CheckForWrapAround(uint32 new_timestamp,
- uint32 old_timestamp) const {
+int Rtcp::CheckForWrapAround(uint32 new_timestamp, uint32 old_timestamp) const {
if (new_timestamp < old_timestamp) {
// This difference should be less than -2^31 if we have had a wrap around
// (e.g. |new_timestamp| = 1, |rtcp_rtp_timestamp| = 2^32 - 1). Since it is
void Rtcp::UpdateNextTimeToSendRtcp() {
int random = base::RandInt(0, 999);
- base::TimeDelta time_to_next = (rtcp_interval_ / 2) +
- (rtcp_interval_ * random / 1000);
+ base::TimeDelta time_to_next =
+ (rtcp_interval_ / 2) + (rtcp_interval_ * random / 1000);
base::TimeTicks now = cast_environment_->Clock()->NowTicks();
next_time_to_send_rtcp_ = now + time_to_next;
projects / platform / framework / web / crosswalk.git / blobdiff