mirror of
https://github.com/mollyim/webrtc.git
synced 2025-05-14 22:30:40 +01:00
c856dc2b6b
Stop using PayloadUnion's public member variables, since a future CL will make them private. BUG=webrtc:8159 Change-Id: Ia3dada56be7ef00ed80f3733209b18c178a36561 Reviewed-on: https://webrtc-review.googlesource.com/4380 Commit-Queue: Karl Wiberg <kwiberg@webrtc.org> Reviewed-by: Danil Chapovalov <danilchap@webrtc.org> Cr-Commit-Position: refs/heads/master@{#20027}
271 lines
10 KiB
C++
271 lines
10 KiB
C++
/*
|
|
* Copyright (c) 2013 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.
|
|
*/
|
|
|
|
#include <memory>
|
|
|
|
#include "common_types.h" // NOLINT(build/include)
|
|
#include "modules/rtp_rtcp/include/rtp_header_parser.h"
|
|
#include "modules/rtp_rtcp/include/rtp_payload_registry.h"
|
|
#include "modules/rtp_rtcp/source/rtp_utility.h"
|
|
#include "test/gmock.h"
|
|
#include "test/gtest.h"
|
|
|
|
namespace webrtc {
|
|
|
|
using ::testing::Eq;
|
|
using ::testing::Return;
|
|
using ::testing::StrEq;
|
|
using ::testing::_;
|
|
|
|
static const char* kTypicalPayloadName = "name";
|
|
static const size_t kTypicalChannels = 1;
|
|
static const uint32_t kTypicalFrequency = 44000;
|
|
static const CodecInst kTypicalAudioCodec = {-1 /* pltype */, "name",
|
|
kTypicalFrequency, 0 /* pacsize */,
|
|
kTypicalChannels};
|
|
|
|
TEST(RtpPayloadRegistryTest,
|
|
RegistersAndRemembersVideoPayloadsUntilDeregistered) {
|
|
RTPPayloadRegistry rtp_payload_registry;
|
|
const uint8_t payload_type = 97;
|
|
VideoCodec video_codec;
|
|
video_codec.codecType = kVideoCodecVP8;
|
|
strncpy(video_codec.plName, "VP8", RTP_PAYLOAD_NAME_SIZE);
|
|
video_codec.plType = payload_type;
|
|
|
|
EXPECT_EQ(0, rtp_payload_registry.RegisterReceivePayload(video_codec));
|
|
|
|
const auto retrieved_payload =
|
|
rtp_payload_registry.PayloadTypeToPayload(payload_type);
|
|
EXPECT_TRUE(retrieved_payload);
|
|
|
|
// We should get back the corresponding payload that we registered.
|
|
EXPECT_STREQ("VP8", retrieved_payload->name);
|
|
EXPECT_TRUE(retrieved_payload->typeSpecific.is_video());
|
|
EXPECT_EQ(kRtpVideoVp8,
|
|
retrieved_payload->typeSpecific.video_payload().videoCodecType);
|
|
|
|
// Now forget about it and verify it's gone.
|
|
EXPECT_EQ(0, rtp_payload_registry.DeRegisterReceivePayload(payload_type));
|
|
EXPECT_FALSE(rtp_payload_registry.PayloadTypeToPayload(payload_type));
|
|
}
|
|
|
|
TEST(RtpPayloadRegistryTest,
|
|
RegistersAndRemembersAudioPayloadsUntilDeregistered) {
|
|
RTPPayloadRegistry rtp_payload_registry;
|
|
uint8_t payload_type = 97;
|
|
bool new_payload_created = false;
|
|
CodecInst audio_codec = kTypicalAudioCodec;
|
|
audio_codec.pltype = payload_type;
|
|
EXPECT_EQ(0, rtp_payload_registry.RegisterReceivePayload(
|
|
audio_codec, &new_payload_created));
|
|
|
|
EXPECT_TRUE(new_payload_created) << "A new payload WAS created.";
|
|
|
|
const auto retrieved_payload =
|
|
rtp_payload_registry.PayloadTypeToPayload(payload_type);
|
|
EXPECT_TRUE(retrieved_payload);
|
|
|
|
// We should get back the corresponding payload that we registered.
|
|
EXPECT_STREQ(kTypicalPayloadName, retrieved_payload->name);
|
|
EXPECT_TRUE(retrieved_payload->typeSpecific.is_audio());
|
|
EXPECT_EQ(kTypicalFrequency,
|
|
retrieved_payload->typeSpecific.audio_payload().frequency);
|
|
EXPECT_EQ(kTypicalChannels,
|
|
retrieved_payload->typeSpecific.audio_payload().channels);
|
|
|
|
// Now forget about it and verify it's gone.
|
|
EXPECT_EQ(0, rtp_payload_registry.DeRegisterReceivePayload(payload_type));
|
|
EXPECT_FALSE(rtp_payload_registry.PayloadTypeToPayload(payload_type));
|
|
}
|
|
|
|
TEST(RtpPayloadRegistryTest, AudioRedWorkProperly) {
|
|
const uint8_t kRedPayloadType = 127;
|
|
const int kRedSampleRate = 8000;
|
|
const size_t kRedChannels = 1;
|
|
|
|
RTPPayloadRegistry rtp_payload_registry;
|
|
|
|
bool new_payload_created = false;
|
|
CodecInst red_audio_codec;
|
|
strncpy(red_audio_codec.plname, "red", RTP_PAYLOAD_NAME_SIZE);
|
|
red_audio_codec.pltype = kRedPayloadType;
|
|
red_audio_codec.plfreq = kRedSampleRate;
|
|
red_audio_codec.channels = kRedChannels;
|
|
EXPECT_EQ(0, rtp_payload_registry.RegisterReceivePayload(
|
|
red_audio_codec, &new_payload_created));
|
|
EXPECT_TRUE(new_payload_created);
|
|
|
|
EXPECT_EQ(kRedPayloadType, rtp_payload_registry.red_payload_type());
|
|
|
|
const auto retrieved_payload =
|
|
rtp_payload_registry.PayloadTypeToPayload(kRedPayloadType);
|
|
EXPECT_TRUE(retrieved_payload);
|
|
EXPECT_TRUE(retrieved_payload->typeSpecific.is_audio());
|
|
EXPECT_STRCASEEQ("red", retrieved_payload->name);
|
|
|
|
// Sample rate is correctly registered.
|
|
EXPECT_EQ(kRedSampleRate,
|
|
rtp_payload_registry.GetPayloadTypeFrequency(kRedPayloadType));
|
|
}
|
|
|
|
TEST(RtpPayloadRegistryTest,
|
|
DoesNotAcceptSamePayloadTypeTwiceExceptIfPayloadIsCompatible) {
|
|
uint8_t payload_type = 97;
|
|
RTPPayloadRegistry rtp_payload_registry;
|
|
|
|
bool ignored = false;
|
|
CodecInst audio_codec = kTypicalAudioCodec;
|
|
audio_codec.pltype = payload_type;
|
|
EXPECT_EQ(0,
|
|
rtp_payload_registry.RegisterReceivePayload(audio_codec, &ignored));
|
|
|
|
CodecInst audio_codec_2 = kTypicalAudioCodec;
|
|
audio_codec_2.pltype = payload_type;
|
|
// Make |audio_codec_2| incompatible with |audio_codec| by changing
|
|
// the frequency.
|
|
audio_codec_2.plfreq = kTypicalFrequency + 1;
|
|
EXPECT_EQ(
|
|
-1, rtp_payload_registry.RegisterReceivePayload(audio_codec_2, &ignored))
|
|
<< "Adding incompatible codec with same payload type = bad.";
|
|
|
|
// Change payload type.
|
|
audio_codec_2.pltype = payload_type - 1;
|
|
EXPECT_EQ(
|
|
0, rtp_payload_registry.RegisterReceivePayload(audio_codec_2, &ignored))
|
|
<< "With a different payload type is fine though.";
|
|
|
|
// Ensure both payloads are preserved.
|
|
const auto retrieved_payload1 =
|
|
rtp_payload_registry.PayloadTypeToPayload(payload_type);
|
|
EXPECT_TRUE(retrieved_payload1);
|
|
EXPECT_STREQ(kTypicalPayloadName, retrieved_payload1->name);
|
|
EXPECT_TRUE(retrieved_payload1->typeSpecific.is_audio());
|
|
EXPECT_EQ(kTypicalFrequency,
|
|
retrieved_payload1->typeSpecific.audio_payload().frequency);
|
|
EXPECT_EQ(kTypicalChannels,
|
|
retrieved_payload1->typeSpecific.audio_payload().channels);
|
|
|
|
const auto retrieved_payload2 =
|
|
rtp_payload_registry.PayloadTypeToPayload(payload_type - 1);
|
|
EXPECT_TRUE(retrieved_payload2);
|
|
EXPECT_STREQ(kTypicalPayloadName, retrieved_payload2->name);
|
|
EXPECT_TRUE(retrieved_payload2->typeSpecific.is_audio());
|
|
EXPECT_EQ(kTypicalFrequency + 1,
|
|
retrieved_payload2->typeSpecific.audio_payload().frequency);
|
|
EXPECT_EQ(kTypicalChannels,
|
|
retrieved_payload2->typeSpecific.audio_payload().channels);
|
|
|
|
// Ok, update the rate for one of the codecs. If either the incoming rate or
|
|
// the stored rate is zero it's not really an error to register the same
|
|
// codec twice, and in that case roughly the following happens.
|
|
EXPECT_EQ(0,
|
|
rtp_payload_registry.RegisterReceivePayload(audio_codec, &ignored));
|
|
}
|
|
|
|
TEST(RtpPayloadRegistryTest,
|
|
RemovesCompatibleCodecsOnRegistryIfCodecsMustBeUnique) {
|
|
uint8_t payload_type = 97;
|
|
RTPPayloadRegistry rtp_payload_registry;
|
|
|
|
bool ignored = false;
|
|
CodecInst audio_codec = kTypicalAudioCodec;
|
|
audio_codec.pltype = payload_type;
|
|
EXPECT_EQ(0,
|
|
rtp_payload_registry.RegisterReceivePayload(audio_codec, &ignored));
|
|
CodecInst audio_codec_2 = kTypicalAudioCodec;
|
|
audio_codec_2.pltype = payload_type - 1;
|
|
EXPECT_EQ(
|
|
0, rtp_payload_registry.RegisterReceivePayload(audio_codec_2, &ignored));
|
|
|
|
EXPECT_FALSE(rtp_payload_registry.PayloadTypeToPayload(payload_type))
|
|
<< "The first payload should be "
|
|
"deregistered because the only thing that differs is payload type.";
|
|
EXPECT_TRUE(rtp_payload_registry.PayloadTypeToPayload(payload_type - 1))
|
|
<< "The second payload should still be registered though.";
|
|
|
|
// Now ensure non-compatible codecs aren't removed. Make |audio_codec_3|
|
|
// incompatible by changing the frequency.
|
|
CodecInst audio_codec_3 = kTypicalAudioCodec;
|
|
audio_codec_3.pltype = payload_type + 1;
|
|
audio_codec_3.plfreq = kTypicalFrequency + 1;
|
|
EXPECT_EQ(
|
|
0, rtp_payload_registry.RegisterReceivePayload(audio_codec_3, &ignored));
|
|
|
|
EXPECT_TRUE(rtp_payload_registry.PayloadTypeToPayload(payload_type - 1))
|
|
<< "Not compatible; both payloads should be kept.";
|
|
EXPECT_TRUE(rtp_payload_registry.PayloadTypeToPayload(payload_type + 1))
|
|
<< "Not compatible; both payloads should be kept.";
|
|
}
|
|
|
|
TEST(RtpPayloadRegistryTest,
|
|
LastReceivedCodecTypesAreResetWhenRegisteringNewPayloadTypes) {
|
|
RTPPayloadRegistry rtp_payload_registry;
|
|
rtp_payload_registry.set_last_received_payload_type(17);
|
|
EXPECT_EQ(17, rtp_payload_registry.last_received_payload_type());
|
|
|
|
bool media_type_unchanged = rtp_payload_registry.ReportMediaPayloadType(18);
|
|
EXPECT_FALSE(media_type_unchanged);
|
|
media_type_unchanged = rtp_payload_registry.ReportMediaPayloadType(18);
|
|
EXPECT_TRUE(media_type_unchanged);
|
|
|
|
bool ignored;
|
|
CodecInst audio_codec = kTypicalAudioCodec;
|
|
audio_codec.pltype = 34;
|
|
EXPECT_EQ(0,
|
|
rtp_payload_registry.RegisterReceivePayload(audio_codec, &ignored));
|
|
|
|
EXPECT_EQ(-1, rtp_payload_registry.last_received_payload_type());
|
|
media_type_unchanged = rtp_payload_registry.ReportMediaPayloadType(18);
|
|
EXPECT_FALSE(media_type_unchanged);
|
|
}
|
|
|
|
class ParameterizedRtpPayloadRegistryTest
|
|
: public ::testing::TestWithParam<int> {};
|
|
|
|
TEST_P(ParameterizedRtpPayloadRegistryTest,
|
|
FailsToRegisterKnownPayloadsWeAreNotInterestedIn) {
|
|
RTPPayloadRegistry rtp_payload_registry;
|
|
|
|
bool ignored;
|
|
CodecInst audio_codec;
|
|
strncpy(audio_codec.plname, "whatever", RTP_PAYLOAD_NAME_SIZE);
|
|
audio_codec.pltype = GetParam();
|
|
audio_codec.plfreq = 1900;
|
|
audio_codec.channels = 1;
|
|
EXPECT_EQ(-1,
|
|
rtp_payload_registry.RegisterReceivePayload(audio_codec, &ignored));
|
|
}
|
|
|
|
INSTANTIATE_TEST_CASE_P(TestKnownBadPayloadTypes,
|
|
ParameterizedRtpPayloadRegistryTest,
|
|
testing::Values(64, 72, 73, 74, 75, 76, 77, 78, 79));
|
|
|
|
class RtpPayloadRegistryGenericTest : public ::testing::TestWithParam<int> {};
|
|
|
|
TEST_P(RtpPayloadRegistryGenericTest, RegisterGenericReceivePayloadType) {
|
|
RTPPayloadRegistry rtp_payload_registry;
|
|
|
|
bool ignored;
|
|
CodecInst audio_codec;
|
|
// Dummy values, except for payload_type.
|
|
strncpy(audio_codec.plname, "generic-codec", RTP_PAYLOAD_NAME_SIZE);
|
|
audio_codec.pltype = GetParam();
|
|
audio_codec.plfreq = 1900;
|
|
audio_codec.channels = 1;
|
|
EXPECT_EQ(0,
|
|
rtp_payload_registry.RegisterReceivePayload(audio_codec, &ignored));
|
|
}
|
|
|
|
INSTANTIATE_TEST_CASE_P(TestDynamicRange,
|
|
RtpPayloadRegistryGenericTest,
|
|
testing::Range(96, 127 + 1));
|
|
|
|
} // namespace webrtc
|