src/third_party/webrtc/modules/audio_coding/main/test/dual_stream_unittest.cc

   1 /*
   2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
   3  *
   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
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include "testing/gtest/include/gtest/gtest.h"
  12 #include "webrtc/modules/audio_coding/main/acm2/acm_common_defs.h"
  13 #include "webrtc/modules/audio_coding/main/interface/audio_coding_module.h"
  14 #include "webrtc/modules/audio_coding/main/test/PCMFile.h"
  15 #include "webrtc/modules/audio_coding/main/test/utility.h"
  16 #include "webrtc/modules/interface/module_common_types.h"
  17 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
  18 #include "webrtc/typedefs.h"
  19 #include "webrtc/test/testsupport/fileutils.h"
  20 #include "webrtc/test/testsupport/gtest_disable.h"
  21
  22 namespace webrtc {
  23
  24 class DualStreamTest : public AudioPacketizationCallback,
  25                        public ::testing::Test {
  26  protected:
  27   DualStreamTest();
  28   ~DualStreamTest();
  29
  30   void RunTest(int frame_size_primary_samples,
  31                int num_channels_primary,
  32                int sampling_rate,
  33                bool start_in_sync,
  34                int num_channels_input);
  35
  36   void ApiTest();
  37
  38   virtual int32_t SendData(
  39       FrameType frameType, uint8_t payload_type,
  40       uint32_t timestamp, const uint8_t* payload_data,
  41       uint16_t payload_size,
  42       const RTPFragmentationHeader* fragmentation) OVERRIDE;
  43
  44   void Perform(bool start_in_sync, int num_channels_input);
  45
  46   void InitializeSender(int frame_size_primary_samples,
  47                         int num_channels_primary, int sampling_rate);
  48
  49   void PopulateCodecInstances(int frame_size_primary_ms,
  50                               int num_channels_primary, int sampling_rate);
  51
  52   void Validate(bool start_in_sync, int tolerance);
  53   bool EqualTimestamp(int stream, int position);
  54   int EqualPayloadLength(int stream, int position);
  55   bool EqualPayloadData(int stream, int position);
  56
  57   static const int kMaxNumStoredPayloads = 2;
  58
  59   enum {
  60     kPrimary = 0,
  61     kSecondary,
  62     kMaxNumStreams
  63   };
  64
  65   scoped_ptr<AudioCodingModule> acm_dual_stream_;
  66   scoped_ptr<AudioCodingModule> acm_ref_primary_;
  67   scoped_ptr<AudioCodingModule> acm_ref_secondary_;
  68
  69   CodecInst primary_encoder_;
  70   CodecInst secondary_encoder_;
  71
  72   CodecInst red_encoder_;
  73
  74   int payload_ref_is_stored_[kMaxNumStreams][kMaxNumStoredPayloads];
  75   int payload_dual_is_stored_[kMaxNumStreams][kMaxNumStoredPayloads];
  76
  77   uint32_t timestamp_ref_[kMaxNumStreams][kMaxNumStoredPayloads];
  78   uint32_t timestamp_dual_[kMaxNumStreams][kMaxNumStoredPayloads];
  79
  80   int payload_len_ref_[kMaxNumStreams][kMaxNumStoredPayloads];
  81   int payload_len_dual_[kMaxNumStreams][kMaxNumStoredPayloads];
  82
  83   uint8_t payload_data_ref_[kMaxNumStreams][MAX_PAYLOAD_SIZE_BYTE
  84       * kMaxNumStoredPayloads];
  85   uint8_t payload_data_dual_[kMaxNumStreams][MAX_PAYLOAD_SIZE_BYTE
  86       * kMaxNumStoredPayloads];
  87   int num_received_payloads_dual_[kMaxNumStreams];
  88   int num_received_payloads_ref_[kMaxNumStreams];
  89
  90   int num_compared_payloads_[kMaxNumStreams];
  91   uint32_t last_timestamp_[kMaxNumStreams];
  92   bool received_payload_[kMaxNumStreams];
  93 };
  94
  95 DualStreamTest::DualStreamTest()
  96     : acm_dual_stream_(AudioCodingModule::Create(0)),
  97       acm_ref_primary_(AudioCodingModule::Create(1)),
  98       acm_ref_secondary_(AudioCodingModule::Create(2)),
  99       payload_ref_is_stored_(),
 100       payload_dual_is_stored_(),
 101       timestamp_ref_(),
 102       num_received_payloads_dual_(),
 103       num_received_payloads_ref_(),
 104       num_compared_payloads_(),
 105       last_timestamp_(),
 106       received_payload_() {}
 107
 108 DualStreamTest::~DualStreamTest() {}
 109
 110 void DualStreamTest::PopulateCodecInstances(int frame_size_primary_ms,
 111                                             int num_channels_primary,
 112                                             int sampling_rate) {
 113   CodecInst my_codec;
 114
 115   // Invalid values. To check later on if the codec are found in the database.
 116   primary_encoder_.pltype = -1;
 117   secondary_encoder_.pltype = -1;
 118   red_encoder_.pltype = -1;
 119
 120   for (int n = 0; n < AudioCodingModule::NumberOfCodecs(); n++) {
 121     AudioCodingModule::Codec(n, &my_codec);
 122     if (strcmp(my_codec.plname, "ISAC") == 0
 123         && my_codec.plfreq == sampling_rate) {
 124       my_codec.rate = 32000;
 125       my_codec.pacsize = 30 * sampling_rate / 1000;
 126       memcpy(&secondary_encoder_, &my_codec, sizeof(my_codec));
 127     } else if (strcmp(my_codec.plname, "L16") == 0
 128         && my_codec.channels == num_channels_primary
 129         && my_codec.plfreq == sampling_rate) {
 130       my_codec.pacsize = frame_size_primary_ms * sampling_rate / 1000;
 131       memcpy(&primary_encoder_, &my_codec, sizeof(my_codec));
 132     } else if (strcmp(my_codec.plname, "red") == 0) {
 133       memcpy(&red_encoder_, &my_codec, sizeof(my_codec));
 134     }
 135   }
 136
 137   ASSERT_GE(primary_encoder_.pltype, 0);
 138   ASSERT_GE(secondary_encoder_.pltype, 0);
 139   ASSERT_GE(red_encoder_.pltype, 0);
 140 }
 141
 142 void DualStreamTest::InitializeSender(int frame_size_primary_samples,
 143                                       int num_channels_primary,
 144                                       int sampling_rate) {
 145   ASSERT_TRUE(acm_dual_stream_.get() != NULL);
 146   ASSERT_TRUE(acm_ref_primary_.get() != NULL);
 147   ASSERT_TRUE(acm_ref_secondary_.get() != NULL);
 148
 149   ASSERT_EQ(0, acm_dual_stream_->InitializeSender());
 150   ASSERT_EQ(0, acm_ref_primary_->InitializeSender());
 151   ASSERT_EQ(0, acm_ref_secondary_->InitializeSender());
 152
 153   PopulateCodecInstances(frame_size_primary_samples, num_channels_primary,
 154                          sampling_rate);
 155
 156   ASSERT_EQ(0, acm_ref_primary_->RegisterSendCodec(primary_encoder_));
 157   ASSERT_EQ(0, acm_ref_secondary_->RegisterSendCodec(secondary_encoder_));
 158   ASSERT_EQ(0, acm_dual_stream_->RegisterSendCodec(primary_encoder_));
 159   ASSERT_EQ(0,
 160             acm_dual_stream_->RegisterSecondarySendCodec(secondary_encoder_));
 161
 162   ASSERT_EQ(0, acm_ref_primary_->RegisterTransportCallback(this));
 163   ASSERT_EQ(0, acm_ref_secondary_->RegisterTransportCallback(this));
 164   ASSERT_EQ(0, acm_dual_stream_->RegisterTransportCallback(this));
 165 }
 166
 167 void DualStreamTest::Perform(bool start_in_sync, int num_channels_input) {
 168   PCMFile pcm_file;
 169   std::string file_name = test::ResourcePath(
 170       (num_channels_input == 1) ?
 171           "audio_coding/testfile32kHz" : "audio_coding/teststereo32kHz",
 172       "pcm");
 173   pcm_file.Open(file_name, 32000, "rb");
 174   pcm_file.ReadStereo(num_channels_input == 2);
 175   AudioFrame audio_frame;
 176
 177   int tolerance = 0;
 178   if (num_channels_input == 2 && primary_encoder_.channels == 2
 179       && secondary_encoder_.channels == 1) {
 180     tolerance = 12;
 181   }
 182
 183   if (!start_in_sync) {
 184     pcm_file.Read10MsData(audio_frame);
 185     // Unregister secondary codec and feed only the primary
 186     acm_dual_stream_->UnregisterSecondarySendCodec();
 187     EXPECT_EQ(0, acm_dual_stream_->Add10MsData(audio_frame));
 188     EXPECT_EQ(0, acm_ref_primary_->Add10MsData(audio_frame));
 189     ASSERT_EQ(0,
 190               acm_dual_stream_->RegisterSecondarySendCodec(secondary_encoder_));
 191   }
 192
 193   const int kNumFramesToProcess = 100;
 194   int frame_cntr = 0;
 195   while (!pcm_file.EndOfFile() && frame_cntr < kNumFramesToProcess) {
 196     pcm_file.Read10MsData(audio_frame);
 197     frame_cntr++;
 198     EXPECT_EQ(0, acm_dual_stream_->Add10MsData(audio_frame));
 199     EXPECT_EQ(0, acm_ref_primary_->Add10MsData(audio_frame));
 200     EXPECT_EQ(0, acm_ref_secondary_->Add10MsData(audio_frame));
 201
 202     EXPECT_GE(acm_dual_stream_->Process(), 0);
 203     EXPECT_GE(acm_ref_primary_->Process(), 0);
 204     EXPECT_GE(acm_ref_secondary_->Process(), 0);
 205
 206     if (start_in_sync || frame_cntr > 7) {
 207       // If we haven't started in sync the first few audio frames might
 208       // slightly differ due to the difference in the state of the resamplers
 209       // of dual-ACM and reference-ACM.
 210       Validate(start_in_sync, tolerance);
 211     } else {
 212       // SendData stores the payloads, if we are not comparing we have to free
 213       // the space by resetting these flags.
 214       memset(payload_ref_is_stored_, 0, sizeof(payload_ref_is_stored_));
 215       memset(payload_dual_is_stored_, 0, sizeof(payload_dual_is_stored_));
 216     }
 217   }
 218   pcm_file.Close();
 219
 220   // Make sure that number of received payloads match. In case of secondary
 221   // encoder, the dual-stream might deliver one lesser payload. The reason is
 222   // that some secondary payloads are stored to be sent with a payload generated
 223   // later and the input file may end before the "next" payload .
 224   EXPECT_EQ(num_received_payloads_ref_[kPrimary],
 225             num_received_payloads_dual_[kPrimary]);
 226   EXPECT_TRUE(
 227       num_received_payloads_ref_[kSecondary]
 228           == num_received_payloads_dual_[kSecondary]
 229           || num_received_payloads_ref_[kSecondary]
 230               == (num_received_payloads_dual_[kSecondary] + 1));
 231
 232   // Make sure all received payloads are compared.
 233   if (start_in_sync) {
 234     EXPECT_EQ(num_received_payloads_dual_[kPrimary],
 235               num_compared_payloads_[kPrimary]);
 236     EXPECT_EQ(num_received_payloads_dual_[kSecondary],
 237               num_compared_payloads_[kSecondary]);
 238   } else {
 239     // In asynchronous test we don't compare couple of first frames, so we
 240     // should account for them in our counting.
 241     EXPECT_GE(num_compared_payloads_[kPrimary],
 242               num_received_payloads_dual_[kPrimary] - 4);
 243     EXPECT_GE(num_compared_payloads_[kSecondary],
 244               num_received_payloads_dual_[kSecondary] - 4);
 245   }
 246 }
 247
 248 bool DualStreamTest::EqualTimestamp(int stream_index, int position) {
 249   if (timestamp_dual_[stream_index][position]
 250       != timestamp_ref_[stream_index][position]) {
 251     return false;
 252   }
 253   return true;
 254 }
 255
 256 int DualStreamTest::EqualPayloadLength(int stream_index, int position) {
 257   return abs(
 258       payload_len_dual_[stream_index][position]
 259           - payload_len_ref_[stream_index][position]);
 260 }
 261
 262 bool DualStreamTest::EqualPayloadData(int stream_index, int position) {
 263   assert(
 264       payload_len_dual_[stream_index][position]
 265           == payload_len_ref_[stream_index][position]);
 266   int offset = position * MAX_PAYLOAD_SIZE_BYTE;
 267   for (int n = 0; n < payload_len_dual_[stream_index][position]; n++) {
 268     if (payload_data_dual_[stream_index][offset + n]
 269         != payload_data_ref_[stream_index][offset + n]) {
 270       return false;
 271     }
 272   }
 273   return true;
 274 }
 275
 276 void DualStreamTest::Validate(bool start_in_sync, int tolerance) {
 277   for (int stream_index = 0; stream_index < kMaxNumStreams; stream_index++) {
 278     int my_tolerance = stream_index == kPrimary ? 0 : tolerance;
 279     for (int position = 0; position < kMaxNumStoredPayloads; position++) {
 280       if (payload_ref_is_stored_[stream_index][position] == 1
 281           && payload_dual_is_stored_[stream_index][position] == 1) {
 282         // Check timestamps only if codecs started in sync or it is primary.
 283         if (start_in_sync || stream_index == 0)
 284           EXPECT_TRUE(EqualTimestamp(stream_index, position));
 285         EXPECT_LE(EqualPayloadLength(stream_index, position), my_tolerance);
 286         if (my_tolerance == 0)
 287           EXPECT_TRUE(EqualPayloadData(stream_index, position));
 288         num_compared_payloads_[stream_index]++;
 289         payload_ref_is_stored_[stream_index][position] = 0;
 290         payload_dual_is_stored_[stream_index][position] = 0;
 291       }
 292     }
 293   }
 294 }
 295
 296 int32_t DualStreamTest::SendData(FrameType frameType, uint8_t payload_type,
 297                                  uint32_t timestamp,
 298                                  const uint8_t* payload_data,
 299                                  uint16_t payload_size,
 300                                  const RTPFragmentationHeader* fragmentation) {
 301   int position;
 302   int stream_index;
 303
 304   if (payload_type == red_encoder_.pltype) {
 305     if (fragmentation == NULL) {
 306       assert(false);
 307       return -1;
 308     }
 309     // As the oldest payloads are in the higher indices of fragmentation,
 310     // to be able to check the increment of timestamps are correct we loop
 311     // backward.
 312     for (int n = fragmentation->fragmentationVectorSize - 1; n >= 0; --n) {
 313       if (fragmentation->fragmentationPlType[n] == primary_encoder_.pltype) {
 314         // Received primary payload from dual stream.
 315         stream_index = kPrimary;
 316       } else if (fragmentation->fragmentationPlType[n]
 317           == secondary_encoder_.pltype) {
 318         // Received secondary payload from dual stream.
 319         stream_index = kSecondary;
 320       } else {
 321         assert(false);
 322         return -1;
 323       }
 324       num_received_payloads_dual_[stream_index]++;
 325       if (payload_dual_is_stored_[stream_index][0] == 0) {
 326         position = 0;
 327       } else if (payload_dual_is_stored_[stream_index][1] == 0) {
 328         position = 1;
 329       } else {
 330         assert(false);
 331         return -1;
 332       }
 333       timestamp_dual_[stream_index][position] = timestamp
 334           - fragmentation->fragmentationTimeDiff[n];
 335       payload_len_dual_[stream_index][position] = fragmentation
 336           ->fragmentationLength[n];
 337       memcpy(
 338           &payload_data_dual_[stream_index][position * MAX_PAYLOAD_SIZE_BYTE],
 339           &payload_data[fragmentation->fragmentationOffset[n]],
 340           fragmentation->fragmentationLength[n]);
 341       payload_dual_is_stored_[stream_index][position] = 1;
 342       // Check if timestamps are incremented correctly.
 343       if (received_payload_[stream_index]) {
 344         int t = timestamp_dual_[stream_index][position]
 345             - last_timestamp_[stream_index];
 346         if ((stream_index == kPrimary) && (t != primary_encoder_.pacsize)) {
 347           assert(false);
 348           return -1;
 349         }
 350         if ((stream_index == kSecondary) && (t != secondary_encoder_.pacsize)) {
 351           assert(false);
 352           return -1;
 353         }
 354       } else {
 355         received_payload_[stream_index] = true;
 356       }
 357       last_timestamp_[stream_index] = timestamp_dual_[stream_index][position];
 358     }
 359   } else {
 360     if (fragmentation != NULL) {
 361       assert(false);
 362       return -1;
 363     }
 364     if (payload_type == primary_encoder_.pltype) {
 365       stream_index = kPrimary;
 366     } else if (payload_type == secondary_encoder_.pltype) {
 367       stream_index = kSecondary;
 368     } else {
 369       assert(false);
 370       return -1;
 371     }
 372     num_received_payloads_ref_[stream_index]++;
 373     if (payload_ref_is_stored_[stream_index][0] == 0) {
 374       position = 0;
 375     } else if (payload_ref_is_stored_[stream_index][1] == 0) {
 376       position = 1;
 377     } else {
 378       assert(false);
 379       return -1;
 380     }
 381     timestamp_ref_[stream_index][position] = timestamp;
 382     payload_len_ref_[stream_index][position] = payload_size;
 383     memcpy(&payload_data_ref_[stream_index][position * MAX_PAYLOAD_SIZE_BYTE],
 384            payload_data, payload_size);
 385     payload_ref_is_stored_[stream_index][position] = 1;
 386   }
 387   return 0;
 388 }
 389
 390 // Mono input, mono primary WB 20 ms frame.
 391 TEST_F(DualStreamTest,
 392        DISABLED_ON_ANDROID(BitExactSyncMonoInputMonoPrimaryWb20Ms)) {
 393   InitializeSender(20, 1, 16000);
 394   Perform(true, 1);
 395 }
 396
 397 // Mono input, stereo primary WB 20 ms frame.
 398 TEST_F(DualStreamTest,
 399        DISABLED_ON_ANDROID(BitExactSyncMonoInput_StereoPrimaryWb20Ms)) {
 400   InitializeSender(20, 2, 16000);
 401   Perform(true, 1);
 402 }
 403
 404 // Mono input, mono primary SWB 20 ms frame.
 405 TEST_F(DualStreamTest,
 406        DISABLED_ON_ANDROID(BitExactSyncMonoInputMonoPrimarySwb20Ms)) {
 407   InitializeSender(20, 1, 32000);
 408   Perform(true, 1);
 409 }
 410
 411 // Mono input, stereo primary SWB 20 ms frame.
 412 TEST_F(DualStreamTest,
 413        DISABLED_ON_ANDROID(BitExactSyncMonoInputStereoPrimarySwb20Ms)) {
 414   InitializeSender(20, 2, 32000);
 415   Perform(true, 1);
 416 }
 417
 418 // Mono input, mono primary WB 40 ms frame.
 419 TEST_F(DualStreamTest,
 420        DISABLED_ON_ANDROID(BitExactSyncMonoInputMonoPrimaryWb40Ms)) {
 421   InitializeSender(40, 1, 16000);
 422   Perform(true, 1);
 423 }
 424
 425 // Mono input, stereo primary WB 40 ms frame
 426 TEST_F(DualStreamTest,
 427        DISABLED_ON_ANDROID(BitExactSyncMonoInputStereoPrimaryWb40Ms)) {
 428   InitializeSender(40, 2, 16000);
 429   Perform(true, 1);
 430 }
 431
 432 // Stereo input, mono primary WB 20 ms frame.
 433 TEST_F(DualStreamTest,
 434        DISABLED_ON_ANDROID(BitExactSyncStereoInputMonoPrimaryWb20Ms)) {
 435   InitializeSender(20, 1, 16000);
 436   Perform(true, 2);
 437 }
 438
 439 // Stereo input, stereo primary WB 20 ms frame.
 440 TEST_F(DualStreamTest,
 441        DISABLED_ON_ANDROID(BitExactSyncStereoInputStereoPrimaryWb20Ms)) {
 442   InitializeSender(20, 2, 16000);
 443   Perform(true, 2);
 444 }
 445
 446 // Stereo input, mono primary SWB 20 ms frame.
 447 TEST_F(DualStreamTest,
 448        DISABLED_ON_ANDROID(BitExactSyncStereoInputMonoPrimarySwb20Ms)) {
 449   InitializeSender(20, 1, 32000);
 450   Perform(true, 2);
 451 }
 452
 453 // Stereo input, stereo primary SWB 20 ms frame.
 454 TEST_F(DualStreamTest,
 455        DISABLED_ON_ANDROID(BitExactSyncStereoInputStereoPrimarySwb20Ms)) {
 456   InitializeSender(20, 2, 32000);
 457   Perform(true, 2);
 458 }
 459
 460 // Stereo input, mono primary WB 40 ms frame.
 461 TEST_F(DualStreamTest,
 462        DISABLED_ON_ANDROID(BitExactSyncStereoInputMonoPrimaryWb40Ms)) {
 463   InitializeSender(40, 1, 16000);
 464   Perform(true, 2);
 465 }
 466
 467 // Stereo input, stereo primary WB 40 ms frame.
 468 TEST_F(DualStreamTest,
 469        DISABLED_ON_ANDROID(BitExactSyncStereoInputStereoPrimaryWb40Ms)) {
 470   InitializeSender(40, 2, 16000);
 471   Perform(true, 2);
 472 }
 473
 474 // Asynchronous test, ACM is fed with data then secondary coder is registered.
 475 // Mono input, mono primary WB 20 ms frame.
 476 TEST_F(DualStreamTest,
 477        DISABLED_ON_ANDROID(BitExactAsyncMonoInputMonoPrimaryWb20Ms)) {
 478   InitializeSender(20, 1, 16000);
 479   Perform(false, 1);
 480 }
 481
 482 // Mono input, mono primary WB 20 ms frame.
 483 TEST_F(DualStreamTest,
 484        DISABLED_ON_ANDROID(BitExactAsyncMonoInputMonoPrimaryWb40Ms)) {
 485   InitializeSender(40, 1, 16000);
 486   Perform(false, 1);
 487 }
 488
 489 TEST_F(DualStreamTest, DISABLED_ON_ANDROID(Api)) {
 490   PopulateCodecInstances(20, 1, 16000);
 491   CodecInst my_codec;
 492   ASSERT_EQ(0, acm_dual_stream_->InitializeSender());
 493   ASSERT_EQ(-1, acm_dual_stream_->SecondarySendCodec(&my_codec));
 494
 495   // Not allowed to register secondary codec if primary is not registered yet.
 496   ASSERT_EQ(-1,
 497       acm_dual_stream_->RegisterSecondarySendCodec(secondary_encoder_));
 498   ASSERT_EQ(-1, acm_dual_stream_->SecondarySendCodec(&my_codec));
 499
 500   ASSERT_EQ(0, acm_dual_stream_->RegisterSendCodec(primary_encoder_));
 501
 502   ASSERT_EQ(0, acm_dual_stream_->SetVAD(true, true, VADNormal));
 503
 504   // Make sure vad is activated.
 505   bool vad_status;
 506   bool dtx_status;
 507   ACMVADMode vad_mode;
 508   EXPECT_EQ(0, acm_dual_stream_->VAD(&vad_status, &dtx_status, &vad_mode));
 509   EXPECT_TRUE(vad_status);
 510   EXPECT_TRUE(dtx_status);
 511   EXPECT_EQ(VADNormal, vad_mode);
 512
 513   ASSERT_EQ(0,
 514       acm_dual_stream_->RegisterSecondarySendCodec(secondary_encoder_));
 515
 516   ASSERT_EQ(0, acm_dual_stream_->SecondarySendCodec(&my_codec));
 517   ASSERT_EQ(0, memcmp(&my_codec, &secondary_encoder_, sizeof(my_codec)));
 518
 519   // Test if VAD get disabled after registering secondary codec.
 520   EXPECT_EQ(0, acm_dual_stream_->VAD(&vad_status, &dtx_status, &vad_mode));
 521   EXPECT_FALSE(vad_status);
 522   EXPECT_FALSE(dtx_status);
 523
 524   // Activating VAD should fail.
 525   ASSERT_EQ(-1, acm_dual_stream_->SetVAD(true, true, VADNormal));
 526
 527   // Unregister secondary encoder and it should be possible to activate VAD.
 528   acm_dual_stream_->UnregisterSecondarySendCodec();
 529   // Should fail.
 530   ASSERT_EQ(-1, acm_dual_stream_->SecondarySendCodec(&my_codec));
 531
 532   ASSERT_EQ(0, acm_dual_stream_->SetVAD(true, true, VADVeryAggr));
 533   // Make sure VAD is activated.
 534   EXPECT_EQ(0, acm_dual_stream_->VAD(&vad_status, &dtx_status, &vad_mode));
 535   EXPECT_TRUE(vad_status);
 536   EXPECT_TRUE(dtx_status);
 537   EXPECT_EQ(VADVeryAggr, vad_mode);
 538 }
 539
 540 }  // namespace webrtc