RTPPayloadRegistry: Stop using the rate to keep track of receive codecs

webrtc/modules/rtp_rtcp/source/rtp_payload_registry_unittest.cc

 /*
  *  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.
  */
 
@@ skipping 10 matching lines @@
 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 uint32_t kTypicalRate = 32 * 1024;
-static const CodecInst kTypicalAudioCodec = {-1 /* pltype */,   "name",
+static const CodecInst kTypicalAudioCodec = {-1 /* pltype */, "name",
                                              kTypicalFrequency, 0 /* pacsize */,
-                                             kTypicalChannels,  kTypicalRate};
+                                             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;
 
@@ skipping 27 matching lines @@
 
   const RtpUtility::Payload* 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->audio);
   EXPECT_EQ(kTypicalFrequency, retrieved_payload->typeSpecific.Audio.frequency);
   EXPECT_EQ(kTypicalChannels, retrieved_payload->typeSpecific.Audio.channels);
-  EXPECT_EQ(kTypicalRate, retrieved_payload->typeSpecific.Audio.rate);
 
   // 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;
-  const int kRedBitRate = 0;
 
   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;
-  red_audio_codec.rate = kRedBitRate;
   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 RtpUtility::Payload* retrieved_payload =
       rtp_payload_registry.PayloadTypeToPayload(kRedPayloadType);
   EXPECT_TRUE(retrieved_payload);
   EXPECT_TRUE(retrieved_payload->audio);
@@ skipping 31 matching lines @@
       << "With a different payload type is fine though.";
 
   // Ensure both payloads are preserved.
   const RtpUtility::Payload* retrieved_payload =
       rtp_payload_registry.PayloadTypeToPayload(payload_type);
   EXPECT_TRUE(retrieved_payload);
   EXPECT_STREQ(kTypicalPayloadName, retrieved_payload->name);
   EXPECT_TRUE(retrieved_payload->audio);
   EXPECT_EQ(kTypicalFrequency, retrieved_payload->typeSpecific.Audio.frequency);
   EXPECT_EQ(kTypicalChannels, retrieved_payload->typeSpecific.Audio.channels);
-  EXPECT_EQ(kTypicalRate, retrieved_payload->typeSpecific.Audio.rate);
 
   retrieved_payload =
       rtp_payload_registry.PayloadTypeToPayload(payload_type - 1);
   EXPECT_TRUE(retrieved_payload);
   EXPECT_STREQ(kTypicalPayloadName, retrieved_payload->name);
   EXPECT_TRUE(retrieved_payload->audio);
   EXPECT_EQ(kTypicalFrequency + 1,
             retrieved_payload->typeSpecific.Audio.frequency);
   EXPECT_EQ(kTypicalChannels, retrieved_payload->typeSpecific.Audio.channels);
-  EXPECT_EQ(kTypicalRate, retrieved_payload->typeSpecific.Audio.rate);
 
   // 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) {
@@ skipping 58 matching lines @@
 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;
-  audio_codec.rate = 17;
   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;
-  audio_codec.rate = 17;
   EXPECT_EQ(0,
             rtp_payload_registry.RegisterReceivePayload(audio_codec, &ignored));
 }
 
 // Generates an RTX packet for the given length and original sequence number.
 // The RTX sequence number and ssrc will use the default value of 9999. The
 // caller takes ownership of the returned buffer.
 const uint8_t* GenerateRtxPacket(size_t header_length,
                                  size_t payload_length,
                                  uint16_t original_sequence_number) {
@@ skipping 88 matching lines @@
   rtp_payload_registry.SetRtxPayloadType(105, 95);
   TestRtxPacket(&rtp_payload_registry, 105, 95, true);
   TestRtxPacket(&rtp_payload_registry, 106, 0, false);
 }
 
 INSTANTIATE_TEST_CASE_P(TestDynamicRange,
                         RtpPayloadRegistryGenericTest,
                         testing::Range(96, 127 + 1));
 
 }  // namespace webrtc