OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2016 The WebRTC Project Authors. All rights reserved. | 2 * Copyright 2016 The WebRTC Project Authors. All rights reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 4 * Use of this source code is governed by a BSD-style license |
5 * that can be found in the LICENSE file in the root of the source | 5 * that can be found in the LICENSE file in the root of the source |
6 * tree. An additional intellectual property rights grant can be found | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
46 return audio ? "RTCCodec_OutboundAudio_" + rtc::ToString<>(payload_type) | 46 return audio ? "RTCCodec_OutboundAudio_" + rtc::ToString<>(payload_type) |
47 : "RTCCodec_OutboundVideo_" + rtc::ToString<>(payload_type); | 47 : "RTCCodec_OutboundVideo_" + rtc::ToString<>(payload_type); |
48 } | 48 } |
49 | 49 |
50 std::string RTCIceCandidatePairStatsIDFromConnectionInfo( | 50 std::string RTCIceCandidatePairStatsIDFromConnectionInfo( |
51 const cricket::ConnectionInfo& info) { | 51 const cricket::ConnectionInfo& info) { |
52 return "RTCIceCandidatePair_" + info.local_candidate.id() + "_" + | 52 return "RTCIceCandidatePair_" + info.local_candidate.id() + "_" + |
53 info.remote_candidate.id(); | 53 info.remote_candidate.id(); |
54 } | 54 } |
55 | 55 |
56 std::string RTCMediaStreamTrackStatsIDFromMediaStreamTrackInterface( | 56 std::string RTCMediaStreamTrackStatsIDFromTrackID( |
57 const MediaStreamTrackInterface& track) { | 57 const std::string& id, bool is_local) { |
58 return "RTCMediaStreamTrack_" + track.id(); | 58 return (is_local ? "RTCMediaStreamTrack_local_" + id |
| 59 : "RTCMediaStreamTrack_remote_" + id); |
59 } | 60 } |
60 | 61 |
61 std::string RTCTransportStatsIDFromTransportChannel( | 62 std::string RTCTransportStatsIDFromTransportChannel( |
62 const std::string& transport_name, int channel_component) { | 63 const std::string& transport_name, int channel_component) { |
63 return "RTCTransport_" + transport_name + "_" + | 64 return "RTCTransport_" + transport_name + "_" + |
64 rtc::ToString<>(channel_component); | 65 rtc::ToString<>(channel_component); |
65 } | 66 } |
66 | 67 |
67 std::string RTCTransportStatsIDFromBaseChannel( | 68 std::string RTCTransportStatsIDFromBaseChannel( |
68 const ProxyTransportMap& proxy_to_transport, | 69 const ProxyTransportMap& proxy_to_transport, |
(...skipping 251 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
320 | 321 |
321 std::unique_ptr<RTCMediaStreamStats> stream_stats( | 322 std::unique_ptr<RTCMediaStreamStats> stream_stats( |
322 new RTCMediaStreamStats( | 323 new RTCMediaStreamStats( |
323 (is_local ? "RTCMediaStream_local_" : "RTCMediaStream_remote_") + | 324 (is_local ? "RTCMediaStream_local_" : "RTCMediaStream_remote_") + |
324 stream->label(), timestamp_us)); | 325 stream->label(), timestamp_us)); |
325 stream_stats->stream_identifier = stream->label(); | 326 stream_stats->stream_identifier = stream->label(); |
326 stream_stats->track_ids = std::vector<std::string>(); | 327 stream_stats->track_ids = std::vector<std::string>(); |
327 // Audio Tracks | 328 // Audio Tracks |
328 for (const rtc::scoped_refptr<AudioTrackInterface>& audio_track : | 329 for (const rtc::scoped_refptr<AudioTrackInterface>& audio_track : |
329 stream->GetAudioTracks()) { | 330 stream->GetAudioTracks()) { |
330 std::string id = RTCMediaStreamTrackStatsIDFromMediaStreamTrackInterface( | 331 std::string id = RTCMediaStreamTrackStatsIDFromTrackID( |
331 *audio_track.get()); | 332 audio_track->id(), is_local); |
332 if (report->Get(id)) { | 333 if (report->Get(id)) { |
333 // Skip track, stats already exist for it. | 334 // Skip track, stats already exist for it. |
334 continue; | 335 continue; |
335 } | 336 } |
336 std::unique_ptr<RTCMediaStreamTrackStats> audio_track_stats( | 337 std::unique_ptr<RTCMediaStreamTrackStats> audio_track_stats( |
337 new RTCMediaStreamTrackStats(id, timestamp_us)); | 338 new RTCMediaStreamTrackStats(id, timestamp_us)); |
338 stream_stats->track_ids->push_back(audio_track_stats->id()); | 339 stream_stats->track_ids->push_back(audio_track_stats->id()); |
339 SetMediaStreamTrackStatsFromMediaStreamTrackInterface( | 340 SetMediaStreamTrackStatsFromMediaStreamTrackInterface( |
340 *audio_track.get(), | 341 *audio_track.get(), |
341 audio_track_stats.get()); | 342 audio_track_stats.get()); |
(...skipping 16 matching lines...) Expand all Loading... |
358 if (audio_processor_stats.echo_return_loss_enhancement != -100) { | 359 if (audio_processor_stats.echo_return_loss_enhancement != -100) { |
359 audio_track_stats->echo_return_loss_enhancement = static_cast<double>( | 360 audio_track_stats->echo_return_loss_enhancement = static_cast<double>( |
360 audio_processor_stats.echo_return_loss_enhancement); | 361 audio_processor_stats.echo_return_loss_enhancement); |
361 } | 362 } |
362 } | 363 } |
363 report->AddStats(std::move(audio_track_stats)); | 364 report->AddStats(std::move(audio_track_stats)); |
364 } | 365 } |
365 // Video Tracks | 366 // Video Tracks |
366 for (const rtc::scoped_refptr<VideoTrackInterface>& video_track : | 367 for (const rtc::scoped_refptr<VideoTrackInterface>& video_track : |
367 stream->GetVideoTracks()) { | 368 stream->GetVideoTracks()) { |
368 std::string id = RTCMediaStreamTrackStatsIDFromMediaStreamTrackInterface( | 369 std::string id = RTCMediaStreamTrackStatsIDFromTrackID( |
369 *video_track.get()); | 370 video_track->id(), is_local); |
370 if (report->Get(id)) { | 371 if (report->Get(id)) { |
371 // Skip track, stats already exist for it. | 372 // Skip track, stats already exist for it. |
372 continue; | 373 continue; |
373 } | 374 } |
374 std::unique_ptr<RTCMediaStreamTrackStats> video_track_stats( | 375 std::unique_ptr<RTCMediaStreamTrackStats> video_track_stats( |
375 new RTCMediaStreamTrackStats(id, timestamp_us)); | 376 new RTCMediaStreamTrackStats(id, timestamp_us)); |
376 stream_stats->track_ids->push_back(video_track_stats->id()); | 377 stream_stats->track_ids->push_back(video_track_stats->id()); |
377 SetMediaStreamTrackStatsFromMediaStreamTrackInterface( | 378 SetMediaStreamTrackStatsFromMediaStreamTrackInterface( |
378 *video_track.get(), | 379 *video_track.get(), |
379 video_track_stats.get()); | 380 video_track_stats.get()); |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
443 // are no more pending partial reports. | 444 // are no more pending partial reports. |
444 | 445 |
445 // "Now" using a system clock, relative to the UNIX epoch (Jan 1, 1970, | 446 // "Now" using a system clock, relative to the UNIX epoch (Jan 1, 1970, |
446 // UTC), in microseconds. The system clock could be modified and is not | 447 // UTC), in microseconds. The system clock could be modified and is not |
447 // necessarily monotonically increasing. | 448 // necessarily monotonically increasing. |
448 int64_t timestamp_us = rtc::TimeUTCMicros(); | 449 int64_t timestamp_us = rtc::TimeUTCMicros(); |
449 | 450 |
450 num_pending_partial_reports_ = 2; | 451 num_pending_partial_reports_ = 2; |
451 partial_report_timestamp_us_ = cache_now_us; | 452 partial_report_timestamp_us_ = cache_now_us; |
452 | 453 |
453 // Prepare |channel_names_| and |media_info_| for use in | 454 // Prepare |channel_name_pairs_| for use in |
454 // |ProducePartialResultsOnNetworkThread|. | 455 // |ProducePartialResultsOnNetworkThread|. |
455 channel_name_pairs_.reset(new ChannelNamePairs()); | 456 channel_name_pairs_.reset(new ChannelNamePairs()); |
456 if (pc_->session()->voice_channel()) { | 457 if (pc_->session()->voice_channel()) { |
457 channel_name_pairs_->voice = rtc::Optional<ChannelNamePair>( | 458 channel_name_pairs_->voice = rtc::Optional<ChannelNamePair>( |
458 ChannelNamePair(pc_->session()->voice_channel()->content_name(), | 459 ChannelNamePair(pc_->session()->voice_channel()->content_name(), |
459 pc_->session()->voice_channel()->transport_name())); | 460 pc_->session()->voice_channel()->transport_name())); |
460 } | 461 } |
461 if (pc_->session()->video_channel()) { | 462 if (pc_->session()->video_channel()) { |
462 channel_name_pairs_->video = rtc::Optional<ChannelNamePair>( | 463 channel_name_pairs_->video = rtc::Optional<ChannelNamePair>( |
463 ChannelNamePair(pc_->session()->video_channel()->content_name(), | 464 ChannelNamePair(pc_->session()->video_channel()->content_name(), |
464 pc_->session()->video_channel()->transport_name())); | 465 pc_->session()->video_channel()->transport_name())); |
465 } | 466 } |
466 if (pc_->session()->rtp_data_channel()) { | 467 if (pc_->session()->rtp_data_channel()) { |
467 channel_name_pairs_->data = | 468 channel_name_pairs_->data = |
468 rtc::Optional<ChannelNamePair>(ChannelNamePair( | 469 rtc::Optional<ChannelNamePair>(ChannelNamePair( |
469 pc_->session()->rtp_data_channel()->content_name(), | 470 pc_->session()->rtp_data_channel()->content_name(), |
470 pc_->session()->rtp_data_channel()->transport_name())); | 471 pc_->session()->rtp_data_channel()->transport_name())); |
471 } | 472 } |
472 if (pc_->session()->sctp_content_name()) { | 473 if (pc_->session()->sctp_content_name()) { |
473 channel_name_pairs_->data = rtc::Optional<ChannelNamePair>( | 474 channel_name_pairs_->data = rtc::Optional<ChannelNamePair>( |
474 ChannelNamePair(*pc_->session()->sctp_content_name(), | 475 ChannelNamePair(*pc_->session()->sctp_content_name(), |
475 *pc_->session()->sctp_transport_name())); | 476 *pc_->session()->sctp_transport_name())); |
476 } | 477 } |
477 media_info_.reset(PrepareMediaInfo_s().release()); | 478 // Prepare |track_media_info_map_| for use in |
| 479 // |ProducePartialResultsOnNetworkThread| and |
| 480 // |ProducePartialResultsOnSignalingThread|. |
| 481 track_media_info_map_.reset(PrepareTrackMediaInfoMap_s().release()); |
| 482 // Prepare |track_to_id_| for use in |ProducePartialResultsOnNetworkThread|. |
| 483 // This avoids a possible deadlock if |MediaStreamTrackInterface::id| is |
| 484 // implemented to invoke on the signaling thread. |
| 485 track_to_id_ = PrepareTrackToID_s(); |
478 | 486 |
479 invoker_.AsyncInvoke<void>(RTC_FROM_HERE, network_thread_, | 487 invoker_.AsyncInvoke<void>(RTC_FROM_HERE, network_thread_, |
480 rtc::Bind(&RTCStatsCollector::ProducePartialResultsOnNetworkThread, | 488 rtc::Bind(&RTCStatsCollector::ProducePartialResultsOnNetworkThread, |
481 rtc::scoped_refptr<RTCStatsCollector>(this), timestamp_us)); | 489 rtc::scoped_refptr<RTCStatsCollector>(this), timestamp_us)); |
482 ProducePartialResultsOnSignalingThread(timestamp_us); | 490 ProducePartialResultsOnSignalingThread(timestamp_us); |
483 } | 491 } |
484 } | 492 } |
485 | 493 |
486 void RTCStatsCollector::ClearCachedStatsReport() { | 494 void RTCStatsCollector::ClearCachedStatsReport() { |
487 RTC_DCHECK(signaling_thread_->IsCurrent()); | 495 RTC_DCHECK(signaling_thread_->IsCurrent()); |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
520 | 528 |
521 std::unique_ptr<SessionStats> session_stats = | 529 std::unique_ptr<SessionStats> session_stats = |
522 pc_->session()->GetStats(*channel_name_pairs_); | 530 pc_->session()->GetStats(*channel_name_pairs_); |
523 if (session_stats) { | 531 if (session_stats) { |
524 std::map<std::string, CertificateStatsPair> transport_cert_stats = | 532 std::map<std::string, CertificateStatsPair> transport_cert_stats = |
525 PrepareTransportCertificateStats_n(*session_stats); | 533 PrepareTransportCertificateStats_n(*session_stats); |
526 | 534 |
527 ProduceCertificateStats_n( | 535 ProduceCertificateStats_n( |
528 timestamp_us, transport_cert_stats, report.get()); | 536 timestamp_us, transport_cert_stats, report.get()); |
529 ProduceCodecStats_n( | 537 ProduceCodecStats_n( |
530 timestamp_us, *media_info_, report.get()); | 538 timestamp_us, *track_media_info_map_, report.get()); |
531 ProduceIceCandidateAndPairStats_n( | 539 ProduceIceCandidateAndPairStats_n( |
532 timestamp_us, *session_stats, report.get()); | 540 timestamp_us, *session_stats, report.get()); |
533 ProduceRTPStreamStats_n( | 541 ProduceRTPStreamStats_n( |
534 timestamp_us, *session_stats, *media_info_, report.get()); | 542 timestamp_us, *session_stats, *track_media_info_map_, report.get()); |
535 ProduceTransportStats_n( | 543 ProduceTransportStats_n( |
536 timestamp_us, *session_stats, transport_cert_stats, report.get()); | 544 timestamp_us, *session_stats, transport_cert_stats, report.get()); |
537 } | 545 } |
538 | 546 |
539 AddPartialResults(report); | 547 AddPartialResults(report); |
540 } | 548 } |
541 | 549 |
542 void RTCStatsCollector::AddPartialResults( | 550 void RTCStatsCollector::AddPartialResults( |
543 const rtc::scoped_refptr<RTCStatsReport>& partial_report) { | 551 const rtc::scoped_refptr<RTCStatsReport>& partial_report) { |
544 if (!signaling_thread_->IsCurrent()) { | 552 if (!signaling_thread_->IsCurrent()) { |
(...skipping 12 matching lines...) Expand all Loading... |
557 RTC_DCHECK_GT(num_pending_partial_reports_, 0); | 565 RTC_DCHECK_GT(num_pending_partial_reports_, 0); |
558 if (!partial_report_) | 566 if (!partial_report_) |
559 partial_report_ = partial_report; | 567 partial_report_ = partial_report; |
560 else | 568 else |
561 partial_report_->TakeMembersFrom(partial_report); | 569 partial_report_->TakeMembersFrom(partial_report); |
562 --num_pending_partial_reports_; | 570 --num_pending_partial_reports_; |
563 if (!num_pending_partial_reports_) { | 571 if (!num_pending_partial_reports_) { |
564 cache_timestamp_us_ = partial_report_timestamp_us_; | 572 cache_timestamp_us_ = partial_report_timestamp_us_; |
565 cached_report_ = partial_report_; | 573 cached_report_ = partial_report_; |
566 partial_report_ = nullptr; | 574 partial_report_ = nullptr; |
| 575 channel_name_pairs_.reset(); |
| 576 track_media_info_map_.reset(); |
| 577 track_to_id_.clear(); |
567 DeliverCachedReport(); | 578 DeliverCachedReport(); |
568 } | 579 } |
569 } | 580 } |
570 | 581 |
571 void RTCStatsCollector::DeliverCachedReport() { | 582 void RTCStatsCollector::DeliverCachedReport() { |
572 RTC_DCHECK(signaling_thread_->IsCurrent()); | 583 RTC_DCHECK(signaling_thread_->IsCurrent()); |
573 RTC_DCHECK(!callbacks_.empty()); | 584 RTC_DCHECK(!callbacks_.empty()); |
574 RTC_DCHECK(cached_report_); | 585 RTC_DCHECK(cached_report_); |
575 for (const rtc::scoped_refptr<RTCStatsCollectorCallback>& callback : | 586 for (const rtc::scoped_refptr<RTCStatsCollectorCallback>& callback : |
576 callbacks_) { | 587 callbacks_) { |
(...skipping 13 matching lines...) Expand all Loading... |
590 timestamp_us, *transport_cert_stats_pair.second.local.get(), report); | 601 timestamp_us, *transport_cert_stats_pair.second.local.get(), report); |
591 } | 602 } |
592 if (transport_cert_stats_pair.second.remote) { | 603 if (transport_cert_stats_pair.second.remote) { |
593 ProduceCertificateStatsFromSSLCertificateStats( | 604 ProduceCertificateStatsFromSSLCertificateStats( |
594 timestamp_us, *transport_cert_stats_pair.second.remote.get(), report); | 605 timestamp_us, *transport_cert_stats_pair.second.remote.get(), report); |
595 } | 606 } |
596 } | 607 } |
597 } | 608 } |
598 | 609 |
599 void RTCStatsCollector::ProduceCodecStats_n( | 610 void RTCStatsCollector::ProduceCodecStats_n( |
600 int64_t timestamp_us, const MediaInfo& media_info, | 611 int64_t timestamp_us, const TrackMediaInfoMap& track_media_info_map, |
601 RTCStatsReport* report) const { | 612 RTCStatsReport* report) const { |
602 RTC_DCHECK(network_thread_->IsCurrent()); | 613 RTC_DCHECK(network_thread_->IsCurrent()); |
603 // Audio | 614 // Audio |
604 if (media_info.voice) { | 615 if (track_media_info_map.voice_media_info()) { |
605 // Inbound | 616 // Inbound |
606 for (const auto& pair : media_info.voice->receive_codecs) { | 617 for (const auto& pair : |
| 618 track_media_info_map.voice_media_info()->receive_codecs) { |
607 report->AddStats(CodecStatsFromRtpCodecParameters( | 619 report->AddStats(CodecStatsFromRtpCodecParameters( |
608 timestamp_us, true, true, pair.second)); | 620 timestamp_us, true, true, pair.second)); |
609 } | 621 } |
610 // Outbound | 622 // Outbound |
611 for (const auto& pair : media_info.voice->send_codecs) { | 623 for (const auto& pair : |
| 624 track_media_info_map.voice_media_info()->send_codecs) { |
612 report->AddStats(CodecStatsFromRtpCodecParameters( | 625 report->AddStats(CodecStatsFromRtpCodecParameters( |
613 timestamp_us, false, true, pair.second)); | 626 timestamp_us, false, true, pair.second)); |
614 } | 627 } |
615 } | 628 } |
616 // Video | 629 // Video |
617 if (media_info.video) { | 630 if (track_media_info_map.video_media_info()) { |
618 // Inbound | 631 // Inbound |
619 for (const auto& pair : media_info.video->receive_codecs) { | 632 for (const auto& pair : |
| 633 track_media_info_map.video_media_info()->receive_codecs) { |
620 report->AddStats(CodecStatsFromRtpCodecParameters( | 634 report->AddStats(CodecStatsFromRtpCodecParameters( |
621 timestamp_us, true, false, pair.second)); | 635 timestamp_us, true, false, pair.second)); |
622 } | 636 } |
623 // Outbound | 637 // Outbound |
624 for (const auto& pair : media_info.video->send_codecs) { | 638 for (const auto& pair : |
| 639 track_media_info_map.video_media_info()->send_codecs) { |
625 report->AddStats(CodecStatsFromRtpCodecParameters( | 640 report->AddStats(CodecStatsFromRtpCodecParameters( |
626 timestamp_us, false, false, pair.second)); | 641 timestamp_us, false, false, pair.second)); |
627 } | 642 } |
628 } | 643 } |
629 } | 644 } |
630 | 645 |
631 void RTCStatsCollector::ProduceDataChannelStats_s( | 646 void RTCStatsCollector::ProduceDataChannelStats_s( |
632 int64_t timestamp_us, RTCStatsReport* report) const { | 647 int64_t timestamp_us, RTCStatsReport* report) const { |
633 RTC_DCHECK(signaling_thread_->IsCurrent()); | 648 RTC_DCHECK(signaling_thread_->IsCurrent()); |
634 for (const rtc::scoped_refptr<DataChannel>& data_channel : | 649 for (const rtc::scoped_refptr<DataChannel>& data_channel : |
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
724 RTC_DCHECK(signaling_thread_->IsCurrent()); | 739 RTC_DCHECK(signaling_thread_->IsCurrent()); |
725 std::unique_ptr<RTCPeerConnectionStats> stats( | 740 std::unique_ptr<RTCPeerConnectionStats> stats( |
726 new RTCPeerConnectionStats("RTCPeerConnection", timestamp_us)); | 741 new RTCPeerConnectionStats("RTCPeerConnection", timestamp_us)); |
727 stats->data_channels_opened = internal_record_.data_channels_opened; | 742 stats->data_channels_opened = internal_record_.data_channels_opened; |
728 stats->data_channels_closed = internal_record_.data_channels_closed; | 743 stats->data_channels_closed = internal_record_.data_channels_closed; |
729 report->AddStats(std::move(stats)); | 744 report->AddStats(std::move(stats)); |
730 } | 745 } |
731 | 746 |
732 void RTCStatsCollector::ProduceRTPStreamStats_n( | 747 void RTCStatsCollector::ProduceRTPStreamStats_n( |
733 int64_t timestamp_us, const SessionStats& session_stats, | 748 int64_t timestamp_us, const SessionStats& session_stats, |
734 const MediaInfo& media_info, RTCStatsReport* report) const { | 749 const TrackMediaInfoMap& track_media_info_map, |
| 750 RTCStatsReport* report) const { |
735 RTC_DCHECK(network_thread_->IsCurrent()); | 751 RTC_DCHECK(network_thread_->IsCurrent()); |
736 | 752 |
737 // Audio | 753 // Audio |
738 if (media_info.voice) { | 754 if (track_media_info_map.voice_media_info()) { |
739 std::string transport_id = RTCTransportStatsIDFromBaseChannel( | 755 std::string transport_id = RTCTransportStatsIDFromBaseChannel( |
740 session_stats.proxy_to_transport, *pc_->session()->voice_channel()); | 756 session_stats.proxy_to_transport, *pc_->session()->voice_channel()); |
741 RTC_DCHECK(!transport_id.empty()); | 757 RTC_DCHECK(!transport_id.empty()); |
742 // Inbound | 758 // Inbound |
743 for (const cricket::VoiceReceiverInfo& voice_receiver_info : | 759 for (const cricket::VoiceReceiverInfo& voice_receiver_info : |
744 media_info.voice->receivers) { | 760 track_media_info_map.voice_media_info()->receivers) { |
745 // TODO(nisse): SSRC == 0 currently means none. Delete check when that | 761 // TODO(nisse): SSRC == 0 currently means none. Delete check when that |
746 // is fixed. | 762 // is fixed. |
747 if (voice_receiver_info.ssrc() == 0) | 763 if (voice_receiver_info.ssrc() == 0) |
748 continue; | 764 continue; |
749 std::unique_ptr<RTCInboundRTPStreamStats> inbound_audio( | 765 std::unique_ptr<RTCInboundRTPStreamStats> inbound_audio( |
750 new RTCInboundRTPStreamStats( | 766 new RTCInboundRTPStreamStats( |
751 RTCInboundRTPStreamStatsIDFromSSRC( | 767 RTCInboundRTPStreamStatsIDFromSSRC( |
752 true, voice_receiver_info.ssrc()), | 768 true, voice_receiver_info.ssrc()), |
753 timestamp_us)); | 769 timestamp_us)); |
754 SetInboundRTPStreamStatsFromVoiceReceiverInfo( | 770 SetInboundRTPStreamStatsFromVoiceReceiverInfo( |
755 voice_receiver_info, inbound_audio.get()); | 771 voice_receiver_info, inbound_audio.get()); |
| 772 rtc::scoped_refptr<AudioTrackInterface> audio_track = |
| 773 track_media_info_map_->GetAudioTrack(voice_receiver_info); |
| 774 if (audio_track) { |
| 775 RTC_DCHECK(track_to_id_.find(audio_track.get()) != track_to_id_.end()); |
| 776 inbound_audio->media_track_id = |
| 777 RTCMediaStreamTrackStatsIDFromTrackID( |
| 778 track_to_id_.find(audio_track.get())->second, false); |
| 779 } |
756 inbound_audio->transport_id = transport_id; | 780 inbound_audio->transport_id = transport_id; |
757 if (voice_receiver_info.codec_payload_type) { | 781 if (voice_receiver_info.codec_payload_type) { |
758 inbound_audio->codec_id = | 782 inbound_audio->codec_id = |
759 RTCCodecStatsIDFromDirectionMediaAndPayload( | 783 RTCCodecStatsIDFromDirectionMediaAndPayload( |
760 true, true, *voice_receiver_info.codec_payload_type); | 784 true, true, *voice_receiver_info.codec_payload_type); |
761 } | 785 } |
762 report->AddStats(std::move(inbound_audio)); | 786 report->AddStats(std::move(inbound_audio)); |
763 } | 787 } |
764 // Outbound | 788 // Outbound |
765 for (const cricket::VoiceSenderInfo& voice_sender_info : | 789 for (const cricket::VoiceSenderInfo& voice_sender_info : |
766 media_info.voice->senders) { | 790 track_media_info_map.voice_media_info()->senders) { |
767 // TODO(nisse): SSRC == 0 currently means none. Delete check when that | 791 // TODO(nisse): SSRC == 0 currently means none. Delete check when that |
768 // is fixed. | 792 // is fixed. |
769 if (voice_sender_info.ssrc() == 0) | 793 if (voice_sender_info.ssrc() == 0) |
770 continue; | 794 continue; |
771 std::unique_ptr<RTCOutboundRTPStreamStats> outbound_audio( | 795 std::unique_ptr<RTCOutboundRTPStreamStats> outbound_audio( |
772 new RTCOutboundRTPStreamStats( | 796 new RTCOutboundRTPStreamStats( |
773 RTCOutboundRTPStreamStatsIDFromSSRC( | 797 RTCOutboundRTPStreamStatsIDFromSSRC( |
774 true, voice_sender_info.ssrc()), | 798 true, voice_sender_info.ssrc()), |
775 timestamp_us)); | 799 timestamp_us)); |
776 SetOutboundRTPStreamStatsFromVoiceSenderInfo( | 800 SetOutboundRTPStreamStatsFromVoiceSenderInfo( |
777 voice_sender_info, outbound_audio.get()); | 801 voice_sender_info, outbound_audio.get()); |
| 802 rtc::scoped_refptr<AudioTrackInterface> audio_track = |
| 803 track_media_info_map_->GetAudioTrack(voice_sender_info); |
| 804 if (audio_track) { |
| 805 RTC_DCHECK(track_to_id_.find(audio_track.get()) != track_to_id_.end()); |
| 806 outbound_audio->media_track_id = |
| 807 RTCMediaStreamTrackStatsIDFromTrackID( |
| 808 track_to_id_.find(audio_track.get())->second, true); |
| 809 } |
778 outbound_audio->transport_id = transport_id; | 810 outbound_audio->transport_id = transport_id; |
779 if (voice_sender_info.codec_payload_type) { | 811 if (voice_sender_info.codec_payload_type) { |
780 outbound_audio->codec_id = | 812 outbound_audio->codec_id = |
781 RTCCodecStatsIDFromDirectionMediaAndPayload( | 813 RTCCodecStatsIDFromDirectionMediaAndPayload( |
782 false, true, *voice_sender_info.codec_payload_type); | 814 false, true, *voice_sender_info.codec_payload_type); |
783 } | 815 } |
784 report->AddStats(std::move(outbound_audio)); | 816 report->AddStats(std::move(outbound_audio)); |
785 } | 817 } |
786 } | 818 } |
787 // Video | 819 // Video |
788 if (media_info.video) { | 820 if (track_media_info_map.video_media_info()) { |
789 std::string transport_id = RTCTransportStatsIDFromBaseChannel( | 821 std::string transport_id = RTCTransportStatsIDFromBaseChannel( |
790 session_stats.proxy_to_transport, *pc_->session()->video_channel()); | 822 session_stats.proxy_to_transport, *pc_->session()->video_channel()); |
791 RTC_DCHECK(!transport_id.empty()); | 823 RTC_DCHECK(!transport_id.empty()); |
792 // Inbound | 824 // Inbound |
793 for (const cricket::VideoReceiverInfo& video_receiver_info : | 825 for (const cricket::VideoReceiverInfo& video_receiver_info : |
794 media_info.video->receivers) { | 826 track_media_info_map.video_media_info()->receivers) { |
795 // TODO(nisse): SSRC == 0 currently means none. Delete check when that | 827 // TODO(nisse): SSRC == 0 currently means none. Delete check when that |
796 // is fixed. | 828 // is fixed. |
797 if (video_receiver_info.ssrc() == 0) | 829 if (video_receiver_info.ssrc() == 0) |
798 continue; | 830 continue; |
799 std::unique_ptr<RTCInboundRTPStreamStats> inbound_video( | 831 std::unique_ptr<RTCInboundRTPStreamStats> inbound_video( |
800 new RTCInboundRTPStreamStats( | 832 new RTCInboundRTPStreamStats( |
801 RTCInboundRTPStreamStatsIDFromSSRC( | 833 RTCInboundRTPStreamStatsIDFromSSRC( |
802 false, video_receiver_info.ssrc()), | 834 false, video_receiver_info.ssrc()), |
803 timestamp_us)); | 835 timestamp_us)); |
804 SetInboundRTPStreamStatsFromVideoReceiverInfo( | 836 SetInboundRTPStreamStatsFromVideoReceiverInfo( |
805 video_receiver_info, inbound_video.get()); | 837 video_receiver_info, inbound_video.get()); |
| 838 rtc::scoped_refptr<VideoTrackInterface> video_track = |
| 839 track_media_info_map_->GetVideoTrack(video_receiver_info); |
| 840 if (video_track) { |
| 841 RTC_DCHECK(track_to_id_.find(video_track.get()) != track_to_id_.end()); |
| 842 inbound_video->media_track_id = |
| 843 RTCMediaStreamTrackStatsIDFromTrackID( |
| 844 track_to_id_.find(video_track.get())->second, false); |
| 845 } |
806 inbound_video->transport_id = transport_id; | 846 inbound_video->transport_id = transport_id; |
807 if (video_receiver_info.codec_payload_type) { | 847 if (video_receiver_info.codec_payload_type) { |
808 inbound_video->codec_id = | 848 inbound_video->codec_id = |
809 RTCCodecStatsIDFromDirectionMediaAndPayload( | 849 RTCCodecStatsIDFromDirectionMediaAndPayload( |
810 true, false, *video_receiver_info.codec_payload_type); | 850 true, false, *video_receiver_info.codec_payload_type); |
811 } | 851 } |
812 report->AddStats(std::move(inbound_video)); | 852 report->AddStats(std::move(inbound_video)); |
813 } | 853 } |
814 // Outbound | 854 // Outbound |
815 for (const cricket::VideoSenderInfo& video_sender_info : | 855 for (const cricket::VideoSenderInfo& video_sender_info : |
816 media_info.video->senders) { | 856 track_media_info_map.video_media_info()->senders) { |
817 // TODO(nisse): SSRC == 0 currently means none. Delete check when that | 857 // TODO(nisse): SSRC == 0 currently means none. Delete check when that |
818 // is fixed. | 858 // is fixed. |
819 if (video_sender_info.ssrc() == 0) | 859 if (video_sender_info.ssrc() == 0) |
820 continue; | 860 continue; |
821 std::unique_ptr<RTCOutboundRTPStreamStats> outbound_video( | 861 std::unique_ptr<RTCOutboundRTPStreamStats> outbound_video( |
822 new RTCOutboundRTPStreamStats( | 862 new RTCOutboundRTPStreamStats( |
823 RTCOutboundRTPStreamStatsIDFromSSRC( | 863 RTCOutboundRTPStreamStatsIDFromSSRC( |
824 false, video_sender_info.ssrc()), | 864 false, video_sender_info.ssrc()), |
825 timestamp_us)); | 865 timestamp_us)); |
826 SetOutboundRTPStreamStatsFromVideoSenderInfo( | 866 SetOutboundRTPStreamStatsFromVideoSenderInfo( |
827 video_sender_info, outbound_video.get()); | 867 video_sender_info, outbound_video.get()); |
| 868 rtc::scoped_refptr<VideoTrackInterface> video_track = |
| 869 track_media_info_map_->GetVideoTrack(video_sender_info); |
| 870 if (video_track) { |
| 871 RTC_DCHECK(track_to_id_.find(video_track.get()) != track_to_id_.end()); |
| 872 outbound_video->media_track_id = |
| 873 RTCMediaStreamTrackStatsIDFromTrackID( |
| 874 track_to_id_.find(video_track.get())->second, true); |
| 875 } |
828 outbound_video->transport_id = transport_id; | 876 outbound_video->transport_id = transport_id; |
829 if (video_sender_info.codec_payload_type) { | 877 if (video_sender_info.codec_payload_type) { |
830 outbound_video->codec_id = | 878 outbound_video->codec_id = |
831 RTCCodecStatsIDFromDirectionMediaAndPayload( | 879 RTCCodecStatsIDFromDirectionMediaAndPayload( |
832 false, false, *video_sender_info.codec_payload_type); | 880 false, false, *video_sender_info.codec_payload_type); |
833 } | 881 } |
834 report->AddStats(std::move(outbound_video)); | 882 report->AddStats(std::move(outbound_video)); |
835 } | 883 } |
836 } | 884 } |
837 } | 885 } |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
921 if (remote_certificate) { | 969 if (remote_certificate) { |
922 certificate_stats_pair.remote = remote_certificate->GetStats(); | 970 certificate_stats_pair.remote = remote_certificate->GetStats(); |
923 } | 971 } |
924 transport_cert_stats.insert( | 972 transport_cert_stats.insert( |
925 std::make_pair(transport_stats.second.transport_name, | 973 std::make_pair(transport_stats.second.transport_name, |
926 std::move(certificate_stats_pair))); | 974 std::move(certificate_stats_pair))); |
927 } | 975 } |
928 return transport_cert_stats; | 976 return transport_cert_stats; |
929 } | 977 } |
930 | 978 |
931 std::unique_ptr<RTCStatsCollector::MediaInfo> | 979 std::unique_ptr<TrackMediaInfoMap> |
932 RTCStatsCollector::PrepareMediaInfo_s() const { | 980 RTCStatsCollector::PrepareTrackMediaInfoMap_s() const { |
933 RTC_DCHECK(signaling_thread_->IsCurrent()); | 981 RTC_DCHECK(signaling_thread_->IsCurrent()); |
934 std::unique_ptr<MediaInfo> media_info(new MediaInfo()); | 982 std::unique_ptr<cricket::VoiceMediaInfo> voice_media_info; |
935 if (pc_->session()->voice_channel()) { | 983 if (pc_->session()->voice_channel()) { |
936 cricket::VoiceMediaInfo voice_media_info; | 984 voice_media_info.reset(new cricket::VoiceMediaInfo()); |
937 if (pc_->session()->voice_channel()->GetStats(&voice_media_info)) { | 985 if (!pc_->session()->voice_channel()->GetStats(voice_media_info.get())) { |
938 media_info->voice = rtc::Optional<cricket::VoiceMediaInfo>( | 986 voice_media_info.reset(); |
939 std::move(voice_media_info)); | |
940 } | 987 } |
941 } | 988 } |
| 989 std::unique_ptr<cricket::VideoMediaInfo> video_media_info; |
942 if (pc_->session()->video_channel()) { | 990 if (pc_->session()->video_channel()) { |
943 cricket::VideoMediaInfo video_media_info; | 991 video_media_info.reset(new cricket::VideoMediaInfo()); |
944 if (pc_->session()->video_channel()->GetStats(&video_media_info)) { | 992 if (!pc_->session()->video_channel()->GetStats(video_media_info.get())) { |
945 media_info->video = rtc::Optional<cricket::VideoMediaInfo>( | 993 video_media_info.reset(); |
946 std::move(video_media_info)); | |
947 } | 994 } |
948 } | 995 } |
949 return media_info; | 996 std::unique_ptr<TrackMediaInfoMap> track_media_info_map( |
| 997 new TrackMediaInfoMap(std::move(voice_media_info), |
| 998 std::move(video_media_info), |
| 999 pc_->GetSenders(), |
| 1000 pc_->GetReceivers())); |
| 1001 return track_media_info_map; |
| 1002 } |
| 1003 |
| 1004 std::map<MediaStreamTrackInterface*, std::string> |
| 1005 RTCStatsCollector::PrepareTrackToID_s() const { |
| 1006 RTC_DCHECK(signaling_thread_->IsCurrent()); |
| 1007 std::map<MediaStreamTrackInterface*, std::string> track_to_id; |
| 1008 StreamCollectionInterface* local_and_remote_streams[] = |
| 1009 { pc_->local_streams().get(), pc_->remote_streams().get() }; |
| 1010 for (auto& streams : local_and_remote_streams) { |
| 1011 if (streams) { |
| 1012 for (size_t i = 0; i < streams->count(); ++i) { |
| 1013 MediaStreamInterface* stream = streams->at(i); |
| 1014 for (const rtc::scoped_refptr<AudioTrackInterface>& audio_track : |
| 1015 stream->GetAudioTracks()) { |
| 1016 track_to_id[audio_track.get()] = audio_track->id(); |
| 1017 } |
| 1018 for (const rtc::scoped_refptr<VideoTrackInterface>& video_track : |
| 1019 stream->GetVideoTracks()) { |
| 1020 track_to_id[video_track.get()] = video_track->id(); |
| 1021 } |
| 1022 } |
| 1023 } |
| 1024 } |
| 1025 return track_to_id; |
950 } | 1026 } |
951 | 1027 |
952 void RTCStatsCollector::OnDataChannelCreated(DataChannel* channel) { | 1028 void RTCStatsCollector::OnDataChannelCreated(DataChannel* channel) { |
953 channel->SignalOpened.connect(this, &RTCStatsCollector::OnDataChannelOpened); | 1029 channel->SignalOpened.connect(this, &RTCStatsCollector::OnDataChannelOpened); |
954 channel->SignalClosed.connect(this, &RTCStatsCollector::OnDataChannelClosed); | 1030 channel->SignalClosed.connect(this, &RTCStatsCollector::OnDataChannelClosed); |
955 } | 1031 } |
956 | 1032 |
957 void RTCStatsCollector::OnDataChannelOpened(DataChannel* channel) { | 1033 void RTCStatsCollector::OnDataChannelOpened(DataChannel* channel) { |
958 RTC_DCHECK(signaling_thread_->IsCurrent()); | 1034 RTC_DCHECK(signaling_thread_->IsCurrent()); |
959 bool result = internal_record_.opened_data_channels.insert( | 1035 bool result = internal_record_.opened_data_channels.insert( |
(...skipping 17 matching lines...) Expand all Loading... |
977 const std::string& type) { | 1053 const std::string& type) { |
978 return CandidateTypeToRTCIceCandidateType(type); | 1054 return CandidateTypeToRTCIceCandidateType(type); |
979 } | 1055 } |
980 | 1056 |
981 const char* DataStateToRTCDataChannelStateForTesting( | 1057 const char* DataStateToRTCDataChannelStateForTesting( |
982 DataChannelInterface::DataState state) { | 1058 DataChannelInterface::DataState state) { |
983 return DataStateToRTCDataChannelState(state); | 1059 return DataStateToRTCDataChannelState(state); |
984 } | 1060 } |
985 | 1061 |
986 } // namespace webrtc | 1062 } // namespace webrtc |
OLD | NEW |