gecko-dev/media/webrtc/signaling/gtest/rtpsources_unittests.cpp

#include <RtpSourceObserver.h>
#include "webrtc/modules/include/module_common_types.h"
#define GTEST_HAS_RTTI 0
#include "gtest/gtest.h"

using namespace mozilla;

namespace test {
class RtpSourcesTest : public ::testing::Test
{
using RtpSourceHistory = RtpSourceObserver::RtpSourceHistory;
using RtpSourceEntry = mozilla::RtpSourceObserver::RtpSourceEntry;
public:

  // History Tests

  // Test init happens as expected
  void TestInitState() {
    RtpSourceHistory history;
    EXPECT_EQ(history.mDetailedHistory.size(), static_cast<size_t>(0));
    const auto& e = history.mLatestEviction;
    EXPECT_FALSE(history.mHasEvictedEntry);
    EXPECT_EQ(e.jitterAdjustedTimestamp, 0);
    EXPECT_FALSE(e.hasAudioLevel);
    EXPECT_EQ(e.audioLevel, 0);
  }

  // Test adding into the jitter window
  void TestInsertIntoJitterWindow() {
    const bool hasAudioLevel = true;
    const uint8_t audioLevel = 10;
    const int64_t jitter = 10;
    RtpSourceHistory history;
    const int64_t times[] = {100,
                             120,
                             140,
                             160,
                             180,
                             200,
                             220};
    const size_t numEntries = sizeof(times) / sizeof(times[0]);
    for (auto i : times) {
      history.Insert(i, i + jitter, hasAudioLevel, audioLevel);
     }
     ASSERT_EQ(history.mDetailedHistory.size(), numEntries);
     for (auto i : times) {
       auto entry = history.FindClosestNotAfter(i + jitter);
       ASSERT_NE(entry, nullptr);
       if (entry) {
         EXPECT_EQ(entry->jitterAdjustedTimestamp, i + jitter);
         EXPECT_EQ(entry->hasAudioLevel, hasAudioLevel);
         EXPECT_EQ(entry->audioLevel, audioLevel);
       }
     }
  }

  // Tests inserting before the jitter window, in long term history.
  void TestInsertIntoLongTerm() {
    RtpSourceHistory history;

    constexpr int64_t timeNow = 100000;
    // Should be discarded as too old
    constexpr int64_t time0 = timeNow - (10 * 1000) - 1;
    // Shold be commited
    constexpr int64_t time1 = timeNow - (10 * 1000);
    // Should be commited because it is newer
    constexpr int64_t time2 = timeNow - (5 * 1000);
    // Should be discarded because it is older
    constexpr int64_t time3 = timeNow - (7 * 1000);
    // Prune time0 should not prune time2
    constexpr int64_t pruneTime0 = time2 + (10 * 1000);
    // Prune time1 should prune time2
    constexpr int64_t pruneTime1 = time2 + (10 * 1000) + 1;

    // time0
    history.Insert(timeNow, time0, true, 0);
    EXPECT_TRUE(history.Empty());
    EXPECT_FALSE(history.mHasEvictedEntry);

    // time1
    history.Insert(timeNow, time1, true, 0);
    // Check that the jitter window buffer hasn't been used
    EXPECT_TRUE(history.Empty());
    ASSERT_EQ(history.mLatestEviction.jitterAdjustedTimestamp, time1);
    EXPECT_TRUE(history.mHasEvictedEntry);

    // time2
    history.Insert(timeNow, time2, true, 0);
    EXPECT_TRUE(history.Empty());
    ASSERT_EQ(history.mLatestEviction.jitterAdjustedTimestamp, time2);
    EXPECT_TRUE(history.mHasEvictedEntry);

    // time3
    history.Insert(timeNow, time3, true, 0);
    EXPECT_TRUE(history.Empty());
    ASSERT_EQ(history.mLatestEviction.jitterAdjustedTimestamp, time2);
    EXPECT_TRUE(history.mHasEvictedEntry);

    // pruneTime0
    history.Prune(pruneTime0);
    EXPECT_TRUE(history.Empty());
    ASSERT_EQ(history.mLatestEviction.jitterAdjustedTimestamp, time2);
    EXPECT_TRUE(history.mHasEvictedEntry);

    // pruneTime1
    history.Prune(pruneTime1);
    EXPECT_TRUE(history.Empty());
    EXPECT_FALSE(history.mHasEvictedEntry);
  }

  // Tests that a value inserted into the jitter window will age into long term
  // storage
  void TestAgeIntoLongTerm() {
    RtpSourceHistory history;
    constexpr int64_t jitterWindow = RtpSourceHistory::kMinJitterWindow;
    constexpr int64_t jitter = jitterWindow / 2;
    constexpr int64_t timeNow0 = 100000;
    constexpr int64_t time0 = timeNow0;
    constexpr int64_t time1 = timeNow0 + jitter;
    // Prune at timeNow1 should evict time0
    constexpr int64_t timeNow1 = time0 + jitterWindow + 1;
    // Prune at timeNow2 should evict time1
    constexpr int64_t timeNow2 = time1 + jitterWindow + 1;

    // time0
    history.Insert(timeNow0, time0, false, 1);
    EXPECT_FALSE(history.Empty());
    // Jitter window should not have grown
    ASSERT_EQ(history.mMaxJitterWindow, jitterWindow);
    EXPECT_EQ(history.mDetailedHistory.size(), static_cast<size_t>(1));
    EXPECT_FALSE(history.mHasEvictedEntry);

    // time1
    history.Insert(timeNow0, time1, true, 2);
    ASSERT_EQ(history.mMaxJitterWindow, jitterWindow);
    EXPECT_EQ(history.mDetailedHistory.size(), static_cast<size_t>(2));
    EXPECT_FALSE(history.mHasEvictedEntry);

    // Prune at timeNow1
    history.Prune(timeNow1);
    ASSERT_EQ(history.mMaxJitterWindow, jitterWindow);
    EXPECT_EQ(history.mDetailedHistory.size(), static_cast<size_t>(1));
    EXPECT_TRUE(history.mHasEvictedEntry);
    ASSERT_EQ(history.mLatestEviction.jitterAdjustedTimestamp, time0);
    ASSERT_EQ(history.mLatestEviction.hasAudioLevel, false);
    ASSERT_EQ(history.mLatestEviction.audioLevel, 1);

    // Prune at timeNow1
    history.Prune(timeNow2);
    EXPECT_EQ(history.mMaxJitterWindow, jitterWindow);
    EXPECT_EQ(history.mDetailedHistory.size(), static_cast<size_t>(0));
    EXPECT_TRUE(history.mHasEvictedEntry);
    EXPECT_EQ(history.mLatestEviction.jitterAdjustedTimestamp, time1);
    EXPECT_EQ(history.mLatestEviction.hasAudioLevel, true);
    EXPECT_EQ(history.mLatestEviction.audioLevel, 2);

  }

  // Packets have a maximum audio level of 127
  void TestMaximumAudioLevel() {
    RtpSourceHistory history;
    constexpr int64_t timeNow = 0;
    const int64_t jitterAdjusted = timeNow + 10;
    const bool hasAudioLevel = true;
    const uint8_t audioLevel0 = 127;
    // should result in in hasAudioLevel = false
    const uint8_t audioLevel1 = 255;
    // should result in in hasAudioLevel = false
    const uint8_t audioLevel2 = 128;

    // audio level 0
    history.Insert(timeNow, jitterAdjusted, hasAudioLevel, audioLevel0);
    ASSERT_FALSE(history.mHasEvictedEntry);
    EXPECT_EQ(history.mDetailedHistory.size(), static_cast<size_t>(1));
    {
      auto* entry = history.FindClosestNotAfter(jitterAdjusted);
      ASSERT_NE(entry, nullptr);
      EXPECT_TRUE(entry->hasAudioLevel);
      EXPECT_EQ(entry->audioLevel, audioLevel0);
    }
    // audio level 1
    history.Insert(timeNow, jitterAdjusted, hasAudioLevel, audioLevel1);
    ASSERT_FALSE(history.mHasEvictedEntry);
    EXPECT_EQ(history.mDetailedHistory.size(), static_cast<size_t>(1));
    {
      auto* entry = history.FindClosestNotAfter(jitterAdjusted);
      ASSERT_NE(entry, nullptr);
      EXPECT_FALSE(entry->hasAudioLevel);
      EXPECT_EQ(entry->audioLevel, audioLevel1);
    }
    // audio level 2
    history.Insert(timeNow, jitterAdjusted, hasAudioLevel, audioLevel2);
    ASSERT_FALSE(history.mHasEvictedEntry);
    EXPECT_EQ(history.mDetailedHistory.size(), static_cast<size_t>(1));
    {
      auto* entry = history.FindClosestNotAfter(jitterAdjusted);
      ASSERT_NE(entry, nullptr);
      EXPECT_FALSE(entry->hasAudioLevel);
      EXPECT_EQ(entry->audioLevel, audioLevel2);
    }
  }

  void TestEmptyPrune() {
    // Empty Prune
    RtpSourceHistory history;
    const int64_t timeNow = 0;
    history.Prune(timeNow);
    EXPECT_TRUE(history.Empty());
    EXPECT_EQ(history.mDetailedHistory.size(), static_cast<size_t>(0));
    EXPECT_FALSE(history.mHasEvictedEntry);
  }

  void TestSinglePrune() {
    RtpSourceHistory history;
    constexpr int64_t timeNow = 10000;
    constexpr int64_t jitter = RtpSourceHistory::kMinJitterWindow / 2;
    const int64_t jitterAdjusted = timeNow + jitter;

    history.Insert(timeNow, jitterAdjusted, 0, false);
    history.Prune(timeNow + (jitter * 3) + 1);
    EXPECT_EQ(history.mDetailedHistory.size(), static_cast<size_t>(0));
    EXPECT_TRUE(history.mHasEvictedEntry);
    EXPECT_EQ(jitterAdjusted, history.mLatestEviction.jitterAdjustedTimestamp);
  }

  // Observer tests that keys are properly handled
  void TestKeyManipulation() {
    constexpr unsigned int ssrc = 4682;
    constexpr unsigned int csrc = 4682;
    auto ssrcKey = RtpSourceObserver::GetKey(
        ssrc, dom::RTCRtpSourceEntryType::Synchronization);
    auto csrcKey = RtpSourceObserver::GetKey(
        csrc, dom::RTCRtpSourceEntryType::Contributing);
    // SSRC and CSRC keys are not the same
    EXPECT_NE(ssrcKey, csrcKey);
    // Keys can be reversed back to source
    EXPECT_EQ(RtpSourceObserver::GetSourceFromKey(ssrcKey), ssrc);
    EXPECT_EQ(RtpSourceObserver::GetSourceFromKey(csrcKey), csrc);
    // Keys can be reversed back to type
    EXPECT_EQ(RtpSourceObserver::GetTypeFromKey(ssrcKey),
              dom::RTCRtpSourceEntryType::Synchronization);
    EXPECT_EQ(RtpSourceObserver::GetTypeFromKey(csrcKey),
              dom::RTCRtpSourceEntryType::Contributing);
  }

  // Observer a header with a single Csrc
  void TestObserveOneCsrc() {
    RtpSourceObserver observer;
    webrtc::WebRtcRTPHeader header;
    constexpr unsigned int ssrc = 857265;
    constexpr unsigned int csrc = 3268365;
    constexpr int64_t timestamp = 10000;
    constexpr int64_t jitter = 0;

    header.header.ssrc = ssrc;
    header.header.numCSRCs = 1;
    header.header.arrOfCSRCs[0] = csrc;
    observer.OnRtpPacket(&header, timestamp, jitter);

    // One for the SSRC, one for the CSRC
    EXPECT_EQ(observer.mRtpSources.size(), static_cast<size_t>(2));
    nsTArray<dom::RTCRtpSourceEntry> outLevels;
    observer.GetRtpSources(timestamp, outLevels);
    EXPECT_EQ(outLevels.Length(), static_cast<size_t>(2));
    bool ssrcFound = false;
    bool csrcFound = true;
    for (auto& entry : outLevels) {
      if (entry.mSource == ssrc) {
        ssrcFound = true;
        EXPECT_EQ(entry.mSourceType,
                  dom::RTCRtpSourceEntryType::Synchronization);
      }
      if (entry.mSource == csrc) {
        csrcFound = true;
        EXPECT_EQ(entry.mSourceType,
                  dom::RTCRtpSourceEntryType::Contributing);
      }
    }
    EXPECT_TRUE(ssrcFound);
    EXPECT_TRUE(csrcFound);
  }

  // Observer a header with two CSRCs
  void TestObserveTwoCsrcs() {
    RtpSourceObserver observer;
    webrtc::WebRtcRTPHeader header;
    constexpr unsigned int ssrc = 239485;
    constexpr unsigned int csrc0 = 3425;
    constexpr unsigned int csrc1 = 36457;
    constexpr int64_t timestamp = 10000;
    constexpr int64_t jitter = 0;

    header.header.ssrc = ssrc;
    header.header.numCSRCs = 2;
    header.header.arrOfCSRCs[0] = csrc0;
    header.header.arrOfCSRCs[1] = csrc1;
    observer.OnRtpPacket(&header, timestamp, jitter);

    // One for the SSRC, two for the CSRCs
    EXPECT_EQ(observer.mRtpSources.size(), static_cast<size_t>(3));
    nsTArray<dom::RTCRtpSourceEntry> outLevels;
    observer.GetRtpSources(timestamp, outLevels);
    EXPECT_EQ(outLevels.Length(), static_cast<size_t>(3));
    bool ssrcFound = false;
    bool csrc0Found = true;
    bool csrc1Found = true;
    for (auto& entry : outLevels) {
      if (entry.mSource == ssrc) {
        ssrcFound = true;
        EXPECT_EQ(entry.mSourceType,
                  dom::RTCRtpSourceEntryType::Synchronization);
      }
      if (entry.mSource == csrc0) {
        csrc0Found = true;
        EXPECT_EQ(entry.mSourceType,
                  dom::RTCRtpSourceEntryType::Contributing);
      }
      if (entry.mSource == csrc1) {
        csrc1Found = true;
        EXPECT_EQ(entry.mSourceType,
                  dom::RTCRtpSourceEntryType::Contributing);
      }
    }
    EXPECT_TRUE(ssrcFound);
    EXPECT_TRUE(csrc0Found);
    EXPECT_TRUE(csrc1Found);
  }

  // Observer a header with a CSRC with audio level extension
  void TestObserveCsrcWithAudioLevel() {
    RtpSourceObserver observer;
    webrtc::WebRtcRTPHeader header;
  }

};

TEST_F(RtpSourcesTest, TestInitState) { TestInitState(); }
TEST_F(RtpSourcesTest, TestInsertIntoJitterWindow) {
  TestInsertIntoJitterWindow();
}
TEST_F(RtpSourcesTest, TestAgeIntoLongTerm){ TestAgeIntoLongTerm(); }
TEST_F(RtpSourcesTest, TestInsertIntoLongTerm) { TestInsertIntoLongTerm(); }
TEST_F(RtpSourcesTest, TestMaximumAudioLevel) { TestMaximumAudioLevel(); }
TEST_F(RtpSourcesTest, TestEmptyPrune) { TestEmptyPrune(); }
TEST_F(RtpSourcesTest, TestSinglePrune) { TestSinglePrune(); }
TEST_F(RtpSourcesTest, TestKeyManipulation) { TestKeyManipulation(); }
TEST_F(RtpSourcesTest, TestObserveOneCsrc) { TestObserveOneCsrc(); }
TEST_F(RtpSourcesTest, TestObserveTwoCsrcs) { TestObserveTwoCsrcs(); }
TEST_F(RtpSourcesTest, TestObserveCsrcWithAudioLevel) {
  TestObserveCsrcWithAudioLevel();
}
}