diff options
Diffstat (limited to 'media')
50 files changed, 689 insertions, 752 deletions
diff --git a/media/cast/audio_receiver/audio_receiver.cc b/media/cast/audio_receiver/audio_receiver.cc index 94abdff..212419c 100644 --- a/media/cast/audio_receiver/audio_receiver.cc +++ b/media/cast/audio_receiver/audio_receiver.cc @@ -26,8 +26,7 @@ AudioReceiver::AudioReceiver(scoped_refptr<CastEnvironment> cast_environment, transport::PacedPacketSender* const packet_sender) : RtpReceiver(cast_environment->Clock(), &audio_config, NULL), cast_environment_(cast_environment), - event_subscriber_(kReceiverRtcpEventHistorySize, - ReceiverRtcpEventSubscriber::kAudioEventSubscriber), + event_subscriber_(kReceiverRtcpEventHistorySize, AUDIO_EVENT), codec_(audio_config.codec), frequency_(audio_config.frequency), target_delay_delta_( @@ -46,7 +45,8 @@ AudioReceiver::AudioReceiver(scoped_refptr<CastEnvironment> cast_environment, base::TimeDelta::FromMilliseconds(audio_config.rtcp_interval), audio_config.feedback_ssrc, audio_config.incoming_ssrc, - audio_config.rtcp_c_name), + audio_config.rtcp_c_name, + true), is_waiting_for_consecutive_frame_(false), weak_factory_(this) { if (!audio_config.use_external_decoder) @@ -84,26 +84,16 @@ void AudioReceiver::OnReceivedPayloadData(const uint8* payload_data, frame_id_to_rtp_timestamp_[rtp_header.frame_id & 0xff] = rtp_header.rtp_timestamp; cast_environment_->Logging()->InsertPacketEvent( - now, kAudioPacketReceived, rtp_header.rtp_timestamp, + now, PACKET_RECEIVED, AUDIO_EVENT, rtp_header.rtp_timestamp, rtp_header.frame_id, rtp_header.packet_id, rtp_header.max_packet_id, payload_size); bool duplicate = false; const bool complete = framer_.InsertPacket(payload_data, payload_size, rtp_header, &duplicate); - if (duplicate) { - cast_environment_->Logging()->InsertPacketEvent( - now, - kDuplicateAudioPacketReceived, - rtp_header.rtp_timestamp, - rtp_header.frame_id, - rtp_header.packet_id, - rtp_header.max_packet_id, - payload_size); - // Duplicate packets are ignored. - return; - } - if (!complete) + + // Duplicate packets are ignored. + if (duplicate || !complete) return; EmitAvailableEncodedFrames(); @@ -155,9 +145,9 @@ void AudioReceiver::EmitRawAudioFrame( if (audio_bus.get()) { const base::TimeTicks now = cast_environment->Clock()->NowTicks(); cast_environment->Logging()->InsertFrameEvent( - now, kAudioFrameDecoded, rtp_timestamp, frame_id); + now, FRAME_DECODED, AUDIO_EVENT, rtp_timestamp, frame_id); cast_environment->Logging()->InsertFrameEventWithDelay( - now, kAudioPlayoutDelay, rtp_timestamp, frame_id, + now, FRAME_PLAYOUT, AUDIO_EVENT, rtp_timestamp, frame_id, playout_time - now); } callback.Run(audio_bus.Pass(), playout_time, is_continuous); @@ -266,7 +256,8 @@ void AudioReceiver::CastFeedback(const RtcpCastMessage& cast_message) { RtpTimestamp rtp_timestamp = frame_id_to_rtp_timestamp_[cast_message.ack_frame_id_ & 0xff]; cast_environment_->Logging()->InsertFrameEvent( - now, kAudioAckSent, rtp_timestamp, cast_message.ack_frame_id_); + now, FRAME_ACK_SENT, AUDIO_EVENT, rtp_timestamp, + cast_message.ack_frame_id_); ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events; event_subscriber_.GetRtcpEventsAndReset(&rtcp_events); diff --git a/media/cast/audio_receiver/audio_receiver.h b/media/cast/audio_receiver/audio_receiver.h index 6aae136..5cc8f88 100644 --- a/media/cast/audio_receiver/audio_receiver.h +++ b/media/cast/audio_receiver/audio_receiver.h @@ -168,7 +168,7 @@ class AudioReceiver : public RtpReceiver, // EmitAvailableEncodedFrames(). bool is_waiting_for_consecutive_frame_; - // This mapping allows us to log kAudioAckSent as a frame event. In addition + // This mapping allows us to log AUDIO_ACK_SENT as a frame event. In addition // it allows the event to be transmitted via RTCP. RtpTimestamp frame_id_to_rtp_timestamp_[256]; diff --git a/media/cast/audio_receiver/audio_receiver_unittest.cc b/media/cast/audio_receiver/audio_receiver_unittest.cc index 8b7e706..f2725ff 100644 --- a/media/cast/audio_receiver/audio_receiver_unittest.cc +++ b/media/cast/audio_receiver/audio_receiver_unittest.cc @@ -141,7 +141,8 @@ TEST_F(AudioReceiverTest, GetOnePacketEncodedFrame) { event_subscriber.GetFrameEventsAndReset(&frame_events); ASSERT_TRUE(!frame_events.empty()); - EXPECT_EQ(kAudioAckSent, frame_events.begin()->type); + EXPECT_EQ(FRAME_ACK_SENT, frame_events.begin()->type); + EXPECT_EQ(AUDIO_EVENT, frame_events.begin()->media_type); EXPECT_EQ(rtp_header_.frame_id, frame_events.begin()->frame_id); EXPECT_EQ(rtp_header_.rtp_timestamp, frame_events.begin()->rtp_timestamp); diff --git a/media/cast/audio_sender/audio_encoder.cc b/media/cast/audio_sender/audio_encoder.cc index 6f31726..f5739f7 100644 --- a/media/cast/audio_sender/audio_encoder.cc +++ b/media/cast/audio_sender/audio_encoder.cc @@ -49,7 +49,8 @@ void LogAudioFrameEncodedEvent( return; } cast_environment->Logging()->InsertEncodedFrameEvent( - event_time, kAudioFrameEncoded, rtp_timestamp, frame_id, + event_time, media::cast::FRAME_ENCODED, media::cast::AUDIO_EVENT, + rtp_timestamp, frame_id, static_cast<int>(frame_size), /* key_frame - unused */ false, /*target_bitrate - unused*/ 0); } diff --git a/media/cast/audio_sender/audio_sender.cc b/media/cast/audio_sender/audio_sender.cc index c0393b8..0e266c7 100644 --- a/media/cast/audio_sender/audio_sender.cc +++ b/media/cast/audio_sender/audio_sender.cc @@ -52,7 +52,8 @@ AudioSender::AudioSender(scoped_refptr<CastEnvironment> cast_environment, base::TimeDelta::FromMilliseconds(audio_config.rtcp_interval), audio_config.rtp_config.ssrc, audio_config.incoming_feedback_ssrc, - audio_config.rtcp_c_name), + audio_config.rtcp_c_name, + true), timers_initialized_(false), cast_initialization_cb_(STATUS_AUDIO_UNINITIALIZED), weak_factory_(this) { diff --git a/media/cast/logging/encoding_event_subscriber.cc b/media/cast/logging/encoding_event_subscriber.cc index 2ccf731..e2eb37a 100644 --- a/media/cast/logging/encoding_event_subscriber.cc +++ b/media/cast/logging/encoding_event_subscriber.cc @@ -62,7 +62,7 @@ void EncodingEventSubscriber::OnReceiveFrameEvent( const FrameEvent& frame_event) { DCHECK(thread_checker_.CalledOnValidThread()); - if (!ShouldProcessEvent(frame_event.type)) + if (event_media_type_ != frame_event.media_type) return; RtpTimestamp relative_rtp_timestamp = @@ -92,14 +92,14 @@ void EncodingEventSubscriber::OnReceiveFrameEvent( event_proto->add_event_timestamp_ms( (frame_event.timestamp - base::TimeTicks()).InMilliseconds()); - if (frame_event.type == kAudioFrameEncoded) { + if (frame_event.type == FRAME_ENCODED) { event_proto->set_encoded_frame_size(frame_event.size); - } else if (frame_event.type == kVideoFrameEncoded) { - event_proto->set_encoded_frame_size(frame_event.size); - event_proto->set_key_frame(frame_event.key_frame); - event_proto->set_target_bitrate(frame_event.target_bitrate); - } else if (frame_event.type == kAudioPlayoutDelay || - frame_event.type == kVideoRenderDelay) { + if (frame_event.media_type == VIDEO_EVENT) { + event_proto->set_encoded_frame_size(frame_event.size); + event_proto->set_key_frame(frame_event.key_frame); + event_proto->set_target_bitrate(frame_event.target_bitrate); + } + } else if (frame_event.type == FRAME_PLAYOUT) { event_proto->set_delay_millis(frame_event.delay_delta.InMilliseconds()); } @@ -114,7 +114,7 @@ void EncodingEventSubscriber::OnReceivePacketEvent( const PacketEvent& packet_event) { DCHECK(thread_checker_.CalledOnValidThread()); - if (!ShouldProcessEvent(packet_event.type)) + if (event_media_type_ != packet_event.media_type) return; RtpTimestamp relative_rtp_timestamp = GetRelativeRtpTimestamp(packet_event.rtp_timestamp); @@ -208,10 +208,6 @@ void EncodingEventSubscriber::GetEventsAndReset(LogMetadata* metadata, Reset(); } -bool EncodingEventSubscriber::ShouldProcessEvent(CastLoggingEvent event) { - return GetEventMediaType(event) == event_media_type_; -} - void EncodingEventSubscriber::TransferFrameEvents(size_t max_num_entries) { DCHECK(frame_event_map_.size() >= max_num_entries); diff --git a/media/cast/logging/encoding_event_subscriber.h b/media/cast/logging/encoding_event_subscriber.h index c507499..ca2cccb 100644 --- a/media/cast/logging/encoding_event_subscriber.h +++ b/media/cast/logging/encoding_event_subscriber.h @@ -72,8 +72,6 @@ class EncodingEventSubscriber : public RawEventSubscriber { linked_ptr<media::cast::proto::AggregatedPacketEvent> > PacketEventMap; - bool ShouldProcessEvent(CastLoggingEvent event); - // Transfer up to |max_num_entries| smallest entries from |frame_event_map_| // to |frame_event_storage_|. This helps keep size of |frame_event_map_| small // and lookup speed fast. diff --git a/media/cast/logging/encoding_event_subscriber_unittest.cc b/media/cast/logging/encoding_event_subscriber_unittest.cc index 264ae93..3d77a62 100644 --- a/media/cast/logging/encoding_event_subscriber_unittest.cc +++ b/media/cast/logging/encoding_event_subscriber_unittest.cc @@ -78,11 +78,13 @@ TEST_F(EncodingEventSubscriberTest, FrameEventTruncating) { // Entry with RTP timestamp 0 should get dropped. for (int i = 0; i < 11; i++) { cast_environment_->Logging()->InsertFrameEvent(now, - kVideoFrameCaptureBegin, + FRAME_CAPTURE_BEGIN, + VIDEO_EVENT, i * 100, /*frame_id*/ 0); cast_environment_->Logging()->InsertFrameEvent(now, - kVideoFrameDecoded, + FRAME_DECODED, + VIDEO_EVENT, i * 100, /*frame_id*/ 0); } @@ -102,7 +104,8 @@ TEST_F(EncodingEventSubscriberTest, PacketEventTruncating) { // Entry with RTP timestamp 0 should get dropped. for (int i = 0; i < 11; i++) { cast_environment_->Logging()->InsertPacketEvent(now, - kAudioPacketReceived, + PACKET_RECEIVED, + AUDIO_EVENT, /*rtp_timestamp*/ i * 100, /*frame_id*/ 0, /*packet_id*/ i, @@ -123,13 +126,15 @@ TEST_F(EncodingEventSubscriberTest, EventFiltering) { base::TimeTicks now(testing_clock_->NowTicks()); RtpTimestamp rtp_timestamp = 100; cast_environment_->Logging()->InsertFrameEvent(now, - kVideoFrameDecoded, + FRAME_DECODED, + VIDEO_EVENT, rtp_timestamp, /*frame_id*/ 0); // This is an AUDIO_EVENT and shouldn't be processed by the subscriber. cast_environment_->Logging()->InsertFrameEvent(now, - kAudioFrameDecoded, + FRAME_DECODED, + AUDIO_EVENT, rtp_timestamp, /*frame_id*/ 0); @@ -141,7 +146,7 @@ TEST_F(EncodingEventSubscriberTest, EventFiltering) { linked_ptr<AggregatedFrameEvent> frame_event = *it; ASSERT_EQ(1, frame_event->event_type_size()); - EXPECT_EQ(media::cast::proto::VIDEO_FRAME_DECODED, + EXPECT_EQ(media::cast::proto::FRAME_DECODED, frame_event->event_type(0)); GetEventsAndReset(); @@ -153,7 +158,8 @@ TEST_F(EncodingEventSubscriberTest, FrameEvent) { Init(VIDEO_EVENT); base::TimeTicks now(testing_clock_->NowTicks()); RtpTimestamp rtp_timestamp = 100; - cast_environment_->Logging()->InsertFrameEvent(now, kVideoFrameDecoded, + cast_environment_->Logging()->InsertFrameEvent(now, FRAME_DECODED, + VIDEO_EVENT, rtp_timestamp, /*frame_id*/ 0); @@ -169,7 +175,7 @@ TEST_F(EncodingEventSubscriberTest, FrameEvent) { EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp()); ASSERT_EQ(1, event->event_type_size()); - EXPECT_EQ(media::cast::proto::VIDEO_FRAME_DECODED, event->event_type(0)); + EXPECT_EQ(media::cast::proto::FRAME_DECODED, event->event_type(0)); ASSERT_EQ(1, event->event_timestamp_ms_size()); EXPECT_EQ(InMilliseconds(now), event->event_timestamp_ms(0)); @@ -186,7 +192,7 @@ TEST_F(EncodingEventSubscriberTest, FrameEventDelay) { RtpTimestamp rtp_timestamp = 100; int delay_ms = 100; cast_environment_->Logging()->InsertFrameEventWithDelay( - now, kAudioPlayoutDelay, rtp_timestamp, + now, FRAME_PLAYOUT, AUDIO_EVENT, rtp_timestamp, /*frame_id*/ 0, base::TimeDelta::FromMilliseconds(delay_ms)); GetEventsAndReset(); @@ -201,7 +207,7 @@ TEST_F(EncodingEventSubscriberTest, FrameEventDelay) { EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp()); ASSERT_EQ(1, event->event_type_size()); - EXPECT_EQ(media::cast::proto::AUDIO_PLAYOUT_DELAY, event->event_type(0)); + EXPECT_EQ(media::cast::proto::FRAME_PLAYOUT, event->event_type(0)); ASSERT_EQ(1, event->event_timestamp_ms_size()); EXPECT_EQ(InMilliseconds(now), event->event_timestamp_ms(0)); @@ -218,7 +224,7 @@ TEST_F(EncodingEventSubscriberTest, FrameEventSize) { bool key_frame = true; int target_bitrate = 1024; cast_environment_->Logging()->InsertEncodedFrameEvent( - now, kVideoFrameEncoded, rtp_timestamp, + now, FRAME_ENCODED, VIDEO_EVENT, rtp_timestamp, /*frame_id*/ 0, size, key_frame, target_bitrate); GetEventsAndReset(); @@ -233,7 +239,7 @@ TEST_F(EncodingEventSubscriberTest, FrameEventSize) { EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp()); ASSERT_EQ(1, event->event_type_size()); - EXPECT_EQ(media::cast::proto::VIDEO_FRAME_ENCODED, event->event_type(0)); + EXPECT_EQ(media::cast::proto::FRAME_ENCODED, event->event_type(0)); ASSERT_EQ(1, event->event_timestamp_ms_size()); EXPECT_EQ(InMilliseconds(now), event->event_timestamp_ms(0)); @@ -250,20 +256,20 @@ TEST_F(EncodingEventSubscriberTest, MultipleFrameEvents) { RtpTimestamp rtp_timestamp2 = 200; base::TimeTicks now1(testing_clock_->NowTicks()); cast_environment_->Logging()->InsertFrameEventWithDelay( - now1, kAudioPlayoutDelay, rtp_timestamp1, + now1, FRAME_PLAYOUT, AUDIO_EVENT, rtp_timestamp1, /*frame_id*/ 0, /*delay*/ base::TimeDelta::FromMilliseconds(100)); testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20)); base::TimeTicks now2(testing_clock_->NowTicks()); cast_environment_->Logging()->InsertEncodedFrameEvent( - now2, kAudioFrameEncoded, rtp_timestamp2, + now2, FRAME_ENCODED, AUDIO_EVENT, rtp_timestamp2, /*frame_id*/ 0, /*size*/ 123, /* key_frame - unused */ false, /*target_bitrate - unused*/ 0); testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20)); base::TimeTicks now3(testing_clock_->NowTicks()); cast_environment_->Logging()->InsertFrameEvent( - now3, kAudioFrameDecoded, rtp_timestamp1, /*frame_id*/ 0); + now3, FRAME_DECODED, AUDIO_EVENT, rtp_timestamp1, /*frame_id*/ 0); GetEventsAndReset(); @@ -277,8 +283,8 @@ TEST_F(EncodingEventSubscriberTest, MultipleFrameEvents) { EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp()); ASSERT_EQ(2, event->event_type_size()); - EXPECT_EQ(media::cast::proto::AUDIO_PLAYOUT_DELAY, event->event_type(0)); - EXPECT_EQ(media::cast::proto::AUDIO_FRAME_DECODED, event->event_type(1)); + EXPECT_EQ(media::cast::proto::FRAME_PLAYOUT, event->event_type(0)); + EXPECT_EQ(media::cast::proto::FRAME_DECODED, event->event_type(1)); ASSERT_EQ(2, event->event_timestamp_ms_size()); EXPECT_EQ(InMilliseconds(now1), event->event_timestamp_ms(0)); @@ -294,7 +300,7 @@ TEST_F(EncodingEventSubscriberTest, MultipleFrameEvents) { EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp()); ASSERT_EQ(1, event->event_type_size()); - EXPECT_EQ(media::cast::proto::AUDIO_FRAME_ENCODED, event->event_type(0)); + EXPECT_EQ(media::cast::proto::FRAME_ENCODED, event->event_type(0)); ASSERT_EQ(1, event->event_timestamp_ms_size()); EXPECT_EQ(InMilliseconds(now2), event->event_timestamp_ms(0)); @@ -309,7 +315,8 @@ TEST_F(EncodingEventSubscriberTest, PacketEvent) { int packet_id = 2; int size = 100; cast_environment_->Logging()->InsertPacketEvent( - now, kAudioPacketReceived, rtp_timestamp, /*frame_id*/ 0, packet_id, + now, PACKET_RECEIVED, AUDIO_EVENT, + rtp_timestamp, /*frame_id*/ 0, packet_id, /*max_packet_id*/ 10, size); GetEventsAndReset(); @@ -327,7 +334,7 @@ TEST_F(EncodingEventSubscriberTest, PacketEvent) { const BasePacketEvent& base_event = event->base_packet_event(0); EXPECT_EQ(packet_id, base_event.packet_id()); ASSERT_EQ(1, base_event.event_type_size()); - EXPECT_EQ(media::cast::proto::AUDIO_PACKET_RECEIVED, + EXPECT_EQ(media::cast::proto::PACKET_RECEIVED, base_event.event_type(0)); ASSERT_EQ(1, base_event.event_timestamp_ms_size()); EXPECT_EQ(InMilliseconds(now), base_event.event_timestamp_ms(0)); @@ -344,7 +351,8 @@ TEST_F(EncodingEventSubscriberTest, MultiplePacketEventsForPacket) { int packet_id = 2; int size = 100; cast_environment_->Logging()->InsertPacketEvent(now1, - kVideoPacketSentToNetwork, + PACKET_SENT_TO_NETWORK, + VIDEO_EVENT, rtp_timestamp, /*frame_id*/ 0, packet_id, @@ -354,7 +362,8 @@ TEST_F(EncodingEventSubscriberTest, MultiplePacketEventsForPacket) { testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20)); base::TimeTicks now2(testing_clock_->NowTicks()); cast_environment_->Logging()->InsertPacketEvent(now2, - kVideoPacketRetransmitted, + PACKET_RETRANSMITTED, + VIDEO_EVENT, rtp_timestamp, /*frame_id*/ 0, packet_id, @@ -376,9 +385,9 @@ TEST_F(EncodingEventSubscriberTest, MultiplePacketEventsForPacket) { const BasePacketEvent& base_event = event->base_packet_event(0); EXPECT_EQ(packet_id, base_event.packet_id()); ASSERT_EQ(2, base_event.event_type_size()); - EXPECT_EQ(media::cast::proto::VIDEO_PACKET_SENT_TO_NETWORK, + EXPECT_EQ(media::cast::proto::PACKET_SENT_TO_NETWORK, base_event.event_type(0)); - EXPECT_EQ(media::cast::proto::VIDEO_PACKET_RETRANSMITTED, + EXPECT_EQ(media::cast::proto::PACKET_RETRANSMITTED, base_event.event_type(1)); ASSERT_EQ(2, base_event.event_timestamp_ms_size()); EXPECT_EQ(InMilliseconds(now1), base_event.event_timestamp_ms(0)); @@ -393,7 +402,8 @@ TEST_F(EncodingEventSubscriberTest, MultiplePacketEventsForFrame) { int packet_id_2 = 3; int size = 100; cast_environment_->Logging()->InsertPacketEvent(now1, - kVideoPacketSentToNetwork, + PACKET_SENT_TO_NETWORK, + VIDEO_EVENT, rtp_timestamp, /*frame_id*/ 0, packet_id_1, @@ -403,7 +413,8 @@ TEST_F(EncodingEventSubscriberTest, MultiplePacketEventsForFrame) { testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20)); base::TimeTicks now2(testing_clock_->NowTicks()); cast_environment_->Logging()->InsertPacketEvent(now2, - kVideoPacketRetransmitted, + PACKET_RETRANSMITTED, + VIDEO_EVENT, rtp_timestamp, /*frame_id*/ 0, packet_id_2, @@ -425,7 +436,7 @@ TEST_F(EncodingEventSubscriberTest, MultiplePacketEventsForFrame) { const BasePacketEvent& base_event = event->base_packet_event(0); EXPECT_EQ(packet_id_1, base_event.packet_id()); ASSERT_EQ(1, base_event.event_type_size()); - EXPECT_EQ(media::cast::proto::VIDEO_PACKET_SENT_TO_NETWORK, + EXPECT_EQ(media::cast::proto::PACKET_SENT_TO_NETWORK, base_event.event_type(0)); ASSERT_EQ(1, base_event.event_timestamp_ms_size()); EXPECT_EQ(InMilliseconds(now1), base_event.event_timestamp_ms(0)); @@ -433,7 +444,7 @@ TEST_F(EncodingEventSubscriberTest, MultiplePacketEventsForFrame) { const BasePacketEvent& base_event_2 = event->base_packet_event(1); EXPECT_EQ(packet_id_2, base_event_2.packet_id()); ASSERT_EQ(1, base_event_2.event_type_size()); - EXPECT_EQ(media::cast::proto::VIDEO_PACKET_RETRANSMITTED, + EXPECT_EQ(media::cast::proto::PACKET_RETRANSMITTED, base_event_2.event_type(0)); ASSERT_EQ(1, base_event_2.event_timestamp_ms_size()); EXPECT_EQ(InMilliseconds(now2), base_event_2.event_timestamp_ms(0)); @@ -448,7 +459,8 @@ TEST_F(EncodingEventSubscriberTest, MultiplePacketEvents) { int packet_id_2 = 3; int size = 100; cast_environment_->Logging()->InsertPacketEvent(now1, - kVideoPacketSentToNetwork, + PACKET_SENT_TO_NETWORK, + VIDEO_EVENT, rtp_timestamp_1, /*frame_id*/ 0, packet_id_1, @@ -458,7 +470,8 @@ TEST_F(EncodingEventSubscriberTest, MultiplePacketEvents) { testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20)); base::TimeTicks now2(testing_clock_->NowTicks()); cast_environment_->Logging()->InsertPacketEvent(now2, - kVideoPacketRetransmitted, + PACKET_RETRANSMITTED, + VIDEO_EVENT, rtp_timestamp_2, /*frame_id*/ 0, packet_id_2, @@ -480,7 +493,7 @@ TEST_F(EncodingEventSubscriberTest, MultiplePacketEvents) { const BasePacketEvent& base_event = event->base_packet_event(0); EXPECT_EQ(packet_id_1, base_event.packet_id()); ASSERT_EQ(1, base_event.event_type_size()); - EXPECT_EQ(media::cast::proto::VIDEO_PACKET_SENT_TO_NETWORK, + EXPECT_EQ(media::cast::proto::PACKET_SENT_TO_NETWORK, base_event.event_type(0)); ASSERT_EQ(1, base_event.event_timestamp_ms_size()); EXPECT_EQ(InMilliseconds(now1), base_event.event_timestamp_ms(0)); @@ -496,7 +509,7 @@ TEST_F(EncodingEventSubscriberTest, MultiplePacketEvents) { const BasePacketEvent& base_event_2 = event->base_packet_event(0); EXPECT_EQ(packet_id_2, base_event_2.packet_id()); ASSERT_EQ(1, base_event_2.event_type_size()); - EXPECT_EQ(media::cast::proto::VIDEO_PACKET_RETRANSMITTED, + EXPECT_EQ(media::cast::proto::PACKET_RETRANSMITTED, base_event_2.event_type(0)); ASSERT_EQ(1, base_event_2.event_timestamp_ms_size()); EXPECT_EQ(InMilliseconds(now2), base_event_2.event_timestamp_ms(0)); @@ -508,12 +521,14 @@ TEST_F(EncodingEventSubscriberTest, FirstRtpTimestamp) { base::TimeTicks now(testing_clock_->NowTicks()); cast_environment_->Logging()->InsertFrameEvent(now, - kVideoFrameCaptureBegin, + FRAME_CAPTURE_BEGIN, + VIDEO_EVENT, rtp_timestamp, /*frame_id*/ 0); cast_environment_->Logging()->InsertFrameEvent(now, - kVideoFrameCaptureEnd, + FRAME_CAPTURE_END, + VIDEO_EVENT, rtp_timestamp + 30, /*frame_id*/ 1); @@ -531,7 +546,8 @@ TEST_F(EncodingEventSubscriberTest, FirstRtpTimestamp) { rtp_timestamp = 67890; cast_environment_->Logging()->InsertFrameEvent(now, - kVideoFrameCaptureBegin, + FRAME_CAPTURE_BEGIN, + VIDEO_EVENT, rtp_timestamp, /*frame_id*/ 0); GetEventsAndReset(); @@ -545,13 +561,15 @@ TEST_F(EncodingEventSubscriberTest, RelativeRtpTimestampWrapAround) { base::TimeTicks now(testing_clock_->NowTicks()); cast_environment_->Logging()->InsertFrameEvent(now, - kVideoFrameCaptureBegin, + FRAME_CAPTURE_BEGIN, + VIDEO_EVENT, rtp_timestamp, /*frame_id*/ 0); // RtpTimestamp has now wrapped around. cast_environment_->Logging()->InsertFrameEvent(now, - kVideoFrameCaptureEnd, + FRAME_CAPTURE_END, + VIDEO_EVENT, rtp_timestamp + 30, /*frame_id*/ 1); @@ -571,7 +589,8 @@ TEST_F(EncodingEventSubscriberTest, MaxEventsPerProto) { RtpTimestamp rtp_timestamp = 100; for (int i = 0; i < kMaxEventsPerProto + 1; i++) { cast_environment_->Logging()->InsertFrameEvent(testing_clock_->NowTicks(), - kVideoAckReceived, + FRAME_ACK_RECEIVED, + VIDEO_EVENT, rtp_timestamp, /*frame_id*/ 0); testing_clock_->Advance(base::TimeDelta::FromMilliseconds(30)); @@ -590,7 +609,8 @@ TEST_F(EncodingEventSubscriberTest, MaxEventsPerProto) { for (int i = 0; i < kMaxPacketsPerFrame + 1; i++) { cast_environment_->Logging()->InsertPacketEvent( testing_clock_->NowTicks(), - kVideoPacketRetransmitted, + PACKET_SENT_TO_NETWORK, + VIDEO_EVENT, rtp_timestamp, /*frame_id*/ 0, i, @@ -618,7 +638,8 @@ TEST_F(EncodingEventSubscriberTest, MaxEventsPerProto) { for (int j = 0; j < kMaxEventsPerProto + 1; j++) { cast_environment_->Logging()->InsertPacketEvent( testing_clock_->NowTicks(), - kVideoPacketRetransmitted, + PACKET_SENT_TO_NETWORK, + VIDEO_EVENT, rtp_timestamp, /*frame_id*/ 0, 0, diff --git a/media/cast/logging/logging_defines.cc b/media/cast/logging/logging_defines.cc index bcb9c37..d0dd5c8 100644 --- a/media/cast/logging/logging_defines.cc +++ b/media/cast/logging/logging_defines.cc @@ -7,7 +7,7 @@ #include "base/logging.h" #define ENUM_TO_STRING(enum) \ - case k##enum: \ + case enum: \ return #enum namespace media { @@ -15,80 +15,25 @@ namespace cast { const char* CastLoggingToString(CastLoggingEvent event) { switch (event) { - // Can happen if the sender and receiver of RTCP log messages are not - // aligned. - ENUM_TO_STRING(Unknown); - ENUM_TO_STRING(RttMs); - ENUM_TO_STRING(PacketLoss); - ENUM_TO_STRING(JitterMs); - ENUM_TO_STRING(VideoAckReceived); - ENUM_TO_STRING(RembBitrate); - ENUM_TO_STRING(AudioAckSent); - ENUM_TO_STRING(VideoAckSent); - ENUM_TO_STRING(AudioFrameCaptureBegin); - ENUM_TO_STRING(AudioFrameCaptureEnd); - ENUM_TO_STRING(AudioFrameEncoded); - ENUM_TO_STRING(AudioPlayoutDelay); - ENUM_TO_STRING(AudioFrameDecoded); - ENUM_TO_STRING(VideoFrameCaptureBegin); - ENUM_TO_STRING(VideoFrameCaptureEnd); - ENUM_TO_STRING(VideoFrameSentToEncoder); - ENUM_TO_STRING(VideoFrameEncoded); - ENUM_TO_STRING(VideoFrameDecoded); - ENUM_TO_STRING(VideoRenderDelay); - ENUM_TO_STRING(AudioPacketSentToNetwork); - ENUM_TO_STRING(VideoPacketSentToNetwork); - ENUM_TO_STRING(AudioPacketRetransmitted); - ENUM_TO_STRING(VideoPacketRetransmitted); - ENUM_TO_STRING(AudioPacketReceived); - ENUM_TO_STRING(VideoPacketReceived); - ENUM_TO_STRING(DuplicateAudioPacketReceived); - ENUM_TO_STRING(DuplicateVideoPacketReceived); + ENUM_TO_STRING(UNKNOWN); + ENUM_TO_STRING(FRAME_CAPTURE_BEGIN); + ENUM_TO_STRING(FRAME_CAPTURE_END); + ENUM_TO_STRING(FRAME_ENCODED); + ENUM_TO_STRING(FRAME_ACK_RECEIVED); + ENUM_TO_STRING(FRAME_ACK_SENT); + ENUM_TO_STRING(FRAME_DECODED); + ENUM_TO_STRING(FRAME_PLAYOUT); + ENUM_TO_STRING(PACKET_SENT_TO_NETWORK); + ENUM_TO_STRING(PACKET_RETRANSMITTED); + ENUM_TO_STRING(PACKET_RECEIVED); } NOTREACHED(); return ""; } -EventMediaType GetEventMediaType(CastLoggingEvent event) { - switch (event) { - case kUnknown: - case kRttMs: - case kPacketLoss: - case kJitterMs: - case kRembBitrate: - return OTHER_EVENT; - case kAudioAckSent: - case kAudioFrameCaptureBegin: - case kAudioFrameCaptureEnd: - case kAudioFrameEncoded: - case kAudioPlayoutDelay: - case kAudioFrameDecoded: - case kAudioPacketSentToNetwork: - case kAudioPacketRetransmitted: - case kAudioPacketReceived: - case kDuplicateAudioPacketReceived: - return AUDIO_EVENT; - case kVideoAckReceived: - case kVideoAckSent: - case kVideoFrameCaptureBegin: - case kVideoFrameCaptureEnd: - case kVideoFrameSentToEncoder: - case kVideoFrameEncoded: - case kVideoFrameDecoded: - case kVideoRenderDelay: - case kVideoPacketSentToNetwork: - case kVideoPacketRetransmitted: - case kVideoPacketReceived: - case kDuplicateVideoPacketReceived: - return VIDEO_EVENT; - } - NOTREACHED(); - return OTHER_EVENT; -} - FrameEvent::FrameEvent() - : rtp_timestamp(0u), frame_id(kFrameIdUnknown), size(0u), type(kUnknown), - key_frame(false), target_bitrate(0) {} + : rtp_timestamp(0u), frame_id(kFrameIdUnknown), size(0u), type(UNKNOWN), + media_type(UNKNOWN_EVENT), key_frame(false), target_bitrate(0) {} FrameEvent::~FrameEvent() {} PacketEvent::PacketEvent() @@ -97,7 +42,8 @@ PacketEvent::PacketEvent() max_packet_id(0), packet_id(0), size(0), - type(kUnknown) {} + type(UNKNOWN), + media_type(UNKNOWN_EVENT) {} PacketEvent::~PacketEvent() {} } // namespace cast diff --git a/media/cast/logging/logging_defines.h b/media/cast/logging/logging_defines.h index f1d5c81..2af95d6 100644 --- a/media/cast/logging/logging_defines.h +++ b/media/cast/logging/logging_defines.h @@ -19,50 +19,28 @@ static const uint32 kFrameIdUnknown = 0xFFFFFFFF; typedef uint32 RtpTimestamp; enum CastLoggingEvent { - kUnknown, - // Generic events. These are no longer used. - kRttMs, - kPacketLoss, - kJitterMs, - kVideoAckReceived, // Sender side frame event. - kRembBitrate, // Generic event. No longer used. + UNKNOWN, + // Sender side frame events. + FRAME_CAPTURE_BEGIN, + FRAME_CAPTURE_END, + FRAME_ENCODED, + FRAME_ACK_RECEIVED, // Receiver side frame events. - kAudioAckSent, - kVideoAckSent, - // Audio sender. - kAudioFrameCaptureBegin, - kAudioFrameCaptureEnd, - kAudioFrameEncoded, - // Audio receiver. - kAudioFrameDecoded, - kAudioPlayoutDelay, - // Video sender. - kVideoFrameCaptureBegin, - kVideoFrameCaptureEnd, - kVideoFrameSentToEncoder, // Deprecated - kVideoFrameEncoded, - // Video receiver. - kVideoFrameDecoded, - kVideoRenderDelay, - // Send-side packet events. - kAudioPacketSentToNetwork, - kVideoPacketSentToNetwork, - kAudioPacketRetransmitted, - kVideoPacketRetransmitted, - // Receive-side packet events. - kAudioPacketReceived, - kVideoPacketReceived, - kDuplicateAudioPacketReceived, - kDuplicateVideoPacketReceived, - kNumOfLoggingEvents = kDuplicateVideoPacketReceived + FRAME_ACK_SENT, + FRAME_DECODED, + FRAME_PLAYOUT, + // Sender side packet events. + PACKET_SENT_TO_NETWORK, + PACKET_RETRANSMITTED, + // Receiver side packet events. + PACKET_RECEIVED, + kNumOfLoggingEvents = PACKET_RECEIVED }; const char* CastLoggingToString(CastLoggingEvent event); // CastLoggingEvent are classified into one of three following types. -enum EventMediaType { AUDIO_EVENT, VIDEO_EVENT, OTHER_EVENT }; - -EventMediaType GetEventMediaType(CastLoggingEvent event); +enum EventMediaType { AUDIO_EVENT, VIDEO_EVENT, UNKNOWN_EVENT }; struct FrameEvent { FrameEvent(); @@ -70,7 +48,8 @@ struct FrameEvent { RtpTimestamp rtp_timestamp; uint32 frame_id; - // Size of encoded frame. Only set for kVideoFrameEncoded event. + + // Size of encoded frame. Only set for FRAME_ENCODED event. size_t size; // Time of event logged. @@ -78,15 +57,16 @@ struct FrameEvent { CastLoggingEvent type; - // Render / playout delay. Only set for kAudioPlayoutDelay and - // kVideoRenderDelay events. + EventMediaType media_type; + + // Render / playout delay. Only set for FRAME_PLAYOUT events. base::TimeDelta delay_delta; - // Whether the frame is a key frame. Only set for kVideoFrameEncoded event. + // Whether the frame is a key frame. Only set for video FRAME_ENCODED event. bool key_frame; // The requested target bitrate of the encoder at the time the frame is - // encoded. Only set for kVideoFrameEncoded event. + // encoded. Only set for video FRAME_ENCODED event. int target_bitrate; }; @@ -103,6 +83,7 @@ struct PacketEvent { // Time of event logged. base::TimeTicks timestamp; CastLoggingEvent type; + EventMediaType media_type; }; } // namespace cast diff --git a/media/cast/logging/logging_impl.cc b/media/cast/logging/logging_impl.cc index 7d975e2..1143d1b 100644 --- a/media/cast/logging/logging_impl.cc +++ b/media/cast/logging/logging_impl.cc @@ -19,33 +19,39 @@ LoggingImpl::LoggingImpl() { LoggingImpl::~LoggingImpl() {} void LoggingImpl::InsertFrameEvent(const base::TimeTicks& time_of_event, - CastLoggingEvent event, uint32 rtp_timestamp, + CastLoggingEvent event, + EventMediaType event_media_type, + uint32 rtp_timestamp, uint32 frame_id) { DCHECK(thread_checker_.CalledOnValidThread()); - raw_.InsertFrameEvent(time_of_event, event, rtp_timestamp, frame_id); + raw_.InsertFrameEvent(time_of_event, event, event_media_type, + rtp_timestamp, frame_id); } void LoggingImpl::InsertEncodedFrameEvent(const base::TimeTicks& time_of_event, CastLoggingEvent event, + EventMediaType event_media_type, uint32 rtp_timestamp, uint32 frame_id, int frame_size, bool key_frame, int target_bitrate) { DCHECK(thread_checker_.CalledOnValidThread()); - raw_.InsertEncodedFrameEvent(time_of_event, event, rtp_timestamp, frame_id, - frame_size, key_frame, target_bitrate); + raw_.InsertEncodedFrameEvent(time_of_event, event, event_media_type, + rtp_timestamp, frame_id, frame_size, key_frame, target_bitrate); } void LoggingImpl::InsertFrameEventWithDelay( const base::TimeTicks& time_of_event, CastLoggingEvent event, - uint32 rtp_timestamp, uint32 frame_id, base::TimeDelta delay) { + EventMediaType event_media_type, uint32 rtp_timestamp, uint32 frame_id, + base::TimeDelta delay) { DCHECK(thread_checker_.CalledOnValidThread()); - raw_.InsertFrameEventWithDelay(time_of_event, event, rtp_timestamp, - frame_id, delay); + raw_.InsertFrameEventWithDelay(time_of_event, event, event_media_type, + rtp_timestamp, frame_id, delay); } void LoggingImpl::InsertSinglePacketEvent(const base::TimeTicks& time_of_event, CastLoggingEvent event, + EventMediaType event_media_type, const Packet& packet) { DCHECK(thread_checker_.CalledOnValidThread()); @@ -64,6 +70,7 @@ void LoggingImpl::InsertSinglePacketEvent(const base::TimeTicks& time_of_event, // rtp_timestamp is enough - no need for frame_id as well. InsertPacketEvent(time_of_event, event, + event_media_type, rtp_timestamp, kFrameIdUnknown, packet_id, @@ -73,22 +80,25 @@ void LoggingImpl::InsertSinglePacketEvent(const base::TimeTicks& time_of_event, void LoggingImpl::InsertPacketListEvent(const base::TimeTicks& time_of_event, CastLoggingEvent event, + EventMediaType event_media_type, const PacketList& packets) { DCHECK(thread_checker_.CalledOnValidThread()); for (PacketList::const_iterator it = packets.begin(); it != packets.end(); ++it) { - InsertSinglePacketEvent(time_of_event, event, (*it)->data); + InsertSinglePacketEvent(time_of_event, event, event_media_type, + (*it)->data); } } void LoggingImpl::InsertPacketEvent(const base::TimeTicks& time_of_event, CastLoggingEvent event, + EventMediaType event_media_type, uint32 rtp_timestamp, uint32 frame_id, uint16 packet_id, uint16 max_packet_id, size_t size) { DCHECK(thread_checker_.CalledOnValidThread()); - raw_.InsertPacketEvent(time_of_event, event, rtp_timestamp, frame_id, - packet_id, max_packet_id, size); + raw_.InsertPacketEvent(time_of_event, event, event_media_type, + rtp_timestamp, frame_id, packet_id, max_packet_id, size); } void LoggingImpl::AddRawEventSubscriber(RawEventSubscriber* subscriber) { diff --git a/media/cast/logging/logging_impl.h b/media/cast/logging/logging_impl.h index 2efef55..ba453c8 100644 --- a/media/cast/logging/logging_impl.h +++ b/media/cast/logging/logging_impl.h @@ -26,27 +26,35 @@ class LoggingImpl { // Note: All methods below should be called from the same thread. void InsertFrameEvent(const base::TimeTicks& time_of_event, - CastLoggingEvent event, uint32 rtp_timestamp, - uint32 frame_id); + CastLoggingEvent event, EventMediaType event_media_type, + uint32 rtp_timestamp, uint32 frame_id); void InsertEncodedFrameEvent(const base::TimeTicks& time_of_event, - CastLoggingEvent event, uint32 rtp_timestamp, - uint32 frame_id, int frame_size, bool key_frame, + CastLoggingEvent event, + EventMediaType event_media_type, + uint32 rtp_timestamp, uint32 frame_id, + int frame_size, bool key_frame, int target_bitrate); void InsertFrameEventWithDelay(const base::TimeTicks& time_of_event, - CastLoggingEvent event, uint32 rtp_timestamp, - uint32 frame_id, base::TimeDelta delay); + CastLoggingEvent event, + EventMediaType event_media_type, + uint32 rtp_timestamp, uint32 frame_id, + base::TimeDelta delay); void InsertSinglePacketEvent(const base::TimeTicks& time_of_event, CastLoggingEvent event, + EventMediaType event_media_type, const Packet& packet); void InsertPacketListEvent(const base::TimeTicks& time_of_event, - CastLoggingEvent event, const PacketList& packets); + CastLoggingEvent event, + EventMediaType event_media_type, + const PacketList& packets); void InsertPacketEvent(const base::TimeTicks& time_of_event, - CastLoggingEvent event, uint32 rtp_timestamp, + CastLoggingEvent event, + EventMediaType event_media_type, uint32 rtp_timestamp, uint32 frame_id, uint16 packet_id, uint16 max_packet_id, size_t size); diff --git a/media/cast/logging/logging_impl_unittest.cc b/media/cast/logging/logging_impl_unittest.cc index cced0ac..712d76b 100644 --- a/media/cast/logging/logging_impl_unittest.cc +++ b/media/cast/logging/logging_impl_unittest.cc @@ -53,7 +53,7 @@ TEST_F(LoggingImplTest, BasicFrameLogging) { do { now = testing_clock_.NowTicks(); logging_.InsertFrameEvent( - now, kAudioFrameCaptureBegin, rtp_timestamp, frame_id); + now, FRAME_CAPTURE_BEGIN, VIDEO_EVENT, rtp_timestamp, frame_id); testing_clock_.Advance( base::TimeDelta::FromMilliseconds(kFrameIntervalMs)); rtp_timestamp += kFrameIntervalMs * 90; @@ -84,7 +84,7 @@ TEST_F(LoggingImplTest, FrameLoggingWithSize) { base::RandInt(-kRandomSizeInterval, kRandomSizeInterval); sum_size += static_cast<size_t>(size); logging_.InsertEncodedFrameEvent(testing_clock_.NowTicks(), - kVideoFrameEncoded, rtp_timestamp, + FRAME_ENCODED, VIDEO_EVENT, rtp_timestamp, frame_id, size, true, target_bitrate); testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs)); rtp_timestamp += kFrameIntervalMs * 90; @@ -112,7 +112,8 @@ TEST_F(LoggingImplTest, FrameLoggingWithDelay) { base::RandInt(-kRandomSizeInterval, kRandomSizeInterval); logging_.InsertFrameEventWithDelay( testing_clock_.NowTicks(), - kAudioFrameCaptureBegin, + FRAME_CAPTURE_BEGIN, + VIDEO_EVENT, rtp_timestamp, frame_id, base::TimeDelta::FromMilliseconds(delay)); @@ -136,21 +137,23 @@ TEST_F(LoggingImplTest, MultipleEventFrameLogging) { uint32 num_events = 0u; do { logging_.InsertFrameEvent(testing_clock_.NowTicks(), - kAudioFrameCaptureBegin, + FRAME_CAPTURE_END, + VIDEO_EVENT, rtp_timestamp, frame_id); ++num_events; if (frame_id % 2) { logging_.InsertEncodedFrameEvent(testing_clock_.NowTicks(), - kAudioFrameEncoded, rtp_timestamp, + FRAME_ENCODED, AUDIO_EVENT, + rtp_timestamp, frame_id, 1500, true, 0); } else if (frame_id % 3) { - logging_.InsertFrameEvent(testing_clock_.NowTicks(), kVideoFrameDecoded, - rtp_timestamp, frame_id); + logging_.InsertFrameEvent(testing_clock_.NowTicks(), FRAME_DECODED, + VIDEO_EVENT, rtp_timestamp, frame_id); } else { logging_.InsertFrameEventWithDelay( - testing_clock_.NowTicks(), kVideoRenderDelay, rtp_timestamp, frame_id, - base::TimeDelta::FromMilliseconds(20)); + testing_clock_.NowTicks(), FRAME_PLAYOUT, VIDEO_EVENT, + rtp_timestamp, frame_id, base::TimeDelta::FromMilliseconds(20)); } ++num_events; @@ -185,12 +188,13 @@ TEST_F(LoggingImplTest, PacketLogging) { latest_time = testing_clock_.NowTicks(); ++num_packets; logging_.InsertPacketEvent(latest_time, - kDuplicateVideoPacketReceived, - rtp_timestamp, - frame_id, - i, - kNumPacketsPerFrame, - size); + PACKET_RECEIVED, + VIDEO_EVENT, + rtp_timestamp, + frame_id, + i, + kNumPacketsPerFrame, + size); } testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs)); rtp_timestamp += kFrameIntervalMs * 90; @@ -211,7 +215,8 @@ TEST_F(LoggingImplTest, MultipleRawEventSubscribers) { logging_.AddRawEventSubscriber(&event_subscriber_2); logging_.InsertFrameEvent(testing_clock_.NowTicks(), - kAudioFrameCaptureBegin, + FRAME_CAPTURE_BEGIN, + VIDEO_EVENT, /*rtp_timestamp*/ 0u, /*frame_id*/ 0u); diff --git a/media/cast/logging/logging_raw.cc b/media/cast/logging/logging_raw.cc index 272f734..229064d 100644 --- a/media/cast/logging/logging_raw.cc +++ b/media/cast/logging/logging_raw.cc @@ -17,32 +17,39 @@ LoggingRaw::LoggingRaw() {} LoggingRaw::~LoggingRaw() {} void LoggingRaw::InsertFrameEvent(const base::TimeTicks& time_of_event, - CastLoggingEvent event, uint32 rtp_timestamp, + CastLoggingEvent event, + EventMediaType event_media_type, + uint32 rtp_timestamp, uint32 frame_id) { - InsertBaseFrameEvent(time_of_event, event, frame_id, rtp_timestamp, - base::TimeDelta(), 0, false, 0); + InsertBaseFrameEvent(time_of_event, event, event_media_type, frame_id, + rtp_timestamp, base::TimeDelta(), 0, false, 0); } void LoggingRaw::InsertEncodedFrameEvent(const base::TimeTicks& time_of_event, CastLoggingEvent event, + EventMediaType event_media_type, uint32 rtp_timestamp, uint32 frame_id, int size, bool key_frame, int target_bitrate) { - InsertBaseFrameEvent(time_of_event, event, frame_id, rtp_timestamp, - base::TimeDelta(), size, key_frame, target_bitrate); + InsertBaseFrameEvent(time_of_event, event, event_media_type, + frame_id, rtp_timestamp, base::TimeDelta(), size, + key_frame, target_bitrate); } void LoggingRaw::InsertFrameEventWithDelay(const base::TimeTicks& time_of_event, CastLoggingEvent event, + EventMediaType event_media_type, uint32 rtp_timestamp, uint32 frame_id, base::TimeDelta delay) { - InsertBaseFrameEvent(time_of_event, event, frame_id, rtp_timestamp, delay, - 0, false, 0); + InsertBaseFrameEvent(time_of_event, event, event_media_type, frame_id, + rtp_timestamp, delay, 0, false, 0); } void LoggingRaw::InsertBaseFrameEvent(const base::TimeTicks& time_of_event, - CastLoggingEvent event, uint32 frame_id, + CastLoggingEvent event, + EventMediaType event_media_type, + uint32 frame_id, uint32 rtp_timestamp, base::TimeDelta delay, int size, bool key_frame, int target_bitrate) { @@ -52,6 +59,7 @@ void LoggingRaw::InsertBaseFrameEvent(const base::TimeTicks& time_of_event, frame_event.size = size; frame_event.timestamp = time_of_event; frame_event.type = event; + frame_event.media_type = event_media_type; frame_event.delay_delta = delay; frame_event.key_frame = key_frame; frame_event.target_bitrate = target_bitrate; @@ -63,7 +71,9 @@ void LoggingRaw::InsertBaseFrameEvent(const base::TimeTicks& time_of_event, } void LoggingRaw::InsertPacketEvent(const base::TimeTicks& time_of_event, - CastLoggingEvent event, uint32 rtp_timestamp, + CastLoggingEvent event, + EventMediaType event_media_type, + uint32 rtp_timestamp, uint32 frame_id, uint16 packet_id, uint16 max_packet_id, size_t size) { PacketEvent packet_event; @@ -74,6 +84,7 @@ void LoggingRaw::InsertPacketEvent(const base::TimeTicks& time_of_event, packet_event.size = size; packet_event.timestamp = time_of_event; packet_event.type = event; + packet_event.media_type = event_media_type; for (std::vector<RawEventSubscriber*>::const_iterator it = subscribers_.begin(); it != subscribers_.end(); ++it) { diff --git a/media/cast/logging/logging_raw.h b/media/cast/logging/logging_raw.h index 98c2bfe..8ed4a59 100644 --- a/media/cast/logging/logging_raw.h +++ b/media/cast/logging/logging_raw.h @@ -27,31 +27,34 @@ class LoggingRaw : public base::NonThreadSafe { // Inform of new event: two types of events: frame and packet. // Frame events can be inserted with different parameters. void InsertFrameEvent(const base::TimeTicks& time_of_event, - CastLoggingEvent event, uint32 rtp_timestamp, - uint32 frame_id); + CastLoggingEvent event, EventMediaType event_media_type, + uint32 rtp_timestamp, uint32 frame_id); - // This function is only applicable for the following frame events: - // kAudioFrameEncoded, kVideoFrameEncoded + // This function is only applicable for FRAME_ENCODED event. // |size| - Size of encoded frame. // |key_frame| - Whether the frame is a key frame. This field is only - // applicable for kVideoFrameEncoded event. + // applicable for video event. // |target_bitrate| - The target bitrate of the encoder the time the frame - // was encoded. Only applicable for kVideoFrameEncoded event. + // was encoded. Only applicable for video event. void InsertEncodedFrameEvent(const base::TimeTicks& time_of_event, - CastLoggingEvent event, uint32 rtp_timestamp, - uint32 frame_id, int size, bool key_frame, + CastLoggingEvent event, + EventMediaType event_media_type, + uint32 rtp_timestamp, uint32 frame_id, + int size, bool key_frame, int target_bitrate); // Render/playout delay - // This function is only applicable for the following frame events: - // kAudioPlayoutDelay, kVideoRenderDelay + // This function is only applicable for FRAME_PLAYOUT event. void InsertFrameEventWithDelay(const base::TimeTicks& time_of_event, - CastLoggingEvent event, uint32 rtp_timestamp, + CastLoggingEvent event, + EventMediaType event_media_type, + uint32 rtp_timestamp, uint32 frame_id, base::TimeDelta delay); // Insert a packet event. void InsertPacketEvent(const base::TimeTicks& time_of_event, - CastLoggingEvent event, uint32 rtp_timestamp, + CastLoggingEvent event, + EventMediaType event_media_type, uint32 rtp_timestamp, uint32 frame_id, uint16 packet_id, uint16 max_packet_id, size_t size); @@ -68,9 +71,11 @@ class LoggingRaw : public base::NonThreadSafe { private: void InsertBaseFrameEvent(const base::TimeTicks& time_of_event, - CastLoggingEvent event, uint32 frame_id, - uint32 rtp_timestamp, base::TimeDelta delay, - int size, bool key_frame, int target_bitrate); + CastLoggingEvent event, + EventMediaType event_media_type, + uint32 frame_id, uint32 rtp_timestamp, + base::TimeDelta delay, int size, bool key_frame, + int target_bitrate); // List of subscriber pointers. This class does not own the subscribers. std::vector<RawEventSubscriber*> subscribers_; diff --git a/media/cast/logging/logging_raw_unittest.cc b/media/cast/logging/logging_raw_unittest.cc index 0949cd9..0b7c05a 100644 --- a/media/cast/logging/logging_raw_unittest.cc +++ b/media/cast/logging/logging_raw_unittest.cc @@ -25,11 +25,13 @@ class LoggingRawTest : public ::testing::Test { }; TEST_F(LoggingRawTest, FrameEvent) { - CastLoggingEvent event_type = kVideoFrameDecoded; + CastLoggingEvent event_type = FRAME_DECODED; + EventMediaType media_type = VIDEO_EVENT; uint32 frame_id = 456u; RtpTimestamp rtp_timestamp = 123u; base::TimeTicks timestamp = base::TimeTicks(); - raw_.InsertFrameEvent(timestamp, event_type, rtp_timestamp, frame_id); + raw_.InsertFrameEvent(timestamp, event_type, media_type, + rtp_timestamp, frame_id); event_subscriber_.GetPacketEventsAndReset(&packet_events_); EXPECT_TRUE(packet_events_.empty()); @@ -41,19 +43,21 @@ TEST_F(LoggingRawTest, FrameEvent) { EXPECT_EQ(0u, frame_events_[0].size); EXPECT_EQ(timestamp, frame_events_[0].timestamp); EXPECT_EQ(event_type, frame_events_[0].type); + EXPECT_EQ(media_type, frame_events_[0].media_type); EXPECT_EQ(base::TimeDelta(), frame_events_[0].delay_delta); } TEST_F(LoggingRawTest, EncodedFrameEvent) { - CastLoggingEvent event_type = kVideoFrameEncoded; + CastLoggingEvent event_type = FRAME_ENCODED; + EventMediaType media_type = VIDEO_EVENT; uint32 frame_id = 456u; RtpTimestamp rtp_timestamp = 123u; base::TimeTicks timestamp = base::TimeTicks(); int size = 1024; bool key_frame = true; int target_bitrate = 4096; - raw_.InsertEncodedFrameEvent(timestamp, event_type, rtp_timestamp, frame_id, - size, key_frame, target_bitrate); + raw_.InsertEncodedFrameEvent(timestamp, event_type, media_type, + rtp_timestamp, frame_id, size, key_frame, target_bitrate); event_subscriber_.GetPacketEventsAndReset(&packet_events_); EXPECT_TRUE(packet_events_.empty()); @@ -65,19 +69,21 @@ TEST_F(LoggingRawTest, EncodedFrameEvent) { EXPECT_EQ(size, static_cast<int>(frame_events_[0].size)); EXPECT_EQ(timestamp, frame_events_[0].timestamp); EXPECT_EQ(event_type, frame_events_[0].type); + EXPECT_EQ(media_type, frame_events_[0].media_type); EXPECT_EQ(base::TimeDelta(), frame_events_[0].delay_delta); EXPECT_EQ(key_frame, frame_events_[0].key_frame); EXPECT_EQ(target_bitrate, frame_events_[0].target_bitrate); } TEST_F(LoggingRawTest, FrameEventWithDelay) { - CastLoggingEvent event_type = kVideoRenderDelay; + CastLoggingEvent event_type = FRAME_PLAYOUT; + EventMediaType media_type = VIDEO_EVENT; uint32 frame_id = 456u; RtpTimestamp rtp_timestamp = 123u; base::TimeTicks timestamp = base::TimeTicks(); base::TimeDelta delay = base::TimeDelta::FromMilliseconds(20); - raw_.InsertFrameEventWithDelay(timestamp, event_type, rtp_timestamp, frame_id, - delay); + raw_.InsertFrameEventWithDelay(timestamp, event_type, media_type, + rtp_timestamp, frame_id, delay); event_subscriber_.GetPacketEventsAndReset(&packet_events_); EXPECT_TRUE(packet_events_.empty()); @@ -89,25 +95,28 @@ TEST_F(LoggingRawTest, FrameEventWithDelay) { EXPECT_EQ(0u, frame_events_[0].size); EXPECT_EQ(timestamp, frame_events_[0].timestamp); EXPECT_EQ(event_type, frame_events_[0].type); + EXPECT_EQ(media_type, frame_events_[0].media_type); EXPECT_EQ(delay, frame_events_[0].delay_delta); } TEST_F(LoggingRawTest, PacketEvent) { - CastLoggingEvent event_type = kVideoPacketReceived; + CastLoggingEvent event_type = PACKET_RECEIVED; + EventMediaType media_type = VIDEO_EVENT; uint32 frame_id = 456u; uint16 packet_id = 1u; uint16 max_packet_id = 10u; RtpTimestamp rtp_timestamp = 123u; base::TimeTicks timestamp = base::TimeTicks(); size_t size = 1024u; - raw_.InsertPacketEvent(timestamp, event_type, rtp_timestamp, frame_id, - packet_id, max_packet_id, size); + raw_.InsertPacketEvent(timestamp, event_type, media_type, + rtp_timestamp, frame_id, packet_id, max_packet_id, size); event_subscriber_.GetFrameEventsAndReset(&frame_events_); EXPECT_TRUE(frame_events_.empty()); event_subscriber_.GetPacketEventsAndReset(&packet_events_); ASSERT_EQ(1u, packet_events_.size()); + EXPECT_EQ(rtp_timestamp, packet_events_[0].rtp_timestamp); EXPECT_EQ(frame_id, packet_events_[0].frame_id); EXPECT_EQ(max_packet_id, packet_events_[0].max_packet_id); @@ -115,6 +124,7 @@ TEST_F(LoggingRawTest, PacketEvent) { EXPECT_EQ(size, packet_events_[0].size); EXPECT_EQ(timestamp, packet_events_[0].timestamp); EXPECT_EQ(event_type, packet_events_[0].type); + EXPECT_EQ(media_type, packet_events_[0].media_type); } TEST_F(LoggingRawTest, MultipleSubscribers) { @@ -123,11 +133,13 @@ TEST_F(LoggingRawTest, MultipleSubscribers) { // Now raw_ has two subscribers. raw_.AddSubscriber(&event_subscriber_2); - CastLoggingEvent event_type = kVideoFrameDecoded; + CastLoggingEvent event_type = FRAME_DECODED; + EventMediaType media_type = VIDEO_EVENT; uint32 frame_id = 456u; RtpTimestamp rtp_timestamp = 123u; base::TimeTicks timestamp = base::TimeTicks(); - raw_.InsertFrameEvent(timestamp, event_type, rtp_timestamp, frame_id); + raw_.InsertFrameEvent(timestamp, event_type, media_type, + rtp_timestamp, frame_id); event_subscriber_.GetPacketEventsAndReset(&packet_events_); EXPECT_TRUE(packet_events_.empty()); @@ -139,6 +151,7 @@ TEST_F(LoggingRawTest, MultipleSubscribers) { EXPECT_EQ(0u, frame_events_[0].size); EXPECT_EQ(timestamp, frame_events_[0].timestamp); EXPECT_EQ(event_type, frame_events_[0].type); + EXPECT_EQ(media_type, frame_events_[0].media_type); EXPECT_EQ(base::TimeDelta(), frame_events_[0].delay_delta); event_subscriber_2.GetPacketEventsAndReset(&packet_events_); @@ -151,16 +164,18 @@ TEST_F(LoggingRawTest, MultipleSubscribers) { EXPECT_EQ(0u, frame_events_[0].size); EXPECT_EQ(timestamp, frame_events_[0].timestamp); EXPECT_EQ(event_type, frame_events_[0].type); + EXPECT_EQ(media_type, frame_events_[0].media_type); EXPECT_EQ(base::TimeDelta(), frame_events_[0].delay_delta); // Remove event_subscriber_2, so it shouldn't receive events after this. raw_.RemoveSubscriber(&event_subscriber_2); - event_type = kAudioFrameDecoded; + media_type = AUDIO_EVENT; frame_id = 789; rtp_timestamp = 456; timestamp = base::TimeTicks(); - raw_.InsertFrameEvent(timestamp, event_type, rtp_timestamp, frame_id); + raw_.InsertFrameEvent(timestamp, event_type, media_type, + rtp_timestamp, frame_id); // |event_subscriber_| should still receive events. event_subscriber_.GetFrameEventsAndReset(&frame_events_); @@ -170,6 +185,7 @@ TEST_F(LoggingRawTest, MultipleSubscribers) { EXPECT_EQ(0u, frame_events_[0].size); EXPECT_EQ(timestamp, frame_events_[0].timestamp); EXPECT_EQ(event_type, frame_events_[0].type); + EXPECT_EQ(media_type, frame_events_[0].media_type); EXPECT_EQ(base::TimeDelta(), frame_events_[0].delay_delta); event_subscriber_2.GetFrameEventsAndReset(&frame_events_); diff --git a/media/cast/logging/proto/proto_utils.cc b/media/cast/logging/proto/proto_utils.cc index 90517e1..1f05616 100644 --- a/media/cast/logging/proto/proto_utils.cc +++ b/media/cast/logging/proto/proto_utils.cc @@ -6,47 +6,29 @@ #include "base/logging.h" -#define TO_PROTO_ENUM(from_enum, to_enum) \ - case from_enum: \ - return media::cast::proto::to_enum +#define TO_PROTO_ENUM(enum) \ + case enum: \ + return proto::enum namespace media { namespace cast { -media::cast::proto::EventType ToProtoEventType(CastLoggingEvent event) { +proto::EventType ToProtoEventType(CastLoggingEvent event) { switch (event) { - TO_PROTO_ENUM(kUnknown, UNKNOWN); - TO_PROTO_ENUM(kRttMs, RTT_MS); - TO_PROTO_ENUM(kPacketLoss, PACKET_LOSS); - TO_PROTO_ENUM(kJitterMs, JITTER_MS); - TO_PROTO_ENUM(kVideoAckReceived, VIDEO_ACK_RECEIVED); - TO_PROTO_ENUM(kRembBitrate, REMB_BITRATE); - TO_PROTO_ENUM(kAudioAckSent, AUDIO_ACK_SENT); - TO_PROTO_ENUM(kVideoAckSent, VIDEO_ACK_SENT); - TO_PROTO_ENUM(kAudioFrameCaptureEnd, AUDIO_FRAME_CAPTURE_END); - TO_PROTO_ENUM(kAudioFrameCaptureBegin, AUDIO_FRAME_CAPTURE_BEGIN); - TO_PROTO_ENUM(kAudioFrameEncoded, AUDIO_FRAME_ENCODED); - TO_PROTO_ENUM(kAudioPlayoutDelay, AUDIO_PLAYOUT_DELAY); - TO_PROTO_ENUM(kAudioFrameDecoded, AUDIO_FRAME_DECODED); - TO_PROTO_ENUM(kVideoFrameCaptureBegin, VIDEO_FRAME_CAPTURE_BEGIN); - TO_PROTO_ENUM(kVideoFrameCaptureEnd, VIDEO_FRAME_CAPTURE_END); - TO_PROTO_ENUM(kVideoFrameSentToEncoder, VIDEO_FRAME_SENT_TO_ENCODER); - TO_PROTO_ENUM(kVideoFrameEncoded, VIDEO_FRAME_ENCODED); - TO_PROTO_ENUM(kVideoFrameDecoded, VIDEO_FRAME_DECODED); - TO_PROTO_ENUM(kVideoRenderDelay, VIDEO_RENDER_DELAY); - TO_PROTO_ENUM(kAudioPacketSentToNetwork, AUDIO_PACKET_SENT_TO_NETWORK); - TO_PROTO_ENUM(kVideoPacketSentToNetwork, VIDEO_PACKET_SENT_TO_NETWORK); - TO_PROTO_ENUM(kAudioPacketRetransmitted, AUDIO_PACKET_RETRANSMITTED); - TO_PROTO_ENUM(kVideoPacketRetransmitted, VIDEO_PACKET_RETRANSMITTED); - TO_PROTO_ENUM(kAudioPacketReceived, AUDIO_PACKET_RECEIVED); - TO_PROTO_ENUM(kVideoPacketReceived, VIDEO_PACKET_RECEIVED); - TO_PROTO_ENUM(kDuplicateAudioPacketReceived, - DUPLICATE_AUDIO_PACKET_RECEIVED); - TO_PROTO_ENUM(kDuplicateVideoPacketReceived, - DUPLICATE_VIDEO_PACKET_RECEIVED); + TO_PROTO_ENUM(UNKNOWN); + TO_PROTO_ENUM(FRAME_CAPTURE_BEGIN); + TO_PROTO_ENUM(FRAME_CAPTURE_END); + TO_PROTO_ENUM(FRAME_ENCODED); + TO_PROTO_ENUM(FRAME_ACK_RECEIVED); + TO_PROTO_ENUM(FRAME_ACK_SENT); + TO_PROTO_ENUM(FRAME_DECODED); + TO_PROTO_ENUM(FRAME_PLAYOUT); + TO_PROTO_ENUM(PACKET_SENT_TO_NETWORK); + TO_PROTO_ENUM(PACKET_RETRANSMITTED); + TO_PROTO_ENUM(PACKET_RECEIVED); } NOTREACHED(); - return media::cast::proto::UNKNOWN; + return proto::UNKNOWN; } } // namespace cast diff --git a/media/cast/logging/proto/raw_events.proto b/media/cast/logging/proto/raw_events.proto index adbd943..2ffed58 100644 --- a/media/cast/logging/proto/raw_events.proto +++ b/media/cast/logging/proto/raw_events.proto @@ -14,6 +14,8 @@ package media.cast.proto; // For compatibility reasons, existing values in this enum must not be changed. enum EventType { UNKNOWN = 0; + + // Note: 1-28 are deprecated in favor of unified event types. Do not use. // Generic events. No longer used. RTT_MS = 1; PACKET_LOSS = 2; @@ -51,6 +53,19 @@ enum EventType { VIDEO_PACKET_RECEIVED = 26; DUPLICATE_AUDIO_PACKET_RECEIVED = 27; DUPLICATE_VIDEO_PACKET_RECEIVED = 28; + + + // New, unified event types. + FRAME_CAPTURE_BEGIN = 29; + FRAME_CAPTURE_END = 30; + FRAME_ENCODED = 31; + FRAME_ACK_RECEIVED = 32; + FRAME_ACK_SENT = 33; + FRAME_DECODED = 34; + FRAME_PLAYOUT = 35; + PACKET_SENT_TO_NETWORK = 36; + PACKET_RETRANSMITTED = 37; + PACKET_RECEIVED = 38; } // Each log will contain one |LogMetadata|. @@ -86,16 +101,16 @@ message AggregatedFrameEvent { // and date. repeated int64 event_timestamp_ms = 3 [packed = true]; - // Only set if there is a kAudioFrameEncoded and kVideoFrameEncoded event. + // Only set if there is a frame encoded event. optional int32 encoded_frame_size = 4; - // Only set if there is a kAudioPlayoutDelay or kVideoRenderDelay event. + // Only set if there is a frame playout event. optional int32 delay_millis = 5; - // Only set if there is a kVideoFrameEncoded event. + // Only set if there is a video frame encoded event. optional bool key_frame = 6; - // Only set if there is a kVideoFrameEncoded event. + // Only set if there is a video frame encoded event. optional int32 target_bitrate = 7; }; diff --git a/media/cast/logging/receiver_time_offset_estimator_impl.cc b/media/cast/logging/receiver_time_offset_estimator_impl.cc index 897c7e1..44d5eb0 100644 --- a/media/cast/logging/receiver_time_offset_estimator_impl.cc +++ b/media/cast/logging/receiver_time_offset_estimator_impl.cc @@ -25,9 +25,13 @@ ReceiverTimeOffsetEstimatorImpl::~ReceiverTimeOffsetEstimatorImpl() { void ReceiverTimeOffsetEstimatorImpl::OnReceiveFrameEvent( const FrameEvent& frame_event) { DCHECK(thread_checker_.CalledOnValidThread()); + + if (frame_event.media_type != VIDEO_EVENT) + return; + CastLoggingEvent event = frame_event.type; - if (event != kVideoFrameEncoded && event != kVideoAckSent && - event != kVideoAckReceived) + if (event != FRAME_ENCODED && event != FRAME_ACK_SENT && + event != FRAME_ACK_RECEIVED) return; EventTimesMap::iterator it = event_times_map_.find(frame_event.rtp_timestamp); @@ -37,7 +41,7 @@ void ReceiverTimeOffsetEstimatorImpl::OnReceiveFrameEvent( event_times)).first; } switch (event) { - case kVideoFrameEncoded: + case FRAME_ENCODED: // Encode is supposed to happen only once. If we see duplicate event, // throw away the entry. if (it->second.event_a_time.is_null()) { @@ -47,7 +51,7 @@ void ReceiverTimeOffsetEstimatorImpl::OnReceiveFrameEvent( return; } break; - case kVideoAckSent: + case FRAME_ACK_SENT: if (it->second.event_b_time.is_null()) { it->second.event_b_time = frame_event.timestamp; } else if (it->second.event_b_time != frame_event.timestamp) { @@ -57,7 +61,7 @@ void ReceiverTimeOffsetEstimatorImpl::OnReceiveFrameEvent( return; } break; - case kVideoAckReceived: + case FRAME_ACK_RECEIVED: // If there are duplicate ack received events, pick the one with the // smallest event timestamp so we can get a better bound. if (it->second.event_c_time.is_null()) { diff --git a/media/cast/logging/receiver_time_offset_estimator_impl.h b/media/cast/logging/receiver_time_offset_estimator_impl.h index 0968bed..1d0f6c8 100644 --- a/media/cast/logging/receiver_time_offset_estimator_impl.h +++ b/media/cast/logging/receiver_time_offset_estimator_impl.h @@ -13,10 +13,10 @@ namespace media { namespace cast { -// This implementation listens to three types of events: -// 1. kVideoFrameEncoded (sender side) -// 2. kVideoAckSent (receiver side) -// 3. kVideoAckReceived (sender side) +// This implementation listens to three types of video events: +// 1. FRAME_ENCODED (sender side) +// 2. FRAME_ACK_SENT (receiver side) +// 3. FRAME_ACK_RECEIVED (sender side) // There is a causal relationship between these events in that these events // must happen in order. This class obtains the lower and upper bounds for // the offset by taking the difference of timestamps (2) - (1) and (2) - (3), diff --git a/media/cast/logging/receiver_time_offset_estimator_impl_unittest.cc b/media/cast/logging/receiver_time_offset_estimator_impl_unittest.cc index 36985b6..1cdbecf 100644 --- a/media/cast/logging/receiver_time_offset_estimator_impl_unittest.cc +++ b/media/cast/logging/receiver_time_offset_estimator_impl_unittest.cc @@ -65,7 +65,7 @@ TEST_F(ReceiverTimeOffsetEstimatorImplTest, EstimateOffset) { cast_environment_->Logging()->InsertEncodedFrameEvent( sender_clock_->NowTicks(), - kVideoFrameEncoded, + FRAME_ENCODED, VIDEO_EVENT, rtp_timestamp, frame_id, 1234, @@ -76,13 +76,15 @@ TEST_F(ReceiverTimeOffsetEstimatorImplTest, EstimateOffset) { AdvanceClocks(base::TimeDelta::FromMilliseconds(10)); cast_environment_->Logging()->InsertFrameEvent( - receiver_clock_.NowTicks(), kVideoAckSent, rtp_timestamp, frame_id); + receiver_clock_.NowTicks(), FRAME_ACK_SENT, VIDEO_EVENT, + rtp_timestamp, frame_id); EXPECT_FALSE(estimator_.GetReceiverOffsetBounds(&lower_bound, &upper_bound)); AdvanceClocks(base::TimeDelta::FromMilliseconds(30)); cast_environment_->Logging()->InsertFrameEvent( - sender_clock_->NowTicks(), kVideoAckReceived, rtp_timestamp, frame_id); + sender_clock_->NowTicks(), FRAME_ACK_RECEIVED, VIDEO_EVENT, + rtp_timestamp, frame_id); EXPECT_TRUE(estimator_.GetReceiverOffsetBounds(&lower_bound, &upper_bound)); @@ -112,7 +114,7 @@ TEST_F(ReceiverTimeOffsetEstimatorImplTest, EventCArrivesBeforeEventB) { cast_environment_->Logging()->InsertEncodedFrameEvent( sender_clock_->NowTicks(), - kVideoFrameEncoded, + FRAME_ENCODED, VIDEO_EVENT, rtp_timestamp, frame_id, 1234, @@ -127,12 +129,12 @@ TEST_F(ReceiverTimeOffsetEstimatorImplTest, EventCArrivesBeforeEventB) { base::TimeTicks event_c_time = sender_clock_->NowTicks(); cast_environment_->Logging()->InsertFrameEvent( - event_c_time, kVideoAckReceived, rtp_timestamp, frame_id); + event_c_time, FRAME_ACK_RECEIVED, VIDEO_EVENT, rtp_timestamp, frame_id); EXPECT_FALSE(estimator_.GetReceiverOffsetBounds(&lower_bound, &upper_bound)); cast_environment_->Logging()->InsertFrameEvent( - event_b_time, kVideoAckSent, rtp_timestamp, frame_id); + event_b_time, FRAME_ACK_SENT, VIDEO_EVENT, rtp_timestamp, frame_id); EXPECT_TRUE(estimator_.GetReceiverOffsetBounds(&lower_bound, &upper_bound)); @@ -166,7 +168,7 @@ TEST_F(ReceiverTimeOffsetEstimatorImplTest, MultipleIterations) { AdvanceClocks(base::TimeDelta::FromMilliseconds(20)); cast_environment_->Logging()->InsertEncodedFrameEvent( sender_clock_->NowTicks(), - kVideoFrameEncoded, + FRAME_ENCODED, VIDEO_EVENT, rtp_timestamp_a, frame_id_a, 1234, @@ -176,35 +178,39 @@ TEST_F(ReceiverTimeOffsetEstimatorImplTest, MultipleIterations) { AdvanceClocks(base::TimeDelta::FromMilliseconds(10)); cast_environment_->Logging()->InsertEncodedFrameEvent( sender_clock_->NowTicks(), - kVideoFrameEncoded, + FRAME_ENCODED, VIDEO_EVENT, rtp_timestamp_b, frame_id_b, 1234, true, 5678); cast_environment_->Logging()->InsertFrameEvent( - receiver_clock_.NowTicks(), kVideoAckSent, rtp_timestamp_a, frame_id_a); + receiver_clock_.NowTicks(), FRAME_ACK_SENT, VIDEO_EVENT, + rtp_timestamp_a, frame_id_a); AdvanceClocks(base::TimeDelta::FromMilliseconds(20)); cast_environment_->Logging()->InsertFrameEvent( - receiver_clock_.NowTicks(), kVideoAckSent, rtp_timestamp_b, frame_id_b); + receiver_clock_.NowTicks(), FRAME_ACK_SENT, VIDEO_EVENT, + rtp_timestamp_b, frame_id_b); AdvanceClocks(base::TimeDelta::FromMilliseconds(5)); cast_environment_->Logging()->InsertFrameEvent(sender_clock_->NowTicks(), - kVideoAckReceived, + FRAME_ACK_RECEIVED, + VIDEO_EVENT, rtp_timestamp_b, frame_id_b); AdvanceClocks(base::TimeDelta::FromMilliseconds(5)); cast_environment_->Logging()->InsertFrameEvent(sender_clock_->NowTicks(), - kVideoAckReceived, + FRAME_ACK_RECEIVED, + VIDEO_EVENT, rtp_timestamp_a, frame_id_a); AdvanceClocks(base::TimeDelta::FromMilliseconds(17)); cast_environment_->Logging()->InsertEncodedFrameEvent( sender_clock_->NowTicks(), - kVideoFrameEncoded, + FRAME_ENCODED, VIDEO_EVENT, rtp_timestamp_c, frame_id_c, 1234, @@ -213,11 +219,13 @@ TEST_F(ReceiverTimeOffsetEstimatorImplTest, MultipleIterations) { AdvanceClocks(base::TimeDelta::FromMilliseconds(3)); cast_environment_->Logging()->InsertFrameEvent( - receiver_clock_.NowTicks(), kVideoAckSent, rtp_timestamp_c, frame_id_c); + receiver_clock_.NowTicks(), FRAME_ACK_SENT, VIDEO_EVENT, + rtp_timestamp_c, frame_id_c); AdvanceClocks(base::TimeDelta::FromMilliseconds(30)); cast_environment_->Logging()->InsertFrameEvent(sender_clock_->NowTicks(), - kVideoAckReceived, + FRAME_ACK_RECEIVED, + VIDEO_EVENT, rtp_timestamp_c, frame_id_c); diff --git a/media/cast/logging/serialize_deserialize_test.cc b/media/cast/logging/serialize_deserialize_test.cc index b309ced..7e5aa7d 100644 --- a/media/cast/logging/serialize_deserialize_test.cc +++ b/media/cast/logging/serialize_deserialize_test.cc @@ -20,18 +20,19 @@ using media::cast::proto::LogMetadata; namespace { const media::cast::CastLoggingEvent kVideoFrameEvents[] = { - media::cast::kVideoFrameCaptureBegin, media::cast::kVideoFrameCaptureEnd, - media::cast::kVideoFrameSentToEncoder, media::cast::kVideoFrameEncoded, - media::cast::kVideoFrameDecoded, media::cast::kVideoRenderDelay}; + media::cast::FRAME_CAPTURE_BEGIN, media::cast::FRAME_CAPTURE_END, + media::cast::FRAME_ENCODED, media::cast::FRAME_DECODED, + media::cast::FRAME_PLAYOUT }; const media::cast::CastLoggingEvent kVideoPacketEvents[] = { - media::cast::kVideoPacketSentToNetwork, media::cast::kVideoPacketReceived}; + media::cast::PACKET_SENT_TO_NETWORK, media::cast::PACKET_RECEIVED}; // The frame event fields cycle through these numbers. const int kEncodedFrameSize[] = {512, 425, 399, 400, 237}; const int kDelayMillis[] = {15, 4, 8, 42, 23, 16}; const int kMaxSerializedBytes = 10000; + } namespace media { diff --git a/media/cast/logging/simple_event_subscriber_unittest.cc b/media/cast/logging/simple_event_subscriber_unittest.cc index bce7f53..311a234 100644 --- a/media/cast/logging/simple_event_subscriber_unittest.cc +++ b/media/cast/logging/simple_event_subscriber_unittest.cc @@ -41,25 +41,31 @@ class SimpleEventSubscriberTest : public ::testing::Test { TEST_F(SimpleEventSubscriberTest, GetAndResetEvents) { // Log some frame events. cast_environment_->Logging()->InsertEncodedFrameEvent( - testing_clock_->NowTicks(), kAudioFrameEncoded, /*rtp_timestamp*/ 100u, - /*frame_id*/ 0u, /*frame_size*/ 123, /*key_frame*/ false, 0); + testing_clock_->NowTicks(), FRAME_ENCODED, AUDIO_EVENT, + /*rtp_timestamp*/ 100u, /*frame_id*/ 0u, /*frame_size*/ 123, + /*key_frame*/ false, 0); cast_environment_->Logging()->InsertFrameEventWithDelay( - testing_clock_->NowTicks(), kAudioPlayoutDelay, /*rtp_timestamp*/ 100u, + testing_clock_->NowTicks(), FRAME_PLAYOUT, AUDIO_EVENT, + /*rtp_timestamp*/ 100u, /*frame_id*/ 0u, /*delay*/ base::TimeDelta::FromMilliseconds(100)); cast_environment_->Logging()->InsertFrameEvent( - testing_clock_->NowTicks(), kAudioFrameDecoded, /*rtp_timestamp*/ 200u, + testing_clock_->NowTicks(), FRAME_DECODED, AUDIO_EVENT, + /*rtp_timestamp*/ 200u, /*frame_id*/ 0u); // Log some packet events. cast_environment_->Logging()->InsertPacketEvent( - testing_clock_->NowTicks(), kAudioPacketReceived, /*rtp_timestamp*/ 200u, + testing_clock_->NowTicks(), PACKET_RECEIVED, AUDIO_EVENT, + /*rtp_timestamp*/ 200u, /*frame_id*/ 0u, /*packet_id*/ 1u, /*max_packet_id*/ 5u, /*size*/ 100u); cast_environment_->Logging()->InsertPacketEvent( - testing_clock_->NowTicks(), kVideoFrameDecoded, /*rtp_timestamp*/ 200u, - /*frame_id*/ 0u, /*packet_id*/ 1u, /*max_packet_id*/ 5u, /*size*/ 100u); + testing_clock_->NowTicks(), FRAME_DECODED, VIDEO_EVENT, + /*rtp_timestamp*/ 200u, /*frame_id*/ 0u, /*packet_id*/ 1u, + /*max_packet_id*/ 5u, /*size*/ 100u); cast_environment_->Logging()->InsertPacketEvent( - testing_clock_->NowTicks(), kVideoFrameDecoded, /*rtp_timestamp*/ 300u, - /*frame_id*/ 0u, /*packet_id*/ 1u, /*max_packet_id*/ 5u, /*size*/ 100u); + testing_clock_->NowTicks(), FRAME_DECODED, VIDEO_EVENT, + /*rtp_timestamp*/ 300u, /*frame_id*/ 0u, /*packet_id*/ 1u, + /*max_packet_id*/ 5u, /*size*/ 100u); std::vector<FrameEvent> frame_events; event_subscriber_.GetFrameEventsAndReset(&frame_events); diff --git a/media/cast/logging/stats_event_subscriber.cc b/media/cast/logging/stats_event_subscriber.cc index e292d66..9e3226a 100644 --- a/media/cast/logging/stats_event_subscriber.cc +++ b/media/cast/logging/stats_event_subscriber.cc @@ -22,49 +22,11 @@ using media::cast::EventMediaType; const size_t kMaxFrameEventTimeMapSize = 100; const size_t kMaxPacketEventTimeMapSize = 1000; -CastLoggingEvent GetCapturedEvent(EventMediaType media_type) { - return media_type == AUDIO_EVENT ? - kAudioFrameCaptureBegin : kVideoFrameCaptureBegin; -} - -CastLoggingEvent GetEncodedEvent(EventMediaType media_type) { - return media_type == AUDIO_EVENT ? kAudioFrameEncoded : kVideoFrameEncoded; -} - -CastLoggingEvent GetDecodedEvent(EventMediaType media_type) { - return media_type == AUDIO_EVENT ? kAudioFrameDecoded : kVideoFrameDecoded; -} - -CastLoggingEvent GetPlayoutEvent(EventMediaType media_type) { - return media_type == AUDIO_EVENT ? kAudioPlayoutDelay : kVideoRenderDelay; -} - -CastLoggingEvent GetPacketSentEvent(EventMediaType media_type) { - return media_type == AUDIO_EVENT ? kAudioPacketSentToNetwork : - kVideoPacketSentToNetwork; -} - -CastLoggingEvent GetPacketReceivedEvent(EventMediaType media_type) { - return media_type == AUDIO_EVENT ? kAudioPacketReceived : - kVideoPacketReceived; -} - -CastLoggingEvent GetPacketRetransmittedEvent(EventMediaType media_type) { - return media_type == AUDIO_EVENT ? kAudioPacketRetransmitted : - kVideoPacketRetransmitted; -} - bool IsReceiverEvent(CastLoggingEvent event) { - return event == kAudioFrameDecoded - || event == kVideoFrameDecoded - || event == kAudioPlayoutDelay - || event == kVideoRenderDelay - || event == kAudioAckSent - || event == kVideoAckSent - || event == kAudioPacketReceived - || event == kVideoPacketReceived - || event == kDuplicateAudioPacketReceived - || event == kDuplicateVideoPacketReceived; + return event == FRAME_DECODED + || event == FRAME_PLAYOUT + || event == FRAME_ACK_SENT + || event == PACKET_RECEIVED; } } // namespace @@ -92,7 +54,7 @@ void StatsEventSubscriber::OnReceiveFrameEvent(const FrameEvent& frame_event) { DCHECK(thread_checker_.CalledOnValidThread()); CastLoggingEvent type = frame_event.type; - if (GetEventMediaType(type) != event_media_type_) + if (frame_event.media_type != event_media_type_) return; FrameStatsMap::iterator it = frame_stats_.find(type); @@ -108,9 +70,9 @@ void StatsEventSubscriber::OnReceiveFrameEvent(const FrameEvent& frame_event) { it->second.sum_delay += frame_event.delay_delta; } - if (type == GetCapturedEvent(event_media_type_)) { + if (type == FRAME_CAPTURE_BEGIN) { RecordFrameCapturedTime(frame_event); - } else if (type == GetPlayoutEvent(event_media_type_)) { + } else if (type == FRAME_PLAYOUT) { RecordE2ELatency(frame_event); } @@ -123,7 +85,7 @@ void StatsEventSubscriber::OnReceivePacketEvent( DCHECK(thread_checker_.CalledOnValidThread()); CastLoggingEvent type = packet_event.type; - if (GetEventMediaType(type) != event_media_type_) + if (packet_event.media_type != event_media_type_) return; PacketStatsMap::iterator it = packet_stats_.find(type); @@ -137,10 +99,10 @@ void StatsEventSubscriber::OnReceivePacketEvent( it->second.sum_size += packet_event.size; } - if (type == GetPacketSentEvent(event_media_type_) || - type == GetPacketReceivedEvent(event_media_type_)) { + if (type == PACKET_SENT_TO_NETWORK || + type == PACKET_RECEIVED) { RecordNetworkLatency(packet_event); - } else if (type == GetPacketRetransmittedEvent(event_media_type_)) { + } else if (type == PACKET_RETRANSMITTED) { // We only measure network latency using packets that doesn't have to be // retransmitted as there is precisely one sent-receive timestamp pairs. ErasePacketSentTime(packet_event); @@ -210,19 +172,19 @@ void StatsEventSubscriber::GetStatsInternal(StatsMap* stats_map) const { base::TimeTicks end_time = clock_->NowTicks(); PopulateFpsStat( - end_time, GetCapturedEvent(event_media_type_), CAPTURE_FPS, stats_map); + end_time, FRAME_CAPTURE_BEGIN, CAPTURE_FPS, stats_map); PopulateFpsStat( - end_time, GetEncodedEvent(event_media_type_), ENCODE_FPS, stats_map); + end_time, FRAME_ENCODED, ENCODE_FPS, stats_map); PopulateFpsStat( - end_time, GetDecodedEvent(event_media_type_), DECODE_FPS, stats_map); + end_time, FRAME_DECODED, DECODE_FPS, stats_map); PopulatePlayoutDelayStat(stats_map); PopulateFrameBitrateStat(end_time, stats_map); PopulatePacketBitrateStat(end_time, - GetPacketSentEvent(event_media_type_), + PACKET_SENT_TO_NETWORK, TRANSMISSION_KBPS, stats_map); PopulatePacketBitrateStat(end_time, - GetPacketRetransmittedEvent(event_media_type_), + PACKET_RETRANSMITTED, RETRANSMISSION_KBPS, stats_map); PopulatePacketLossPercentageStat(stats_map); @@ -324,13 +286,13 @@ void StatsEventSubscriber::RecordNetworkLatency( bool match = false; base::TimeTicks packet_sent_time; base::TimeTicks packet_received_time; - if (recorded_type == GetPacketSentEvent(event_media_type_) && - packet_event.type == GetPacketReceivedEvent(event_media_type_)) { + if (recorded_type == PACKET_SENT_TO_NETWORK && + packet_event.type == PACKET_RECEIVED) { packet_sent_time = value.first; packet_received_time = packet_event.timestamp; match = true; - } else if (recorded_type == GetPacketReceivedEvent(event_media_type_) && - packet_event.type == GetPacketSentEvent(event_media_type_)) { + } else if (recorded_type == PACKET_RECEIVED && + packet_event.type == PACKET_SENT_TO_NETWORK) { packet_sent_time = packet_event.timestamp; packet_received_time = value.first; match = true; @@ -362,8 +324,7 @@ void StatsEventSubscriber::PopulateFpsStat(base::TimeTicks end_time, } void StatsEventSubscriber::PopulatePlayoutDelayStat(StatsMap* stats_map) const { - CastLoggingEvent event = GetPlayoutEvent(event_media_type_); - FrameStatsMap::const_iterator it = frame_stats_.find(event); + FrameStatsMap::const_iterator it = frame_stats_.find(FRAME_PLAYOUT); if (it != frame_stats_.end()) { double avg_delay_ms = 0.0; base::TimeDelta sum_delay = it->second.sum_delay; @@ -376,8 +337,7 @@ void StatsEventSubscriber::PopulatePlayoutDelayStat(StatsMap* stats_map) const { void StatsEventSubscriber::PopulateFrameBitrateStat(base::TimeTicks end_time, StatsMap* stats_map) const { - CastLoggingEvent event = GetEncodedEvent(event_media_type_); - FrameStatsMap::const_iterator it = frame_stats_.find(event); + FrameStatsMap::const_iterator it = frame_stats_.find(FRAME_ENCODED); if (it != frame_stats_.end()) { double kbps = 0.0; base::TimeDelta duration = end_time - start_time_; @@ -412,15 +372,12 @@ void StatsEventSubscriber::PopulatePacketLossPercentageStat( // (re)transmission was lost. // This means the percentage of packet loss is // (# of retransmit events) / (# of transmit + retransmit events). - CastLoggingEvent packet_sent_event = GetPacketSentEvent(event_media_type_); - CastLoggingEvent packet_retransmitted_event = - GetPacketRetransmittedEvent(event_media_type_); PacketStatsMap::const_iterator sent_it = - packet_stats_.find(packet_sent_event); + packet_stats_.find(PACKET_SENT_TO_NETWORK); if (sent_it == packet_stats_.end()) return; PacketStatsMap::const_iterator retransmitted_it = - packet_stats_.find(packet_retransmitted_event); + packet_stats_.find(PACKET_RETRANSMITTED); int sent_count = sent_it->second.event_counter; int retransmitted_count = 0; if (retransmitted_it != packet_stats_.end()) diff --git a/media/cast/logging/stats_event_subscriber.h b/media/cast/logging/stats_event_subscriber.h index 4e198da..173378a 100644 --- a/media/cast/logging/stats_event_subscriber.h +++ b/media/cast/logging/stats_event_subscriber.h @@ -83,7 +83,7 @@ class StatsEventSubscriber : public RawEventSubscriber { DECODE_FPS, // Average encode duration in milliseconds. // TODO(imcheng): This stat is not populated yet because we do not have - // the time when encode started. Record it in kVideoFrameEncoded event. + // the time when encode started. Record it in FRAME_ENCODED event. AVG_ENCODE_TIME_MS, // Average playout delay in milliseconds, with target delay already // accounted for. Ideally, every frame should have a playout delay of 0. diff --git a/media/cast/logging/stats_event_subscriber_unittest.cc b/media/cast/logging/stats_event_subscriber_unittest.cc index 90602d5..33faa02 100644 --- a/media/cast/logging/stats_event_subscriber_unittest.cc +++ b/media/cast/logging/stats_event_subscriber_unittest.cc @@ -74,7 +74,8 @@ TEST_F(StatsEventSubscriberTest, Capture) { base::TimeTicks start_time = sender_clock_->NowTicks(); for (int i = 0; i < num_frames; i++) { cast_environment_->Logging()->InsertFrameEvent(sender_clock_->NowTicks(), - kVideoFrameCaptureBegin, + FRAME_CAPTURE_BEGIN, + VIDEO_EVENT, rtp_timestamp, frame_id); @@ -111,7 +112,7 @@ TEST_F(StatsEventSubscriberTest, Encode) { total_size += size; cast_environment_->Logging()->InsertEncodedFrameEvent( sender_clock_->NowTicks(), - kVideoFrameEncoded, + FRAME_ENCODED, VIDEO_EVENT, rtp_timestamp, frame_id, size, @@ -153,7 +154,7 @@ TEST_F(StatsEventSubscriberTest, Decode) { base::TimeTicks start_time = sender_clock_->NowTicks(); for (int i = 0; i < num_frames; i++) { cast_environment_->Logging()->InsertFrameEvent(receiver_clock_.NowTicks(), - kVideoFrameDecoded, + FRAME_DECODED, VIDEO_EVENT, rtp_timestamp, frame_id); @@ -190,7 +191,8 @@ TEST_F(StatsEventSubscriberTest, PlayoutDelay) { total_delay_ms += delay_ms; cast_environment_->Logging()->InsertFrameEventWithDelay( receiver_clock_.NowTicks(), - kVideoRenderDelay, + FRAME_PLAYOUT, + VIDEO_EVENT, rtp_timestamp, frame_id, delay); @@ -220,7 +222,8 @@ TEST_F(StatsEventSubscriberTest, E2ELatency) { base::TimeDelta total_latency; for (int i = 0; i < num_frames; i++) { cast_environment_->Logging()->InsertFrameEvent(sender_clock_->NowTicks(), - kVideoFrameCaptureBegin, + FRAME_CAPTURE_BEGIN, + VIDEO_EVENT, rtp_timestamp, frame_id); @@ -234,7 +237,8 @@ TEST_F(StatsEventSubscriberTest, E2ELatency) { cast_environment_->Logging()->InsertFrameEventWithDelay( receiver_clock_.NowTicks(), - kVideoRenderDelay, + FRAME_PLAYOUT, + VIDEO_EVENT, rtp_timestamp, frame_id, delay); @@ -274,7 +278,8 @@ TEST_F(StatsEventSubscriberTest, Packets) { total_size += size; cast_environment_->Logging()->InsertPacketEvent(sender_clock_->NowTicks(), - kVideoPacketSentToNetwork, + PACKET_SENT_TO_NETWORK, + VIDEO_EVENT, rtp_timestamp, 0, i, @@ -299,7 +304,8 @@ TEST_F(StatsEventSubscriberTest, Packets) { if (i % 2 == 0) { cast_environment_->Logging()->InsertPacketEvent( receiver_clock_.NowTicks(), - kVideoPacketRetransmitted, + PACKET_RETRANSMITTED, + VIDEO_EVENT, rtp_timestamp, 0, i, @@ -315,7 +321,8 @@ TEST_F(StatsEventSubscriberTest, Packets) { if (i % 4 == 0) { cast_environment_->Logging()->InsertPacketEvent( receiver_clock_.NowTicks(), - kVideoPacketRetransmitted, + PACKET_RETRANSMITTED, + VIDEO_EVENT, rtp_timestamp, 0, i, @@ -331,7 +338,8 @@ TEST_F(StatsEventSubscriberTest, Packets) { if (i % 8 == 0) { cast_environment_->Logging()->InsertPacketEvent( receiver_clock_.NowTicks(), - kVideoPacketRetransmitted, + PACKET_RETRANSMITTED, + VIDEO_EVENT, rtp_timestamp, 0, i, @@ -343,7 +351,8 @@ TEST_F(StatsEventSubscriberTest, Packets) { } cast_environment_->Logging()->InsertPacketEvent(received_time, - kVideoPacketReceived, + PACKET_RECEIVED, + VIDEO_EVENT, rtp_timestamp, 0, i, diff --git a/media/cast/rtcp/receiver_rtcp_event_subscriber.cc b/media/cast/rtcp/receiver_rtcp_event_subscriber.cc index 393b678..9a9c0ae 100644 --- a/media/cast/rtcp/receiver_rtcp_event_subscriber.cc +++ b/media/cast/rtcp/receiver_rtcp_event_subscriber.cc @@ -10,10 +10,10 @@ namespace media { namespace cast { ReceiverRtcpEventSubscriber::ReceiverRtcpEventSubscriber( - const size_t max_size_to_retain, Type type) + const size_t max_size_to_retain, EventMediaType type) : max_size_to_retain_(max_size_to_retain), type_(type) { DCHECK(max_size_to_retain_ > 0u); - DCHECK(type_ == kAudioEventSubscriber || type_ == kVideoEventSubscriber); + DCHECK(type_ == AUDIO_EVENT || type_ == VIDEO_EVENT); } ReceiverRtcpEventSubscriber::~ReceiverRtcpEventSubscriber() { @@ -24,16 +24,13 @@ void ReceiverRtcpEventSubscriber::OnReceiveFrameEvent( const FrameEvent& frame_event) { DCHECK(thread_checker_.CalledOnValidThread()); - if (ShouldProcessEvent(frame_event.type)) { + if (ShouldProcessEvent(frame_event.type, frame_event.media_type)) { RtcpEvent rtcp_event; switch (frame_event.type) { - case kAudioPlayoutDelay: - case kVideoRenderDelay: + case FRAME_PLAYOUT: rtcp_event.delay_delta = frame_event.delay_delta; - case kAudioFrameDecoded: - case kVideoFrameDecoded: - case kAudioAckSent: - case kVideoAckSent: + case FRAME_ACK_SENT: + case FRAME_DECODED: rtcp_event.type = frame_event.type; rtcp_event.timestamp = frame_event.timestamp; rtcp_events_.insert( @@ -53,10 +50,9 @@ void ReceiverRtcpEventSubscriber::OnReceivePacketEvent( const PacketEvent& packet_event) { DCHECK(thread_checker_.CalledOnValidThread()); - if (ShouldProcessEvent(packet_event.type)) { + if (ShouldProcessEvent(packet_event.type, packet_event.media_type)) { RtcpEvent rtcp_event; - if (packet_event.type == kAudioPacketReceived || - packet_event.type == kVideoPacketReceived) { + if (packet_event.type == PACKET_RECEIVED) { rtcp_event.type = packet_event.type; rtcp_event.timestamp = packet_event.timestamp; rtcp_event.packet_id = packet_event.packet_id; @@ -90,18 +86,10 @@ void ReceiverRtcpEventSubscriber::TruncateMapIfNeeded() { } bool ReceiverRtcpEventSubscriber::ShouldProcessEvent( - CastLoggingEvent event_type) { - if (type_ == kAudioEventSubscriber) { - return event_type == kAudioPlayoutDelay || - event_type == kAudioFrameDecoded || event_type == kAudioAckSent || - event_type == kAudioPacketReceived; - } else if (type_ == kVideoEventSubscriber) { - return event_type == kVideoRenderDelay || - event_type == kVideoFrameDecoded || event_type == kVideoAckSent || - event_type == kVideoPacketReceived; - } else { - return false; - } + CastLoggingEvent event_type, EventMediaType event_media_type) { + return type_ == event_media_type && + (event_type == FRAME_ACK_SENT || event_type == FRAME_DECODED || + event_type == FRAME_PLAYOUT || event_type == PACKET_RECEIVED); } } // namespace cast diff --git a/media/cast/rtcp/receiver_rtcp_event_subscriber.h b/media/cast/rtcp/receiver_rtcp_event_subscriber.h index f2c7e5a..84af7cb 100644 --- a/media/cast/rtcp/receiver_rtcp_event_subscriber.h +++ b/media/cast/rtcp/receiver_rtcp_event_subscriber.h @@ -12,10 +12,6 @@ #include "media/cast/logging/raw_event_subscriber.h" #include "media/cast/rtcp/rtcp_defines.h" -namespace base { -class SingleThreadTaskRunner; -} - namespace media { namespace cast { @@ -32,20 +28,14 @@ class ReceiverRtcpEventSubscriber : public RawEventSubscriber { public: typedef std::multimap<RtpTimestamp, RtcpEvent> RtcpEventMultiMap; - // Identifies whether the subscriber will process audio or video related - // frame events. - enum Type { - kAudioEventSubscriber, // Only processes audio events - kVideoEventSubscriber // Only processes video events - }; - // |max_size_to_retain|: The object will keep up to |max_size_to_retain| // events // in the map. Once threshold has been reached, an event with the smallest // RTP timestamp will be removed. // |type|: Determines whether the subscriber will process only audio or video // events. - ReceiverRtcpEventSubscriber(const size_t max_size_to_retain, Type type); + ReceiverRtcpEventSubscriber(const size_t max_size_to_retain, + EventMediaType type); virtual ~ReceiverRtcpEventSubscriber(); @@ -63,11 +53,13 @@ class ReceiverRtcpEventSubscriber : public RawEventSubscriber { // |max_size_to_retain_|. void TruncateMapIfNeeded(); - // Returns |true| if events of |event_type| should be processed. - bool ShouldProcessEvent(CastLoggingEvent event_type); + // Returns |true| if events of |event_type| and |media_type| + // should be processed. + bool ShouldProcessEvent(CastLoggingEvent event_type, + EventMediaType media_type); const size_t max_size_to_retain_; - Type type_; + EventMediaType type_; // The key should really be something more than just a RTP timestamp in order // to differentiate between video and audio frames, but since the diff --git a/media/cast/rtcp/receiver_rtcp_event_subscriber_unittest.cc b/media/cast/rtcp/receiver_rtcp_event_subscriber_unittest.cc index aa0d8fa..e0d0f17 100644 --- a/media/cast/rtcp/receiver_rtcp_event_subscriber_unittest.cc +++ b/media/cast/rtcp/receiver_rtcp_event_subscriber_unittest.cc @@ -42,7 +42,7 @@ class ReceiverRtcpEventSubscriberTest : public ::testing::Test { } } - void Init(ReceiverRtcpEventSubscriber::Type type) { + void Init(EventMediaType type) { event_subscriber_.reset( new ReceiverRtcpEventSubscriber(kMaxEventEntries, type)); cast_environment_->Logging()->AddRawEventSubscriber( @@ -52,35 +52,39 @@ class ReceiverRtcpEventSubscriberTest : public ::testing::Test { void InsertEvents() { // Video events cast_environment_->Logging()->InsertFrameEventWithDelay( - testing_clock_->NowTicks(), kVideoRenderDelay, /*rtp_timestamp*/ 100u, - /*frame_id*/ 2u, base::TimeDelta::FromMilliseconds(kDelayMs)); + testing_clock_->NowTicks(), FRAME_PLAYOUT, VIDEO_EVENT, + /*rtp_timestamp*/ 100u, /*frame_id*/ 2u, + base::TimeDelta::FromMilliseconds(kDelayMs)); cast_environment_->Logging()->InsertFrameEvent( - testing_clock_->NowTicks(), kVideoFrameDecoded, /*rtp_timestamp*/ 200u, - /*frame_id*/ 1u); + testing_clock_->NowTicks(), FRAME_DECODED, VIDEO_EVENT, + /*rtp_timestamp*/ 200u, /*frame_id*/ 1u); cast_environment_->Logging()->InsertPacketEvent( - testing_clock_->NowTicks(), kVideoPacketReceived, + testing_clock_->NowTicks(), PACKET_RECEIVED, VIDEO_EVENT, /*rtp_timestamp */ 200u, /*frame_id*/ 2u, /*packet_id*/ 1u, /*max_packet_id*/ 10u, /*size*/ 1024u); // Audio events cast_environment_->Logging()->InsertFrameEventWithDelay( - testing_clock_->NowTicks(), kAudioPlayoutDelay, /*rtp_timestamp*/ 300u, - /*frame_id*/ 4u, base::TimeDelta::FromMilliseconds(kDelayMs)); + testing_clock_->NowTicks(), FRAME_PLAYOUT, AUDIO_EVENT, + /*rtp_timestamp*/ 300u, /*frame_id*/ 4u, + base::TimeDelta::FromMilliseconds(kDelayMs)); cast_environment_->Logging()->InsertFrameEvent( - testing_clock_->NowTicks(), kAudioFrameDecoded, /*rtp_timestamp*/ 400u, - /*frame_id*/ 3u); + testing_clock_->NowTicks(), FRAME_DECODED, AUDIO_EVENT, + /*rtp_timestamp*/ 400u, /*frame_id*/ 3u); cast_environment_->Logging()->InsertPacketEvent( - testing_clock_->NowTicks(), kAudioPacketReceived, + testing_clock_->NowTicks(), PACKET_RECEIVED, AUDIO_EVENT, /*rtp_timestamp */ 400u, /*frame_id*/ 5u, /*packet_id*/ 1u, /*max_packet_id*/ 10u, /*size*/ 128u); // Unrelated events cast_environment_->Logging()->InsertFrameEvent(testing_clock_->NowTicks(), - kVideoFrameCaptureEnd, + FRAME_CAPTURE_END, + VIDEO_EVENT, /*rtp_timestamp*/ 100u, /*frame_id*/ 1u); cast_environment_->Logging()->InsertFrameEvent(testing_clock_->NowTicks(), - kAudioFrameCaptureEnd, + FRAME_CAPTURE_END, + AUDIO_EVENT, /*rtp_timestamp*/ 100u, /*frame_id*/ 1u); } @@ -92,7 +96,7 @@ class ReceiverRtcpEventSubscriberTest : public ::testing::Test { }; TEST_F(ReceiverRtcpEventSubscriberTest, LogVideoEvents) { - Init(ReceiverRtcpEventSubscriber::kVideoEventSubscriber); + Init(VIDEO_EVENT); InsertEvents(); ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events; @@ -101,7 +105,7 @@ TEST_F(ReceiverRtcpEventSubscriberTest, LogVideoEvents) { } TEST_F(ReceiverRtcpEventSubscriberTest, LogAudioEvents) { - Init(ReceiverRtcpEventSubscriber::kAudioEventSubscriber); + Init(AUDIO_EVENT); InsertEvents(); ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events; @@ -110,11 +114,11 @@ TEST_F(ReceiverRtcpEventSubscriberTest, LogAudioEvents) { } TEST_F(ReceiverRtcpEventSubscriberTest, DropEventsWhenSizeExceeded) { - Init(ReceiverRtcpEventSubscriber::kVideoEventSubscriber); + Init(VIDEO_EVENT); for (uint32 i = 1u; i <= 10u; ++i) { cast_environment_->Logging()->InsertFrameEvent( - testing_clock_->NowTicks(), kVideoFrameDecoded, + testing_clock_->NowTicks(), FRAME_DECODED, VIDEO_EVENT, /*rtp_timestamp*/ i * 10, /*frame_id*/ i); } diff --git a/media/cast/rtcp/rtcp.cc b/media/cast/rtcp/rtcp.cc index 234a1e9..0944594 100644 --- a/media/cast/rtcp/rtcp.cc +++ b/media/cast/rtcp/rtcp.cc @@ -68,45 +68,7 @@ class LocalRtcpReceiverFeedback : public RtcpReceiverFeedback { virtual void OnReceivedReceiverLog(const RtcpReceiverLogMessage& receiver_log) OVERRIDE { - // Add received log messages into our log system. - RtcpReceiverLogMessage::const_iterator it = receiver_log.begin(); - - for (; it != receiver_log.end(); ++it) { - uint32 rtp_timestamp = it->rtp_timestamp_; - - RtcpReceiverEventLogMessages::const_iterator event_it = - it->event_log_messages_.begin(); - for (; event_it != it->event_log_messages_.end(); ++event_it) { - switch (event_it->type) { - case kAudioPacketReceived: - case kVideoPacketReceived: - case kDuplicateAudioPacketReceived: - case kDuplicateVideoPacketReceived: - cast_environment_->Logging()->InsertPacketEvent( - event_it->event_timestamp, event_it->type, rtp_timestamp, - kFrameIdUnknown, event_it->packet_id, 0, 0); - break; - case kAudioAckSent: - case kVideoAckSent: - case kAudioFrameDecoded: - case kVideoFrameDecoded: - cast_environment_->Logging()->InsertFrameEvent( - event_it->event_timestamp, event_it->type, rtp_timestamp, - kFrameIdUnknown); - break; - case kAudioPlayoutDelay: - case kVideoRenderDelay: - cast_environment_->Logging()->InsertFrameEventWithDelay( - event_it->event_timestamp, event_it->type, rtp_timestamp, - kFrameIdUnknown, event_it->delay_delta); - break; - default: - VLOG(2) << "Received log message via RTCP that we did not expect: " - << static_cast<int>(event_it->type); - break; - } - } - } + rtcp_->OnReceivedReceiverLog(receiver_log); } virtual void OnReceivedSenderLog( @@ -115,7 +77,7 @@ class LocalRtcpReceiverFeedback : public RtcpReceiverFeedback { for (; it != sender_log.end(); ++it) { uint32 rtp_timestamp = it->rtp_timestamp; - CastLoggingEvent log_event = kUnknown; + CastLoggingEvent log_event = UNKNOWN; // These events are provided to know the status of frames that never // reached the receiver. The timing information for these events are not @@ -123,18 +85,13 @@ class LocalRtcpReceiverFeedback : public RtcpReceiverFeedback { switch (it->frame_status) { case transport::kRtcpSenderFrameStatusDroppedByFlowControl: // A frame that have been dropped by the flow control would have - // kVideoFrameCaptureBegin as its last event in the log. - log_event = kVideoFrameCaptureBegin; - break; - case transport::kRtcpSenderFrameStatusDroppedByEncoder: - // A frame that have been dropped by the encoder would have - // kVideoFrameSentToEncoder as its last event in the log. - log_event = kVideoFrameSentToEncoder; + // FRAME_CAPTURE_BEGIN as its last event in the log. + log_event = FRAME_CAPTURE_BEGIN; break; case transport::kRtcpSenderFrameStatusSentToNetwork: // A frame that have be encoded is always sent to the network. We // do not add a new log entry for this. - log_event = kVideoFrameEncoded; + log_event = FRAME_ENCODED; break; default: continue; @@ -145,7 +102,7 @@ class LocalRtcpReceiverFeedback : public RtcpReceiverFeedback { // we need to send in one. base::TimeTicks now = cast_environment_->Clock()->NowTicks(); cast_environment_->Logging()->InsertFrameEvent( - now, log_event, rtp_timestamp, kFrameIdUnknown); + now, log_event, VIDEO_EVENT, rtp_timestamp, kFrameIdUnknown); } } @@ -160,7 +117,7 @@ Rtcp::Rtcp(scoped_refptr<CastEnvironment> cast_environment, transport::PacedPacketSender* paced_packet_sender, RtpReceiverStatistics* rtp_receiver_statistics, RtcpMode rtcp_mode, const base::TimeDelta& rtcp_interval, uint32 local_ssrc, - uint32 remote_ssrc, const std::string& c_name) + uint32 remote_ssrc, const std::string& c_name, bool is_audio) : cast_environment_(cast_environment), transport_sender_(transport_sender), rtcp_interval_(rtcp_interval), @@ -178,7 +135,8 @@ Rtcp::Rtcp(scoped_refptr<CastEnvironment> cast_environment, last_received_ntp_seconds_(0), last_received_ntp_fraction_(0), min_rtt_(base::TimeDelta::FromMilliseconds(kMaxRttMs)), - number_of_rtt_in_avg_(0) { + number_of_rtt_in_avg_(0), + is_audio_(is_audio) { rtcp_receiver_.reset(new RtcpReceiver(cast_environment, sender_feedback, receiver_feedback_.get(), rtt_feedback_.get(), local_ssrc)); @@ -477,5 +435,42 @@ void Rtcp::UpdateNextTimeToSendRtcp() { next_time_to_send_rtcp_ = now + time_to_next; } +void Rtcp::OnReceivedReceiverLog(const RtcpReceiverLogMessage& receiver_log) { + // Add received log messages into our log system. + RtcpReceiverLogMessage::const_iterator it = receiver_log.begin(); + EventMediaType media_type = is_audio_ ? AUDIO_EVENT : VIDEO_EVENT; + for (; it != receiver_log.end(); ++it) { + uint32 rtp_timestamp = it->rtp_timestamp_; + + RtcpReceiverEventLogMessages::const_iterator event_it = + it->event_log_messages_.begin(); + for (; event_it != it->event_log_messages_.end(); ++event_it) { + switch (event_it->type) { + case PACKET_RECEIVED: + cast_environment_->Logging()->InsertPacketEvent( + event_it->event_timestamp, event_it->type, + media_type, rtp_timestamp, + kFrameIdUnknown, event_it->packet_id, 0, 0); + break; + case FRAME_ACK_SENT: + case FRAME_DECODED: + cast_environment_->Logging()->InsertFrameEvent( + event_it->event_timestamp, event_it->type, media_type, + rtp_timestamp, kFrameIdUnknown); + break; + case FRAME_PLAYOUT: + cast_environment_->Logging()->InsertFrameEventWithDelay( + event_it->event_timestamp, event_it->type, media_type, + rtp_timestamp, kFrameIdUnknown, event_it->delay_delta); + break; + default: + VLOG(2) << "Received log message via RTCP that we did not expect: " + << static_cast<int>(event_it->type); + break; + } + } + } +} + } // namespace cast } // namespace media diff --git a/media/cast/rtcp/rtcp.h b/media/cast/rtcp/rtcp.h index 15bbe11..52c9178 100644 --- a/media/cast/rtcp/rtcp.h +++ b/media/cast/rtcp/rtcp.h @@ -68,7 +68,8 @@ class Rtcp { const base::TimeDelta& rtcp_interval, uint32 local_ssrc, uint32 remote_ssrc, - const std::string& c_name); + const std::string& c_name, + bool is_audio); virtual ~Rtcp(); @@ -111,6 +112,8 @@ class Rtcp { // Update the target delay. Will be added to every sender report. void SetTargetDelay(base::TimeDelta target_delay); + void OnReceivedReceiverLog(const RtcpReceiverLogMessage& receiver_log); + protected: int CheckForWrapAround(uint32 new_timestamp, uint32 old_timestamp) const; @@ -176,6 +179,7 @@ class Rtcp { int number_of_rtt_in_avg_; float avg_rtt_ms_; uint16 target_delay_ms_; + bool is_audio_; DISALLOW_COPY_AND_ASSIGN(Rtcp); }; diff --git a/media/cast/rtcp/rtcp_defines.cc b/media/cast/rtcp/rtcp_defines.cc index 858aa27..214100d 100644 --- a/media/cast/rtcp/rtcp_defines.cc +++ b/media/cast/rtcp/rtcp_defines.cc @@ -21,7 +21,7 @@ void RtcpCastMessage::Copy(const RtcpCastMessage& cast_message) { } RtcpReceiverEventLogMessage::RtcpReceiverEventLogMessage() - : type(kUnknown), packet_id(0u) {} + : type(UNKNOWN), packet_id(0u) {} RtcpReceiverEventLogMessage::~RtcpReceiverEventLogMessage() {} RtcpReceiverFrameLogMessage::RtcpReceiverFrameLogMessage(uint32 timestamp) @@ -42,7 +42,7 @@ RtcpReceiverReferenceTimeReport::RtcpReceiverReferenceTimeReport() : remote_ssrc(0u), ntp_seconds(0u), ntp_fraction(0u) {} RtcpReceiverReferenceTimeReport::~RtcpReceiverReferenceTimeReport() {} -RtcpEvent::RtcpEvent() : type(kUnknown), packet_id(0u) {} +RtcpEvent::RtcpEvent() : type(UNKNOWN), packet_id(0u) {} RtcpEvent::~RtcpEvent() {} } // namespace cast diff --git a/media/cast/rtcp/rtcp_defines.h b/media/cast/rtcp/rtcp_defines.h index 5cc4a59..f121742 100644 --- a/media/cast/rtcp/rtcp_defines.h +++ b/media/cast/rtcp/rtcp_defines.h @@ -111,7 +111,7 @@ inline bool operator==(RtcpReceiverReferenceTimeReport lhs, // Struct used by raw event subscribers as an intermediate format before // sending off to the other side via RTCP. -// (i.e., WindowedRtcpEventRtp{Sender,Receiver}Subscriber) +// (i.e., {Sender,Receiver}RtcpEventSubscriber) struct RtcpEvent { RtcpEvent(); ~RtcpEvent(); @@ -121,11 +121,10 @@ struct RtcpEvent { // Time of event logged. base::TimeTicks timestamp; - // Render/playout delay. Only set for kAudioPlayoutDelay and - // kVideoRenderDelay events. + // Render/playout delay. Only set for FRAME_PLAYOUT events. base::TimeDelta delay_delta; - // Only set for packet events. (kAudioPacketReceived, kVideoPacketReceived) + // Only set for packet events. uint16 packet_id; }; diff --git a/media/cast/rtcp/rtcp_receiver.cc b/media/cast/rtcp/rtcp_receiver.cc index 9345d58..f5100b9 100644 --- a/media/cast/rtcp/rtcp_receiver.cc +++ b/media/cast/rtcp/rtcp_receiver.cc @@ -10,13 +10,6 @@ namespace { -bool IsRtcpPacketEvent(media::cast::CastLoggingEvent event_type) { - return event_type == media::cast::kAudioPacketReceived || - event_type == media::cast::kVideoPacketReceived || - event_type == media::cast::kDuplicateAudioPacketReceived || - event_type == media::cast::kDuplicateVideoPacketReceived; -} - media::cast::transport::RtcpSenderFrameStatus TranslateToFrameStatusFromWireFormat(uint8 status) { switch (status) { @@ -479,7 +472,7 @@ void RtcpReceiver::HandleApplicationSpecificCastReceiverEventLog( const uint8 event = rtcp_field.cast_receiver_log.event; const CastLoggingEvent event_type = TranslateToLogEventFromWireFormat(event); - uint16 packet_id = IsRtcpPacketEvent(event_type) ? + uint16 packet_id = event_type == PACKET_RECEIVED ? rtcp_field.cast_receiver_log.delay_delta_or_packet_id.packet_id : 0; const base::TimeTicks event_timestamp = base::TimeTicks() + diff --git a/media/cast/rtcp/rtcp_receiver_unittest.cc b/media/cast/rtcp/rtcp_receiver_unittest.cc index 74a60dc..fb42bce 100644 --- a/media/cast/rtcp/rtcp_receiver_unittest.cc +++ b/media/cast/rtcp/rtcp_receiver_unittest.cc @@ -98,7 +98,7 @@ class RtcpReceiverCastLogVerification : public RtcpReceiverFeedback { EXPECT_EQ(event_expected_it->type, event_incoming_it->type); EXPECT_EQ(event_expected_it->event_timestamp, event_incoming_it->event_timestamp); - if (event_expected_it->type == kVideoPacketReceived) { + if (event_expected_it->type == PACKET_RECEIVED) { EXPECT_EQ(event_expected_it->packet_id, event_incoming_it->packet_id); } else { EXPECT_EQ(event_expected_it->delay_delta, @@ -501,18 +501,18 @@ TEST_F(RtcpReceiverTest, InjectReceiverReportWithReceiverLogVerificationBase) { RtcpReceiverFrameLogMessage frame_log(kRtpTimestamp); RtcpReceiverEventLogMessage event_log; - event_log.type = kVideoAckSent; + event_log.type = FRAME_ACK_SENT; event_log.event_timestamp = testing_clock.NowTicks(); event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs); frame_log.event_log_messages_.push_back(event_log); testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); - event_log.type = kVideoPacketReceived; + event_log.type = PACKET_RECEIVED; event_log.event_timestamp = testing_clock.NowTicks(); event_log.packet_id = kLostPacketId1; frame_log.event_log_messages_.push_back(event_log); - event_log.type = kVideoPacketReceived; + event_log.type = PACKET_RECEIVED; event_log.event_timestamp = testing_clock.NowTicks(); event_log.packet_id = kLostPacketId2; frame_log.event_log_messages_.push_back(event_log); @@ -526,15 +526,15 @@ TEST_F(RtcpReceiverTest, InjectReceiverReportWithReceiverLogVerificationBase) { p.AddRb(kSourceSsrc); p.AddReceiverLog(kSenderSsrc); p.AddReceiverFrameLog(kRtpTimestamp, 3, kTimeBaseMs); - p.AddReceiverEventLog(kDelayDeltaMs, kVideoAckSent, 0); - p.AddReceiverEventLog(kLostPacketId1, kVideoPacketReceived, kTimeDelayMs); - p.AddReceiverEventLog(kLostPacketId2, kVideoPacketReceived, kTimeDelayMs); + p.AddReceiverEventLog(kDelayDeltaMs, FRAME_ACK_SENT, 0); + p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs); + p.AddReceiverEventLog(kLostPacketId2, PACKET_RECEIVED, kTimeDelayMs); // Adds duplicated receiver event. p.AddReceiverFrameLog(kRtpTimestamp, 3, kTimeBaseMs); - p.AddReceiverEventLog(kDelayDeltaMs, kVideoAckSent, 0); - p.AddReceiverEventLog(kLostPacketId1, kVideoPacketReceived, kTimeDelayMs); - p.AddReceiverEventLog(kLostPacketId2, kVideoPacketReceived, kTimeDelayMs); + p.AddReceiverEventLog(kDelayDeltaMs, FRAME_ACK_SENT, 0); + p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs); + p.AddReceiverEventLog(kLostPacketId2, PACKET_RECEIVED, kTimeDelayMs); EXPECT_CALL(mock_rtt_feedback_, OnReceivedDelaySinceLastReport( @@ -566,7 +566,7 @@ TEST_F(RtcpReceiverTest, InjectReceiverReportWithReceiverLogVerificationMulti) { for (int j = 0; j < 100; ++j) { RtcpReceiverFrameLogMessage frame_log(kRtpTimestamp); RtcpReceiverEventLogMessage event_log; - event_log.type = kVideoAckSent; + event_log.type = FRAME_ACK_SENT; event_log.event_timestamp = testing_clock.NowTicks(); event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs); frame_log.event_log_messages_.push_back(event_log); @@ -582,7 +582,7 @@ TEST_F(RtcpReceiverTest, InjectReceiverReportWithReceiverLogVerificationMulti) { p.AddReceiverLog(kSenderSsrc); for (int i = 0; i < 100; ++i) { p.AddReceiverFrameLog(kRtpTimestamp, 1, kTimeBaseMs + i * kTimeDelayMs); - p.AddReceiverEventLog(kDelayDeltaMs, kVideoAckSent, 0); + p.AddReceiverEventLog(kDelayDeltaMs, FRAME_ACK_SENT, 0); } EXPECT_CALL(mock_rtt_feedback_, diff --git a/media/cast/rtcp/rtcp_sender.cc b/media/cast/rtcp/rtcp_sender.cc index ba1a079..bf7d30c 100644 --- a/media/cast/rtcp/rtcp_sender.cc +++ b/media/cast/rtcp/rtcp_sender.cc @@ -682,20 +682,14 @@ void RtcpSender::BuildReceiverLog( event_message.type, event_message.event_timestamp - event_timestamp_base); switch (event_message.type) { - case kAudioAckSent: - case kVideoAckSent: - case kAudioPlayoutDelay: - case kAudioFrameDecoded: - case kVideoFrameDecoded: - case kVideoRenderDelay: + case FRAME_ACK_SENT: + case FRAME_PLAYOUT: + case FRAME_DECODED: big_endian_writer.WriteU16( static_cast<uint16>(event_message.delay_delta.InMilliseconds())); big_endian_writer.WriteU16(event_type_and_timestamp_delta); break; - case kAudioPacketReceived: - case kVideoPacketReceived: - case kDuplicateAudioPacketReceived: - case kDuplicateVideoPacketReceived: + case PACKET_RECEIVED: big_endian_writer.WriteU16(event_message.packet_id); big_endian_writer.WriteU16(event_type_and_timestamp_delta); break; diff --git a/media/cast/rtcp/rtcp_sender_unittest.cc b/media/cast/rtcp/rtcp_sender_unittest.cc index 6746a68..2074bdb 100644 --- a/media/cast/rtcp/rtcp_sender_unittest.cc +++ b/media/cast/rtcp/rtcp_sender_unittest.cc @@ -255,8 +255,7 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) { cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] = missing_packets; - ReceiverRtcpEventSubscriber event_subscriber( - 500, ReceiverRtcpEventSubscriber::kVideoEventSubscriber); + ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT); ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events; rtcp_sender_->SendRtcpFromRtpReceiver( @@ -273,21 +272,23 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) { p.AddReceiverLog(kSendingSsrc); p.AddReceiverFrameLog(kRtpTimestamp, 2, kTimeBaseMs); - p.AddReceiverEventLog(0, kVideoAckSent, 0); - p.AddReceiverEventLog(kLostPacketId1, kVideoPacketReceived, kTimeDelayMs); + p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0); + p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs); test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); FrameEvent frame_event; frame_event.rtp_timestamp = kRtpTimestamp; - frame_event.type = kVideoAckSent; + frame_event.type = FRAME_ACK_SENT; + frame_event.media_type = VIDEO_EVENT; frame_event.timestamp = testing_clock.NowTicks(); event_subscriber.OnReceiveFrameEvent(frame_event); testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); PacketEvent packet_event; packet_event.rtp_timestamp = kRtpTimestamp; - packet_event.type = kVideoPacketReceived; + packet_event.type = PACKET_RECEIVED; + packet_event.media_type = VIDEO_EVENT; packet_event.timestamp = testing_clock.NowTicks(); packet_event.packet_id = kLostPacketId1; event_subscriber.OnReceivePacketEvent(packet_event); @@ -335,24 +336,25 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithOversizedFrameLog) { kTimeBaseMs + (kRtcpMaxReceiverLogMessages - num_events) * kTimeDelayMs); for (int i = 0; i < num_events; i++) { p.AddReceiverEventLog( - kLostPacketId1, kVideoPacketReceived, + kLostPacketId1, PACKET_RECEIVED, static_cast<uint16>(kTimeDelayMs * i)); } test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); - ReceiverRtcpEventSubscriber event_subscriber( - 500, ReceiverRtcpEventSubscriber::kVideoEventSubscriber); + ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT); FrameEvent frame_event; frame_event.rtp_timestamp = kRtpTimestamp; - frame_event.type = media::cast::kVideoAckSent; + frame_event.type = FRAME_ACK_SENT; + frame_event.media_type = VIDEO_EVENT; frame_event.timestamp = testing_clock.NowTicks(); event_subscriber.OnReceiveFrameEvent(frame_event); for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) { PacketEvent packet_event; packet_event.rtp_timestamp = kRtpTimestamp + 2345; - packet_event.type = kVideoPacketReceived; + packet_event.type = PACKET_RECEIVED; + packet_event.media_type = VIDEO_EVENT; packet_event.timestamp = testing_clock.NowTicks(); packet_event.packet_id = kLostPacketId1; event_subscriber.OnReceivePacketEvent(packet_event); @@ -400,17 +402,17 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithTooManyLogFrames) { i < kRtcpMaxReceiverLogMessages; ++i) { p.AddReceiverFrameLog(kRtpTimestamp + i, 1, kTimeBaseMs + i * kTimeDelayMs); - p.AddReceiverEventLog(0, kVideoAckSent, 0); + p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0); } test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); - ReceiverRtcpEventSubscriber event_subscriber( - 500, ReceiverRtcpEventSubscriber::kVideoEventSubscriber); + ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT); for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) { FrameEvent frame_event; frame_event.rtp_timestamp = kRtpTimestamp + static_cast<int>(i); - frame_event.type = media::cast::kVideoAckSent; + frame_event.type = FRAME_ACK_SENT; + frame_event.media_type = VIDEO_EVENT; frame_event.timestamp = testing_clock.NowTicks(); event_subscriber.OnReceiveFrameEvent(frame_event); testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); @@ -451,16 +453,16 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithOldLogFrames) { const int kTimeBetweenEventsMs = 410; p.AddReceiverFrameLog(kRtpTimestamp, 10, kTimeBaseMs + kTimeBetweenEventsMs); for (int i = 0; i < 10; ++i) { - p.AddReceiverEventLog(0, kVideoAckSent, i * kTimeBetweenEventsMs); + p.AddReceiverEventLog(0, FRAME_ACK_SENT, i * kTimeBetweenEventsMs); } test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); - ReceiverRtcpEventSubscriber event_subscriber( - 500, ReceiverRtcpEventSubscriber::kVideoEventSubscriber); + ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT); for (int i = 0; i < 11; ++i) { FrameEvent frame_event; frame_event.rtp_timestamp = kRtpTimestamp; - frame_event.type = media::cast::kVideoAckSent; + frame_event.type = FRAME_ACK_SENT; + frame_event.media_type = VIDEO_EVENT; frame_event.timestamp = testing_clock.NowTicks(); event_subscriber.OnReceiveFrameEvent(frame_event); testing_clock.Advance( @@ -490,8 +492,7 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportRedundancy) { base::SimpleTestTickClock testing_clock; testing_clock.Advance(base::TimeDelta::FromMilliseconds(time_base_ms)); - ReceiverRtcpEventSubscriber event_subscriber( - 500, ReceiverRtcpEventSubscriber::kVideoEventSubscriber); + ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT); size_t packet_count = kReceiveLogMessageHistorySize + 10; for (size_t i = 0; i < packet_count; i++) { TestRtcpPacketBuilder p; @@ -506,23 +507,24 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportRedundancy) { kRtpTimestamp, 1, time_base_ms - kSecondRedundancyOffset * kTimeBetweenEventsMs); - p.AddReceiverEventLog(0, kVideoAckSent, 0); + p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0); } if (i >= kFirstRedundancyOffset) { p.AddReceiverFrameLog( kRtpTimestamp, 1, time_base_ms - kFirstRedundancyOffset * kTimeBetweenEventsMs); - p.AddReceiverEventLog(0, kVideoAckSent, 0); + p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0); } p.AddReceiverFrameLog(kRtpTimestamp, 1, time_base_ms); - p.AddReceiverEventLog(0, kVideoAckSent, 0); + p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0); test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); FrameEvent frame_event; frame_event.rtp_timestamp = kRtpTimestamp; - frame_event.type = media::cast::kVideoAckSent; + frame_event.type = FRAME_ACK_SENT; + frame_event.media_type = VIDEO_EVENT; frame_event.timestamp = testing_clock.NowTicks(); event_subscriber.OnReceiveFrameEvent(frame_event); diff --git a/media/cast/rtcp/rtcp_unittest.cc b/media/cast/rtcp/rtcp_unittest.cc index 2918c75..16aaef2 100644 --- a/media/cast/rtcp/rtcp_unittest.cc +++ b/media/cast/rtcp/rtcp_unittest.cc @@ -140,7 +140,8 @@ class RtcpPeer : public Rtcp { rtcp_interval, local_ssrc, remote_ssrc, - c_name) {} + c_name, + true) {} using Rtcp::CheckForWrapAround; using Rtcp::OnReceivedLipSyncInfo; @@ -214,7 +215,8 @@ TEST_F(RtcpTest, TimeToSend) { base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), kSenderSsrc, kReceiverSsrc, - kCName); + kCName, + true); receiver_to_sender_.set_rtcp_receiver(&rtcp); EXPECT_LE(start_time, rtcp.TimeToSendNextRtcpReport()); EXPECT_GE( @@ -235,7 +237,8 @@ TEST_F(RtcpTest, BasicSenderReport) { base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), kSenderSsrc, kReceiverSsrc, - kCName); + kCName, + true); sender_to_receiver_.set_rtcp_receiver(&rtcp); transport::RtcpSenderLogMessage empty_sender_log; rtcp.SendRtcpFromRtpSender(empty_sender_log, rtp_sender_stats_.sender_info()); @@ -251,7 +254,8 @@ TEST_F(RtcpTest, BasicReceiverReport) { base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), kSenderSsrc, kReceiverSsrc, - kCName); + kCName, + true); receiver_to_sender_.set_rtcp_receiver(&rtcp); rtcp.SendRtcpFromRtpReceiver(NULL, NULL); } @@ -269,7 +273,8 @@ TEST_F(RtcpTest, BasicCast) { base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), kSenderSsrc, kSenderSsrc, - kCName); + kCName, + true); receiver_to_sender_.set_rtcp_receiver(&rtcp); RtcpCastMessage cast_message(kSenderSsrc); cast_message.ack_frame_id_ = kAckFrameId; @@ -295,7 +300,8 @@ TEST_F(RtcpTest, RttReducedSizeRtcp) { base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), kReceiverSsrc, kSenderSsrc, - kCName); + kCName, + true); // Media sender. Rtcp rtcp_sender(cast_environment_, @@ -307,7 +313,8 @@ TEST_F(RtcpTest, RttReducedSizeRtcp) { base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), kSenderSsrc, kReceiverSsrc, - kCName); + kCName, + true); sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver); receiver_to_sender_.set_rtcp_receiver(&rtcp_sender); @@ -352,7 +359,8 @@ TEST_F(RtcpTest, Rtt) { base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), kReceiverSsrc, kSenderSsrc, - kCName); + kCName, + true); // Media sender. Rtcp rtcp_sender(cast_environment_, @@ -364,7 +372,8 @@ TEST_F(RtcpTest, Rtt) { base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), kSenderSsrc, kReceiverSsrc, - kCName); + kCName, + true); receiver_to_sender_.set_rtcp_receiver(&rtcp_sender); sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver); @@ -447,7 +456,8 @@ TEST_F(RtcpTest, RttWithPacketLoss) { base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), kSenderSsrc, kReceiverSsrc, - kCName); + kCName, + true); // Media sender. Rtcp rtcp_sender(cast_environment_, @@ -459,7 +469,8 @@ TEST_F(RtcpTest, RttWithPacketLoss) { base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), kReceiverSsrc, kSenderSsrc, - kCName); + kCName, + true); receiver_to_sender_.set_rtcp_receiver(&rtcp_sender); sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver); diff --git a/media/cast/rtcp/rtcp_utility.cc b/media/cast/rtcp/rtcp_utility.cc index da6ef9d..f280601 100644 --- a/media/cast/rtcp/rtcp_utility.cc +++ b/media/cast/rtcp/rtcp_utility.cc @@ -1051,61 +1051,51 @@ bool RtcpParser::ParseExtendedReportDelaySinceLastReceiverReport() { return true; } +// Converts a log event type to an integer value. +// NOTE: We have only allocated 4 bits to represent the type of event over the +// wire. Therefore, this function can only return values from 0 to 15. uint8 ConvertEventTypeToWireFormat(CastLoggingEvent event) { switch (event) { - case kAudioAckSent: - return 1; - case kAudioPlayoutDelay: - return 2; - case kAudioFrameDecoded: - return 3; - case kAudioPacketReceived: - return 4; - case kVideoAckSent: - return 5; - case kVideoFrameDecoded: - return 6; - case kVideoRenderDelay: - return 7; - case kVideoPacketReceived: - return 8; - case kDuplicateAudioPacketReceived: - return 9; - case kDuplicateVideoPacketReceived: - return 10; + case FRAME_ACK_SENT: + return 11; + case FRAME_PLAYOUT: + return 12; + case FRAME_DECODED: + return 13; + case PACKET_RECEIVED: + return 14; default: return 0; // Not an interesting event. } } CastLoggingEvent TranslateToLogEventFromWireFormat(uint8 event) { + // TODO(imcheng): Remove the old mappings once they are no longer used. switch (event) { - case 1: - return media::cast::kAudioAckSent; - case 2: - return media::cast::kAudioPlayoutDelay; - case 3: - return media::cast::kAudioFrameDecoded; - case 4: - return media::cast::kAudioPacketReceived; - case 5: - return media::cast::kVideoAckSent; - case 6: - return media::cast::kVideoFrameDecoded; - case 7: - return media::cast::kVideoRenderDelay; - case 8: - return media::cast::kVideoPacketReceived; - case 9: - return media::cast::kDuplicateAudioPacketReceived; - case 10: - return media::cast::kDuplicateVideoPacketReceived; + case 1: // AudioAckSent + case 5: // VideoAckSent + case 11: // Unified + return FRAME_ACK_SENT; + case 2: // AudioPlayoutDelay + case 7: // VideoRenderDelay + case 12: // Unified + return FRAME_PLAYOUT; + case 3: // AudioFrameDecoded + case 6: // VideoFrameDecoded + case 13: // Unified + return FRAME_DECODED; + case 4: // AudioPacketReceived + case 8: // VideoPacketReceived + case 14: // Unified + return PACKET_RECEIVED; + case 9: // DuplicateAudioPacketReceived + case 10: // DuplicateVideoPacketReceived default: // If the sender adds new log messages we will end up here until we add // the new messages in the receiver. VLOG(1) << "Unexpected log message received: " << static_cast<int>(event); NOTREACHED(); - return media::cast::kUnknown; + return UNKNOWN; } } diff --git a/media/cast/rtcp/sender_rtcp_event_subscriber.cc b/media/cast/rtcp/sender_rtcp_event_subscriber.cc index 05bcf3b..6a44b33 100644 --- a/media/cast/rtcp/sender_rtcp_event_subscriber.cc +++ b/media/cast/rtcp/sender_rtcp_event_subscriber.cc @@ -25,9 +25,10 @@ SenderRtcpEventSubscriber::~SenderRtcpEventSubscriber() { void SenderRtcpEventSubscriber::OnReceiveFrameEvent( const FrameEvent& frame_event) { DCHECK(thread_checker_.CalledOnValidThread()); - if (frame_event.type != kVideoFrameCaptureBegin && - frame_event.type != kVideoFrameSentToEncoder && - frame_event.type != kVideoFrameEncoded) { + if (frame_event.media_type != VIDEO_EVENT) + return; + if (frame_event.type != FRAME_CAPTURE_BEGIN && + frame_event.type != FRAME_ENCODED) { // Not interested in other events. return; } @@ -48,11 +49,11 @@ void SenderRtcpEventSubscriber::OnReceiveFrameEvent( // We already have this frame (RTP timestamp) in our map. // Only update events that are later in the chain. // This is due to that events can be reordered on the wire. - if (frame_event.type == kVideoFrameCaptureBegin) { + if (frame_event.type == FRAME_CAPTURE_BEGIN) { return; // First event in chain can not be late by definition. } - if (it->second.type == kVideoFrameEncoded) { + if (it->second.type == FRAME_ENCODED) { return; // Last event in chain should not be updated. } diff --git a/media/cast/rtcp/sender_rtcp_event_subscriber_unittest.cc b/media/cast/rtcp/sender_rtcp_event_subscriber_unittest.cc index 95f2306..d760286 100644 --- a/media/cast/rtcp/sender_rtcp_event_subscriber_unittest.cc +++ b/media/cast/rtcp/sender_rtcp_event_subscriber_unittest.cc @@ -47,17 +47,15 @@ class SenderRtcpEventSubscriberTest : public ::testing::Test { TEST_F(SenderRtcpEventSubscriberTest, InsertEntry) { cast_environment_->Logging()->InsertFrameEvent( - testing_clock_->NowTicks(), kVideoFrameCaptureBegin, 100u, 1u); + testing_clock_->NowTicks(), FRAME_CAPTURE_BEGIN, VIDEO_EVENT, 100u, 1u); cast_environment_->Logging()->InsertFrameEvent( - testing_clock_->NowTicks(), kVideoFrameCaptureBegin, 200u, 2u); - cast_environment_->Logging()->InsertFrameEvent( - testing_clock_->NowTicks(), kVideoFrameSentToEncoder, 100u, 1u); + testing_clock_->NowTicks(), FRAME_CAPTURE_BEGIN, VIDEO_EVENT, 200u, 2u); cast_environment_->Logging()->InsertFrameEvent(testing_clock_->NowTicks(), - kVideoFrameEncoded, 100u, 1u); + FRAME_ENCODED, VIDEO_EVENT, + 100u, 1u); cast_environment_->Logging()->InsertFrameEvent(testing_clock_->NowTicks(), - kVideoFrameEncoded, 300u, 3u); - cast_environment_->Logging()->InsertFrameEvent( - testing_clock_->NowTicks(), kVideoFrameSentToEncoder, 300u, 3u); + FRAME_ENCODED, VIDEO_EVENT, + 300u, 3u); RtcpEventMap events; event_subscriber_.GetRtcpEventsAndReset(&events); @@ -66,20 +64,20 @@ TEST_F(SenderRtcpEventSubscriberTest, InsertEntry) { RtcpEventMap::iterator it = events.begin(); EXPECT_EQ(100u, it->first); - EXPECT_EQ(kVideoFrameEncoded, it->second.type); + EXPECT_EQ(FRAME_ENCODED, it->second.type); ++it; EXPECT_EQ(200u, it->first); - EXPECT_EQ(kVideoFrameCaptureBegin, it->second.type); + EXPECT_EQ(FRAME_CAPTURE_BEGIN, it->second.type); ++it; EXPECT_EQ(300u, it->first); - EXPECT_EQ(kVideoFrameEncoded, it->second.type); + EXPECT_EQ(FRAME_ENCODED, it->second.type); } TEST_F(SenderRtcpEventSubscriberTest, MapReset) { cast_environment_->Logging()->InsertFrameEvent( - testing_clock_->NowTicks(), kVideoFrameCaptureBegin, 100u, 1u); + testing_clock_->NowTicks(), FRAME_CAPTURE_BEGIN, VIDEO_EVENT, 100u, 1u); RtcpEventMap events; event_subscriber_.GetRtcpEventsAndReset(&events); @@ -93,7 +91,8 @@ TEST_F(SenderRtcpEventSubscriberTest, MapReset) { TEST_F(SenderRtcpEventSubscriberTest, DropEventsWhenSizeExceeded) { for (uint32 i = 1u; i <= 10u; ++i) { cast_environment_->Logging()->InsertFrameEvent( - testing_clock_->NowTicks(), kVideoFrameCaptureBegin, i * 10, i); + testing_clock_->NowTicks(), FRAME_CAPTURE_BEGIN, VIDEO_EVENT, + i * 10, i); } RtcpEventMap events; @@ -105,7 +104,8 @@ TEST_F(SenderRtcpEventSubscriberTest, DropEventsWhenSizeExceeded) { for (uint32 i = 1u; i <= 11u; ++i) { cast_environment_->Logging()->InsertFrameEvent( - testing_clock_->NowTicks(), kVideoFrameCaptureBegin, i * 10, i); + testing_clock_->NowTicks(), FRAME_CAPTURE_BEGIN, VIDEO_EVENT, + i * 10, i); } event_subscriber_.GetRtcpEventsAndReset(&events); diff --git a/media/cast/test/end2end_unittest.cc b/media/cast/test/end2end_unittest.cc index 4b8f6fe..6ee722e 100644 --- a/media/cast/test/end2end_unittest.cc +++ b/media/cast/test/end2end_unittest.cc @@ -109,7 +109,7 @@ void VideoInitializationStatus(CastInitializationStatus status) { // This is wrapped in a struct because it needs to be put into a std::map. typedef struct { - int counter[kNumOfLoggingEvents]; + int counter[kNumOfLoggingEvents+1]; } LoggingEventCounts; // Constructs a map from each frame (RTP timestamp) to counts of each event @@ -638,6 +638,7 @@ class End2EndTest : public ::testing::Test { ++it) { cast_environment_sender_->Logging()->InsertPacketEvent(it->timestamp, it->type, + it->media_type, it->rtp_timestamp, it->frame_id, it->packet_id, @@ -1085,40 +1086,42 @@ TEST_F(End2EndTest, VideoLogging) { map_it != event_counter_for_frame.end(); ++map_it) { int total_event_count_for_frame = 0; - for (int i = 0; i < kNumOfLoggingEvents; ++i) { + for (int i = 0; i <= kNumOfLoggingEvents; ++i) { total_event_count_for_frame += map_it->second.counter[i]; } int expected_event_count_for_frame = 0; - EXPECT_EQ(1, map_it->second.counter[kVideoFrameCaptureBegin]); + EXPECT_EQ(1, map_it->second.counter[FRAME_CAPTURE_BEGIN]); expected_event_count_for_frame += - map_it->second.counter[kVideoFrameCaptureBegin]; + map_it->second.counter[FRAME_CAPTURE_BEGIN]; - EXPECT_EQ(1, map_it->second.counter[kVideoFrameEncoded]); + EXPECT_EQ(1, map_it->second.counter[FRAME_CAPTURE_END]); expected_event_count_for_frame += - map_it->second.counter[kVideoFrameEncoded]; + map_it->second.counter[FRAME_CAPTURE_END]; - EXPECT_EQ(1, map_it->second.counter[kVideoFrameCaptureEnd]); + EXPECT_EQ(1, map_it->second.counter[FRAME_ENCODED]); expected_event_count_for_frame += - map_it->second.counter[kVideoFrameCaptureEnd]; + map_it->second.counter[FRAME_ENCODED]; - EXPECT_EQ(1, map_it->second.counter[kVideoRenderDelay]); - expected_event_count_for_frame += map_it->second.counter[kVideoRenderDelay]; - - EXPECT_EQ(1, map_it->second.counter[kVideoFrameDecoded]); + EXPECT_EQ(1, map_it->second.counter[FRAME_DECODED]); expected_event_count_for_frame += - map_it->second.counter[kVideoFrameDecoded]; + map_it->second.counter[FRAME_DECODED]; + + EXPECT_EQ(1, map_it->second.counter[FRAME_PLAYOUT]); + expected_event_count_for_frame += map_it->second.counter[FRAME_PLAYOUT]; - // There is no guarantee that kVideoAckSent is loggeed exactly once per + + // There is no guarantee that FRAME_ACK_SENT is loggeed exactly once per // frame. - EXPECT_GT(map_it->second.counter[kVideoAckSent], 0); - expected_event_count_for_frame += map_it->second.counter[kVideoAckSent]; + EXPECT_GT(map_it->second.counter[FRAME_ACK_SENT], 0); + expected_event_count_for_frame += map_it->second.counter[FRAME_ACK_SENT]; - // There is no guarantee that kVideoAckReceived is loggeed exactly once per + // There is no guarantee that FRAME_ACK_RECEIVED is loggeed exactly once per // frame. - EXPECT_GT(map_it->second.counter[kVideoAckReceived], 0); - expected_event_count_for_frame += map_it->second.counter[kVideoAckReceived]; + EXPECT_GT(map_it->second.counter[FRAME_ACK_RECEIVED], 0); + expected_event_count_for_frame += + map_it->second.counter[FRAME_ACK_RECEIVED]; // Verify that there were no other events logged with respect to this // frame. @@ -1138,14 +1141,14 @@ TEST_F(End2EndTest, VideoLogging) { map_it != event_count_for_packet.end(); ++map_it) { int total_event_count_for_packet = 0; - for (int i = 0; i < kNumOfLoggingEvents; ++i) { + for (int i = 0; i <= kNumOfLoggingEvents; ++i) { total_event_count_for_packet += map_it->second.counter[i]; } int expected_event_count_for_packet = 0; - EXPECT_GT(map_it->second.counter[kVideoPacketReceived], 0); + EXPECT_GT(map_it->second.counter[PACKET_RECEIVED], 0); expected_event_count_for_packet += - map_it->second.counter[kVideoPacketReceived]; + map_it->second.counter[PACKET_RECEIVED]; // Verify that there were no other events logged with respect to this // packet. (i.e. Total event count = expected event count) @@ -1197,7 +1200,7 @@ TEST_F(End2EndTest, AudioLogging) { event_counter_for_frame.begin(); it != event_counter_for_frame.end(); ++it) { - encoded_count += it->second.counter[kAudioFrameEncoded]; + encoded_count += it->second.counter[FRAME_ENCODED]; } EXPECT_EQ(num_audio_frames_requested, encoded_count); @@ -1207,25 +1210,25 @@ TEST_F(End2EndTest, AudioLogging) { event_counter_for_frame.begin(); map_it != event_counter_for_frame.end(); ++map_it) { int total_event_count_for_frame = 0; - for (int j = 0; j < kNumOfLoggingEvents; ++j) + for (int j = 0; j <= kNumOfLoggingEvents; ++j) total_event_count_for_frame += map_it->second.counter[j]; int expected_event_count_for_frame = 0; - EXPECT_EQ(1, map_it->second.counter[kAudioFrameEncoded]); + EXPECT_EQ(1, map_it->second.counter[FRAME_ENCODED]); expected_event_count_for_frame += - map_it->second.counter[kAudioFrameEncoded]; + map_it->second.counter[FRAME_ENCODED]; - EXPECT_EQ(1, map_it->second.counter[kAudioPlayoutDelay]); + EXPECT_EQ(1, map_it->second.counter[FRAME_PLAYOUT]); expected_event_count_for_frame += - map_it->second.counter[kAudioPlayoutDelay]; + map_it->second.counter[FRAME_PLAYOUT]; - EXPECT_EQ(1, map_it->second.counter[kAudioFrameDecoded]); + EXPECT_EQ(1, map_it->second.counter[FRAME_DECODED]); expected_event_count_for_frame += - map_it->second.counter[kAudioFrameDecoded]; + map_it->second.counter[FRAME_DECODED]; - EXPECT_GT(map_it->second.counter[kAudioAckSent], 0); - expected_event_count_for_frame += map_it->second.counter[kAudioAckSent]; + EXPECT_GT(map_it->second.counter[FRAME_ACK_SENT], 0); + expected_event_count_for_frame += map_it->second.counter[FRAME_ACK_SENT]; // Verify that there were no other events logged with respect to this frame. // (i.e. Total event count = expected event count) diff --git a/media/cast/transport/pacing/paced_sender.cc b/media/cast/transport/pacing/paced_sender.cc index d4b5021..a401817 100644 --- a/media/cast/transport/pacing/paced_sender.cc +++ b/media/cast/transport/pacing/paced_sender.cc @@ -21,21 +21,9 @@ static const size_t kPacingMaxBurstsPerFrame = 3; static const size_t kTargetBurstSize = 10; static const size_t kMaxBurstSize = 20; -using media::cast::CastLoggingEvent; - -CastLoggingEvent GetLoggingEvent(bool is_audio, bool retransmit) { - if (retransmit) { - return is_audio ? media::cast::kAudioPacketRetransmitted - : media::cast::kVideoPacketRetransmitted; - } else { - return is_audio ? media::cast::kAudioPacketSentToNetwork - : media::cast::kVideoPacketSentToNetwork; - } -} - } // namespace - +// static PacketKey PacedPacketSender::MakePacketKey(const base::TimeTicks& ticks, uint32 ssrc, uint16 packet_id) { @@ -232,9 +220,11 @@ void PacedSender::LogPacketEvent(const Packet& packet, bool retransmit) { return; } - CastLoggingEvent event = GetLoggingEvent(is_audio, retransmit); - - logging_->InsertSinglePacketEvent(clock_->NowTicks(), event, packet); + CastLoggingEvent event = retransmit ? + PACKET_RETRANSMITTED : PACKET_SENT_TO_NETWORK; + EventMediaType media_type = is_audio ? AUDIO_EVENT : VIDEO_EVENT; + logging_->InsertSinglePacketEvent(clock_->NowTicks(), event, media_type, + packet); } } // namespace transport diff --git a/media/cast/transport/pacing/paced_sender_unittest.cc b/media/cast/transport/pacing/paced_sender_unittest.cc index 8c07889..ef9d89b 100644 --- a/media/cast/transport/pacing/paced_sender_unittest.cc +++ b/media/cast/transport/pacing/paced_sender_unittest.cc @@ -174,7 +174,7 @@ TEST_F(PacedSenderTest, BasicPace) { for (std::vector<PacketEvent>::iterator it = packet_events.begin(); it != packet_events.end(); ++it) { - if (it->type == kVideoPacketSentToNetwork) + if (it->type == PACKET_SENT_TO_NETWORK) sent_to_network_event_count++; else FAIL() << "Got unexpected event type " << CastLoggingToString(it->type); @@ -254,14 +254,17 @@ TEST_F(PacedSenderTest, PaceWithNack) { for (std::vector<PacketEvent>::iterator it = packet_events.begin(); it != packet_events.end(); ++it) { - if (it->type == kVideoPacketSentToNetwork) - video_network_event_count++; - else if (it->type == kVideoPacketRetransmitted) - video_retransmitted_event_count++; - else if (it->type == kAudioPacketSentToNetwork) - audio_network_event_count++; - else + if (it->type == PACKET_SENT_TO_NETWORK) { + if (it->media_type == VIDEO_EVENT) + video_network_event_count++; + else + audio_network_event_count++; + } else if (it->type == PACKET_RETRANSMITTED) { + if (it->media_type == VIDEO_EVENT) + video_retransmitted_event_count++; + } else { FAIL() << "Got unexpected event type " << CastLoggingToString(it->type); + } } EXPECT_EQ(expected_audio_network_event_count, audio_network_event_count); EXPECT_EQ(expected_video_network_event_count, video_network_event_count); diff --git a/media/cast/video_receiver/video_receiver.cc b/media/cast/video_receiver/video_receiver.cc index 677475f..4af2c53 100644 --- a/media/cast/video_receiver/video_receiver.cc +++ b/media/cast/video_receiver/video_receiver.cc @@ -29,8 +29,7 @@ VideoReceiver::VideoReceiver(scoped_refptr<CastEnvironment> cast_environment, transport::PacedPacketSender* const packet_sender) : RtpReceiver(cast_environment->Clock(), NULL, &video_config), cast_environment_(cast_environment), - event_subscriber_(kReceiverRtcpEventHistorySize, - ReceiverRtcpEventSubscriber::kVideoEventSubscriber), + event_subscriber_(kReceiverRtcpEventHistorySize, VIDEO_EVENT), codec_(video_config.codec), target_delay_delta_( base::TimeDelta::FromMilliseconds(video_config.rtp_max_delay_ms)), @@ -51,7 +50,8 @@ VideoReceiver::VideoReceiver(scoped_refptr<CastEnvironment> cast_environment, base::TimeDelta::FromMilliseconds(video_config.rtcp_interval), video_config.feedback_ssrc, video_config.incoming_ssrc, - video_config.rtcp_c_name), + video_config.rtcp_c_name, + false), time_offset_counter_(0), time_incoming_packet_updated_(false), incoming_rtp_timestamp_(0), @@ -125,9 +125,9 @@ void VideoReceiver::EmitRawVideoFrame( if (video_frame) { const base::TimeTicks now = cast_environment->Clock()->NowTicks(); cast_environment->Logging()->InsertFrameEvent( - now, kVideoFrameDecoded, rtp_timestamp, frame_id); + now, FRAME_DECODED, VIDEO_EVENT, rtp_timestamp, frame_id); cast_environment->Logging()->InsertFrameEventWithDelay( - now, kVideoRenderDelay, rtp_timestamp, frame_id, + now, FRAME_PLAYOUT, VIDEO_EVENT, rtp_timestamp, frame_id, playout_time - now); // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc TRACE_EVENT_INSTANT1( @@ -329,7 +329,8 @@ void VideoReceiver::OnReceivedPayloadData(const uint8* payload_data, rtp_header.rtp_timestamp; cast_environment_->Logging()->InsertPacketEvent( now, - kVideoPacketReceived, + PACKET_RECEIVED, + VIDEO_EVENT, rtp_header.rtp_timestamp, rtp_header.frame_id, rtp_header.packet_id, @@ -339,20 +340,14 @@ void VideoReceiver::OnReceivedPayloadData(const uint8* payload_data, bool duplicate = false; const bool complete = framer_.InsertPacket(payload_data, payload_size, rtp_header, &duplicate); - if (duplicate) { - cast_environment_->Logging()->InsertPacketEvent( - now, - kDuplicateVideoPacketReceived, - rtp_header.rtp_timestamp, - rtp_header.frame_id, - rtp_header.packet_id, - rtp_header.max_packet_id, - payload_size); - // Duplicate packets are ignored. + + // Duplicate packets are ignored. + if (duplicate) return; - } + + // Video frame not complete; wait for more packets. if (!complete) - return; // Video frame not complete; wait for more packets. + return; EmitAvailableEncodedFrames(); } @@ -366,7 +361,8 @@ void VideoReceiver::CastFeedback(const RtcpCastMessage& cast_message) { RtpTimestamp rtp_timestamp = frame_id_to_rtp_timestamp_[cast_message.ack_frame_id_ & 0xff]; cast_environment_->Logging()->InsertFrameEvent( - now, kVideoAckSent, rtp_timestamp, cast_message.ack_frame_id_); + now, FRAME_ACK_SENT, VIDEO_EVENT, + rtp_timestamp, cast_message.ack_frame_id_); ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events; event_subscriber_.GetRtcpEventsAndReset(&rtcp_events); diff --git a/media/cast/video_receiver/video_receiver.h b/media/cast/video_receiver/video_receiver.h index 4852794..697657e 100644 --- a/media/cast/video_receiver/video_receiver.h +++ b/media/cast/video_receiver/video_receiver.h @@ -166,7 +166,7 @@ class VideoReceiver : public RtpReceiver, // EmitAvailableEncodedFrames(). bool is_waiting_for_consecutive_frame_; - // This mapping allows us to log kVideoAckSent as a frame event. In addition + // This mapping allows us to log FRAME_ACK_SENT as a frame event. In addition // it allows the event to be transmitted via RTCP. RtpTimestamp frame_id_to_rtp_timestamp_[256]; diff --git a/media/cast/video_receiver/video_receiver_unittest.cc b/media/cast/video_receiver/video_receiver_unittest.cc index 9a1fde7..e9d8bbd 100644 --- a/media/cast/video_receiver/video_receiver_unittest.cc +++ b/media/cast/video_receiver/video_receiver_unittest.cc @@ -144,7 +144,7 @@ TEST_F(VideoReceiverTest, GetOnePacketEncodedFrame) { event_subscriber.GetFrameEventsAndReset(&frame_events); ASSERT_TRUE(!frame_events.empty()); - EXPECT_EQ(kVideoAckSent, frame_events.begin()->type); + EXPECT_EQ(FRAME_ACK_SENT, frame_events.begin()->type); EXPECT_EQ(rtp_header_.frame_id, frame_events.begin()->frame_id); EXPECT_EQ(rtp_header_.rtp_timestamp, frame_events.begin()->rtp_timestamp); diff --git a/media/cast/video_sender/external_video_encoder.cc b/media/cast/video_sender/external_video_encoder.cc index 9280e53..627b723 100644 --- a/media/cast/video_sender/external_video_encoder.cc +++ b/media/cast/video_sender/external_video_encoder.cc @@ -31,7 +31,8 @@ void LogFrameEncodedEvent( media::cast::RtpTimestamp rtp_timestamp, uint32 frame_id) { cast_environment->Logging()->InsertFrameEvent( - event_time, media::cast::kVideoFrameEncoded, rtp_timestamp, frame_id); + event_time, media::cast::FRAME_ENCODED, media::cast::VIDEO_EVENT, + rtp_timestamp, frame_id); } // Proxy this call to ExternalVideoEncoder on the cast main thread. diff --git a/media/cast/video_sender/video_sender.cc b/media/cast/video_sender/video_sender.cc index 07e34d5..8a787ef 100644 --- a/media/cast/video_sender/video_sender.cc +++ b/media/cast/video_sender/video_sender.cc @@ -106,7 +106,8 @@ VideoSender::VideoSender( base::TimeDelta::FromMilliseconds(video_config.rtcp_interval), video_config.rtp_config.ssrc, video_config.incoming_feedback_ssrc, - video_config.rtcp_c_name)); + video_config.rtcp_c_name, + false)); rtcp_->SetCastReceiverEventHistorySize(kReceiverRtcpEventHistorySize); // TODO(pwestin): pass cast_initialization_cb to |video_encoder_| @@ -144,10 +145,11 @@ void VideoSender::InsertRawVideoFrame( RtpTimestamp rtp_timestamp = GetVideoRtpTimestamp(capture_time); cast_environment_->Logging()->InsertFrameEvent( - capture_time, kVideoFrameCaptureBegin, rtp_timestamp, kFrameIdUnknown); + capture_time, FRAME_CAPTURE_BEGIN, VIDEO_EVENT, + rtp_timestamp, kFrameIdUnknown); cast_environment_->Logging()->InsertFrameEvent( cast_environment_->Clock()->NowTicks(), - kVideoFrameCaptureEnd, + FRAME_CAPTURE_END, VIDEO_EVENT, rtp_timestamp, kFrameIdUnknown); @@ -182,7 +184,7 @@ void VideoSender::SendEncodedVideoFrameMainThread( frames_in_encoder_--; uint32 frame_id = encoded_frame->frame_id; cast_environment_->Logging()->InsertEncodedFrameEvent( - last_send_time_, kVideoFrameEncoded, encoded_frame->rtp_timestamp, + last_send_time_, FRAME_ENCODED, VIDEO_EVENT, encoded_frame->rtp_timestamp, frame_id, static_cast<int>(encoded_frame->data.size()), encoded_frame->key_frame, current_requested_bitrate_); @@ -238,21 +240,16 @@ void VideoSender::SendRtcpReport() { for (RtcpEventMap::iterator it = rtcp_events.begin(); it != rtcp_events.end(); ++it) { CastLoggingEvent event_type = it->second.type; - if (event_type == kVideoFrameCaptureBegin || - event_type == kVideoFrameSentToEncoder || - event_type == kVideoFrameEncoded) { + if (event_type == FRAME_CAPTURE_BEGIN || + event_type == FRAME_ENCODED) { transport::RtcpSenderFrameLogMessage frame_message; frame_message.rtp_timestamp = it->first; switch (event_type) { - case kVideoFrameCaptureBegin: + case FRAME_CAPTURE_BEGIN: frame_message.frame_status = transport::kRtcpSenderFrameStatusDroppedByFlowControl; break; - case kVideoFrameSentToEncoder: - frame_message.frame_status = - transport::kRtcpSenderFrameStatusDroppedByEncoder; - break; - case kVideoFrameEncoded: + case FRAME_ENCODED: frame_message.frame_status = transport::kRtcpSenderFrameStatusSentToNetwork; break; @@ -433,7 +430,7 @@ void VideoSender::ReceivedAck(uint32 acked_frame_id) { RtpTimestamp rtp_timestamp = frame_id_to_rtp_timestamp_[acked_frame_id & 0xff]; cast_environment_->Logging()->InsertFrameEvent( - now, kVideoAckReceived, rtp_timestamp, acked_frame_id); + now, FRAME_ACK_RECEIVED, VIDEO_EVENT, rtp_timestamp, acked_frame_id); VLOG(2) << "ReceivedAck:" << static_cast<int>(acked_frame_id); active_session_ = true; diff --git a/media/cast/video_sender/video_sender_unittest.cc b/media/cast/video_sender/video_sender_unittest.cc index d8b07404..a3878a9 100644 --- a/media/cast/video_sender/video_sender_unittest.cc +++ b/media/cast/video_sender/video_sender_unittest.cc @@ -313,7 +313,8 @@ TEST_F(VideoSenderTest, LogAckReceivedEvent) { event_subscriber.GetFrameEventsAndReset(&frame_events); ASSERT_TRUE(!frame_events.empty()); - EXPECT_EQ(kVideoAckReceived, frame_events.rbegin()->type); + EXPECT_EQ(FRAME_ACK_RECEIVED, frame_events.rbegin()->type); + EXPECT_EQ(VIDEO_EVENT, frame_events.rbegin()->media_type); EXPECT_EQ(num_frames - 1u, frame_events.rbegin()->frame_id); cast_environment_->Logging()->RemoveRawEventSubscriber(&event_subscriber); |