default_video_quality_analyzer.h

/*

 *  Copyright (c) 2019 The WebRTC project authors. All Rights Reserved.

 *  Use of this source code is governed by a BSD-style license

 *  that can be found in the LICENSE file in the root of the source

 *  tree. An additional intellectual property rights grant can be found

 *  in the file PATENTS.  All contributing project authors may

 *  be found in the AUTHORS file in the root of the source tree.

*/

#ifndef TEST_PC_E2E_ANALYZER_VIDEO_DEFAULT_VIDEO_QUALITY_ANALYZER_H_

#define TEST_PC_E2E_ANALYZER_VIDEO_DEFAULT_VIDEO_QUALITY_ANALYZER_H_

#include <atomic>

#include <cstdint>

#include <deque>

#include <map>

#include <memory>

#include <set>

#include <string>

#include <unordered_map>

#include <vector>

#include "api/array_view.h"

#include "api/test/metrics/metrics_logger.h"

#include "api/test/video_quality_analyzer_interface.h"

#include "api/units/data_size.h"

#include "api/units/timestamp.h"

#include "api/video/encoded_image.h"

#include "api/video/video_frame.h"

#include "rtc_base/synchronization/mutex.h"

#include "rtc_base/thread_annotations.h"

#include "system_wrappers/include/clock.h"

#include "test/pc/e2e/analyzer/video/default_video_quality_analyzer_cpu_measurer.h"

#include "test/pc/e2e/analyzer/video/default_video_quality_analyzer_frame_in_flight.h"

#include "test/pc/e2e/analyzer/video/default_video_quality_analyzer_frames_comparator.h"

#include "test/pc/e2e/analyzer/video/default_video_quality_analyzer_internal_shared_objects.h"

#include "test/pc/e2e/analyzer/video/default_video_quality_analyzer_shared_objects.h"

#include "test/pc/e2e/analyzer/video/default_video_quality_analyzer_stream_state.h"

#include "test/pc/e2e/analyzer/video/dvqa/frames_storage.h"

#include "test/pc/e2e/analyzer/video/names_collection.h"

namespace webrtc {

class DefaultVideoQualityAnalyzer : public VideoQualityAnalyzerInterface {

 public:

  DefaultVideoQualityAnalyzer(webrtc::Clock* clock,

                              test::MetricsLogger* metrics_logger,

                              DefaultVideoQualityAnalyzerOptions options = {});

  ~DefaultVideoQualityAnalyzer() override;

  void Start(std::string test_case_name,

             rtc::ArrayView<const std::string> peer_names,

             int max_threads_count) override;

  uint16_t OnFrameCaptured(absl::string_view peer_name,

                           const std::string& stream_label,

                           const VideoFrame& frame) override;

  void OnFramePreEncode(absl::string_view peer_name,

                        const VideoFrame& frame) override;

  void OnFrameEncoded(absl::string_view peer_name,

                      uint16_t frame_id,

                      const EncodedImage& encoded_image,

                      const EncoderStats& stats,

                      bool discarded) override;

  void OnFrameDropped(absl::string_view peer_name,

                      EncodedImageCallback::DropReason reason) override;

  void OnFramePreDecode(absl::string_view peer_name,

                        uint16_t frame_id,

                        const EncodedImage& input_image) override;

  void OnFrameDecoded(absl::string_view peer_name,

                      const VideoFrame& frame,

                      const DecoderStats& stats) override;

  void OnFrameRendered(absl::string_view peer_name,

                       const VideoFrame& frame) override;

  void OnEncoderError(absl::string_view peer_name,

                      const VideoFrame& frame,

                      int32_t error_code) override;

  void OnDecoderError(absl::string_view peer_name,

                      uint16_t frame_id,

                      int32_t error_code,

                      const DecoderStats& stats) override;

  void RegisterParticipantInCall(absl::string_view peer_name) override;

  void UnregisterParticipantInCall(absl::string_view peer_name) override;

  void OnPauseAllStreamsFrom(absl::string_view sender_peer_name,

                             absl::string_view receiver_peer_name) override;

  void OnResumeAllStreamsFrom(absl::string_view sender_peer_name,

                              absl::string_view receiver_peer_name) override;

  void Stop() override;

  std::string GetStreamLabel(uint16_t frame_id) override;

  std::string GetSenderPeerName(uint16_t frame_id) const override;

  void OnStatsReports(

      absl::string_view pc_label,

      const rtc::scoped_refptr<const RTCStatsReport>& report) override {}

  // Returns set of stream labels, that were met during test call.

  std::set<StatsKey> GetKnownVideoStreams() const;

  VideoStreamsInfo GetKnownStreams() const;

  FrameCounters GetGlobalCounters() const;

  // Returns frame counter for frames received without frame id set.

  std::map<std::string, FrameCounters> GetUnknownSenderFrameCounters() const;

  // Returns frame counter per stream label. Valid stream labels can be obtained

  // by calling GetKnownVideoStreams()

  std::map<StatsKey, FrameCounters> GetPerStreamCounters() const;

  // Returns video quality stats per stream label. Valid stream labels can be

  // obtained by calling GetKnownVideoStreams()

  std::map<StatsKey, StreamStats> GetStats() const;

  AnalyzerStats GetAnalyzerStats() const;

  double GetCpuUsagePercent() const;

  // Returns mapping from the stream label to the history of frames that were

  // met in this stream in the order as they were captured.

  std::map<std::string, std::vector<uint16_t>> GetStreamFrames() const;

 private:

  enum State { kNew, kActive, kStopped };

  // Returns next frame id to use. Frame ID can't be `VideoFrame::kNotSetId`,

  // because this value is reserved by `VideoFrame` as "ID not set".

  uint16_t GetNextFrameId() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);

  void AddExistingFramesInFlightForStreamToComparator(size_t stream_index,

                                                      StreamState& stream_state,

                                                      size_t peer_index)

      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);

  // Processes frames for the peer identified by `peer_index` up to

  // `rendered_frame_id` (excluded). Sends each dropped frame for comparison and

  // discards superfluous frames (they were not expected to be received by

  // `peer_index` and not accounted in the stats).

  // Returns number of dropped frames.

  int ProcessNotSeenFramesBeforeRendered(size_t peer_index,

                                         uint16_t rendered_frame_id,

                                         const InternalStatsKey& stats_key,

                                         StreamState& state)

      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);

  // Report results for all metrics for all streams.

  void ReportResults();

  void ReportResults(const InternalStatsKey& key,

                     const StreamStats& stats,

                     const FrameCounters& frame_counters)

      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);

  // Returns name of current test case for reporting.

  std::string GetTestCaseName(const std::string& stream_label) const;

  Timestamp Now();

  StatsKey ToStatsKey(const InternalStatsKey& key) const

      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);

  // Returns string representation of stats key for metrics naming. Used for

  // backward compatibility by metrics naming for 2 peers cases.

  std::string ToMetricName(const InternalStatsKey& key) const

      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);

  std::string GetStreamLabelInternal(uint16_t frame_id) const

      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);

  static const uint16_t kStartingFrameId = 1;

  const DefaultVideoQualityAnalyzerOptions options_;

  webrtc::Clock* const clock_;

  test::MetricsLogger* const metrics_logger_;

  std::string test_label_;

  mutable Mutex mutex_;

  uint16_t next_frame_id_ RTC_GUARDED_BY(mutex_) = kStartingFrameId;

  std::unique_ptr<NamesCollection> peers_ RTC_GUARDED_BY(mutex_);

  State state_ RTC_GUARDED_BY(mutex_) = State::kNew;

  Timestamp start_time_ RTC_GUARDED_BY(mutex_) = Timestamp::MinusInfinity();

  // Mapping from stream label to unique size_t value to use in stats and avoid

  // extra string copying.

  NamesCollection streams_ RTC_GUARDED_BY(mutex_);

  FramesStorage frames_storage_ RTC_GUARDED_BY(mutex_);

  // Frames that were captured by all streams and still aren't rendered on

  // receivers or deemed dropped. Frame with id X can be removed from this map

  // if:

  // 1. The frame with id X was received in OnFrameRendered by all expected

  //    receivers.

  // 2. The frame with id Y > X was received in OnFrameRendered by all expected

  //    receivers.

  // 3. Next available frame id for newly captured frame is X

  // 4. There too many frames in flight for current video stream and X is the

  //    oldest frame id in this stream. In such case only the frame content

  //    will be removed, but the map entry will be preserved.

  std::unordered_map<uint16_t, FrameInFlight> captured_frames_in_flight_

      RTC_GUARDED_BY(mutex_);

  // Global frames count for all video streams.

  FrameCounters frame_counters_ RTC_GUARDED_BY(mutex_);

  // Frame counters for received frames without video frame id set.

  // Map from peer name to the frame counters.

  std::map<std::string, FrameCounters> unknown_sender_frame_counters_

      RTC_GUARDED_BY(mutex_);

  // Frame counters per each stream per each receiver.

  std::map<InternalStatsKey, FrameCounters> stream_frame_counters_

      RTC_GUARDED_BY(mutex_);

  // Map from stream index in `streams_` to its StreamState.

  std::unordered_map<size_t, StreamState> stream_states_ RTC_GUARDED_BY(mutex_);

  // Map from stream index in `streams_` to sender peer index in `peers_`.

  std::unordered_map<size_t, size_t> stream_to_sender_ RTC_GUARDED_BY(mutex_);

  // Stores history mapping between stream index in `streams_` and frame ids.

  // Updated when frame id overlap. It required to properly return stream label

  // after 1st frame from simulcast streams was already rendered and last is

  // still encoding.

  std::unordered_map<size_t, std::set<uint16_t>> stream_to_frame_id_history_

      RTC_GUARDED_BY(mutex_);

  // Map from stream index to the list of frames as they were met in the stream.

  std::unordered_map<size_t, std::vector<uint16_t>>

      stream_to_frame_id_full_history_ RTC_GUARDED_BY(mutex_);

  AnalyzerStats analyzer_stats_ RTC_GUARDED_BY(mutex_);

  DefaultVideoQualityAnalyzerCpuMeasurer cpu_measurer_;

  DefaultVideoQualityAnalyzerFramesComparator frames_comparator_;

};

}  // namespace webrtc

#endif  // TEST_PC_E2E_ANALYZER_VIDEO_DEFAULT_VIDEO_QUALITY_ANALYZER_H_

Source code

Revision control

Copy as Markdown

Other Tools