Home | History | Annotate | Download | only in test 
      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 "TwoWayCommunication.h"
     12 
     13 #include <ctype.h>
     14 #include <stdio.h>
     15 #include <string.h>
     16 
     17 #ifdef WIN32
     18 #include <Windows.h>
     19 #endif
     20 
     21 #include "testing/gtest/include/gtest/gtest.h"
     22 #include "webrtc/engine_configurations.h"
     23 #include "webrtc/common_types.h"
     24 #include "webrtc/modules/audio_coding/main/test/PCMFile.h"
     25 #include "webrtc/modules/audio_coding/main/test/utility.h"
     26 #include "webrtc/system_wrappers/interface/trace.h"
     27 #include "webrtc/test/testsupport/fileutils.h"
     28 
     29 namespace webrtc {
     30 
     31 #define MAX_FILE_NAME_LENGTH_BYTE 500
     32 
     33 TwoWayCommunication::TwoWayCommunication(int testMode)
     34     : _acmA(AudioCodingModule::Create(1)),
     35       _acmB(AudioCodingModule::Create(2)),
     36       _acmRefA(AudioCodingModule::Create(3)),
     37       _acmRefB(AudioCodingModule::Create(4)),
     38       _testMode(testMode) {}
     39 
     40 TwoWayCommunication::~TwoWayCommunication() {
     41   delete _channel_A2B;
     42   delete _channel_B2A;
     43   delete _channelRef_A2B;
     44   delete _channelRef_B2A;
     45 #ifdef WEBRTC_DTMF_DETECTION
     46   if (_dtmfDetectorA != NULL) {
     47     delete _dtmfDetectorA;
     48   }
     49   if (_dtmfDetectorB != NULL) {
     50     delete _dtmfDetectorB;
     51   }
     52 #endif
     53   _inFileA.Close();
     54   _inFileB.Close();
     55   _outFileA.Close();
     56   _outFileB.Close();
     57   _outFileRefA.Close();
     58   _outFileRefB.Close();
     59 }
     60 
     61 void TwoWayCommunication::ChooseCodec(uint8_t* codecID_A,
     62                                       uint8_t* codecID_B) {
     63   scoped_ptr<AudioCodingModule> tmpACM(AudioCodingModule::Create(0));
     64   uint8_t noCodec = tmpACM->NumberOfCodecs();
     65   CodecInst codecInst;
     66   printf("List of Supported Codecs\n");
     67   printf("========================\n");
     68   for (uint8_t codecCntr = 0; codecCntr < noCodec; codecCntr++) {
     69     EXPECT_EQ(tmpACM->Codec(codecCntr, &codecInst), 0);
     70     printf("%d- %s\n", codecCntr, codecInst.plname);
     71   }
     72   printf("\nChoose a send codec for side A [0]: ");
     73   char myStr[15] = "";
     74   EXPECT_TRUE(fgets(myStr, 10, stdin) != NULL);
     75   *codecID_A = (uint8_t) atoi(myStr);
     76 
     77   printf("\nChoose a send codec for side B [0]: ");
     78   EXPECT_TRUE(fgets(myStr, 10, stdin) != NULL);
     79   *codecID_B = (uint8_t) atoi(myStr);
     80 
     81   printf("\n");
     82 }
     83 
     84 void TwoWayCommunication::SetUp() {
     85   uint8_t codecID_A;
     86   uint8_t codecID_B;
     87 
     88   ChooseCodec(&codecID_A, &codecID_B);
     89   CodecInst codecInst_A;
     90   CodecInst codecInst_B;
     91   CodecInst dummyCodec;
     92   EXPECT_EQ(0, _acmA->Codec(codecID_A, &codecInst_A));
     93   EXPECT_EQ(0, _acmB->Codec(codecID_B, &codecInst_B));
     94   EXPECT_EQ(0, _acmA->Codec(6, &dummyCodec));
     95 
     96   //--- Set A codecs
     97   EXPECT_EQ(0, _acmA->RegisterSendCodec(codecInst_A));
     98   EXPECT_EQ(0, _acmA->RegisterReceiveCodec(codecInst_B));
     99 #ifdef WEBRTC_DTMF_DETECTION
    100   _dtmfDetectorA = new(DTMFDetector);
    101   EXPECT_GT(_acmA->RegisterIncomingMessagesCallback(_dtmfDetectorA, ACMUSA),
    102             -1);
    103 #endif
    104   //--- Set ref-A codecs
    105   EXPECT_EQ(0, _acmRefA->RegisterSendCodec(codecInst_A));
    106   EXPECT_EQ(0, _acmRefA->RegisterReceiveCodec(codecInst_B));
    107 
    108   //--- Set B codecs
    109   EXPECT_EQ(0, _acmB->RegisterSendCodec(codecInst_B));
    110   EXPECT_EQ(0, _acmB->RegisterReceiveCodec(codecInst_A));
    111 #ifdef WEBRTC_DTMF_DETECTION
    112   _dtmfDetectorB = new(DTMFDetector);
    113   EXPECT_GT(_acmB->RegisterIncomingMessagesCallback(_dtmfDetectorB, ACMUSA),
    114             -1);
    115 #endif
    116 
    117   //--- Set ref-B codecs
    118   EXPECT_EQ(0, _acmRefB->RegisterSendCodec(codecInst_B));
    119   EXPECT_EQ(0, _acmRefB->RegisterReceiveCodec(codecInst_A));
    120 
    121   uint16_t frequencyHz;
    122 
    123   //--- Input A
    124   std::string in_file_name = webrtc::test::ResourcePath(
    125       "audio_coding/testfile32kHz", "pcm");
    126   frequencyHz = 32000;
    127   printf("Enter input file at side A [%s]: ", in_file_name.c_str());
    128   PCMFile::ChooseFile(&in_file_name, 499, &frequencyHz);
    129   _inFileA.Open(in_file_name, frequencyHz, "rb");
    130 
    131   //--- Output A
    132   std::string out_file_a = webrtc::test::OutputPath() + "outA.pcm";
    133   printf("Output file at side A: %s\n", out_file_a.c_str());
    134   printf("Sampling frequency (in Hz) of the above file: %u\n", frequencyHz);
    135   _outFileA.Open(out_file_a, frequencyHz, "wb");
    136   std::string ref_file_name = webrtc::test::OutputPath() + "ref_outA.pcm";
    137   _outFileRefA.Open(ref_file_name, frequencyHz, "wb");
    138 
    139   //--- Input B
    140   in_file_name = webrtc::test::ResourcePath("audio_coding/testfile32kHz",
    141                                             "pcm");
    142   frequencyHz = 32000;
    143   printf("\n\nEnter input file at side B [%s]: ", in_file_name.c_str());
    144   PCMFile::ChooseFile(&in_file_name, 499, &frequencyHz);
    145   _inFileB.Open(in_file_name, frequencyHz, "rb");
    146 
    147   //--- Output B
    148   std::string out_file_b = webrtc::test::OutputPath() + "outB.pcm";
    149   printf("Output file at side B: %s\n", out_file_b.c_str());
    150   printf("Sampling frequency (in Hz) of the above file: %u\n", frequencyHz);
    151   _outFileB.Open(out_file_b, frequencyHz, "wb");
    152   ref_file_name = webrtc::test::OutputPath() + "ref_outB.pcm";
    153   _outFileRefB.Open(ref_file_name, frequencyHz, "wb");
    154 
    155   //--- Set A-to-B channel
    156   _channel_A2B = new Channel;
    157   _acmA->RegisterTransportCallback(_channel_A2B);
    158   _channel_A2B->RegisterReceiverACM(_acmB.get());
    159   //--- Do the same for the reference
    160   _channelRef_A2B = new Channel;
    161   _acmRefA->RegisterTransportCallback(_channelRef_A2B);
    162   _channelRef_A2B->RegisterReceiverACM(_acmRefB.get());
    163 
    164   //--- Set B-to-A channel
    165   _channel_B2A = new Channel;
    166   _acmB->RegisterTransportCallback(_channel_B2A);
    167   _channel_B2A->RegisterReceiverACM(_acmA.get());
    168   //--- Do the same for reference
    169   _channelRef_B2A = new Channel;
    170   _acmRefB->RegisterTransportCallback(_channelRef_B2A);
    171   _channelRef_B2A->RegisterReceiverACM(_acmRefA.get());
    172 
    173   // The clicks will be more obvious when we
    174   // are in FAX mode.
    175   EXPECT_EQ(_acmB->SetPlayoutMode(fax), 0);
    176   EXPECT_EQ(_acmRefB->SetPlayoutMode(fax), 0);
    177 }
    178 
    179 void TwoWayCommunication::SetUpAutotest() {
    180   CodecInst codecInst_A;
    181   CodecInst codecInst_B;
    182   CodecInst dummyCodec;
    183 
    184   EXPECT_EQ(0, _acmA->Codec("ISAC", &codecInst_A, 16000, 1));
    185   EXPECT_EQ(0, _acmB->Codec("L16", &codecInst_B, 8000, 1));
    186   EXPECT_EQ(0, _acmA->Codec(6, &dummyCodec));
    187 
    188   //--- Set A codecs
    189   EXPECT_EQ(0, _acmA->RegisterSendCodec(codecInst_A));
    190   EXPECT_EQ(0, _acmA->RegisterReceiveCodec(codecInst_B));
    191 #ifdef WEBRTC_DTMF_DETECTION
    192   _dtmfDetectorA = new(DTMFDetector);
    193   EXPECT_EQ(0, _acmA->RegisterIncomingMessagesCallback(_dtmfDetectorA, ACMUSA));
    194 #endif
    195 
    196   //--- Set ref-A codecs
    197   EXPECT_GT(_acmRefA->RegisterSendCodec(codecInst_A), -1);
    198   EXPECT_GT(_acmRefA->RegisterReceiveCodec(codecInst_B), -1);
    199 
    200   //--- Set B codecs
    201   EXPECT_GT(_acmB->RegisterSendCodec(codecInst_B), -1);
    202   EXPECT_GT(_acmB->RegisterReceiveCodec(codecInst_A), -1);
    203 #ifdef WEBRTC_DTMF_DETECTION
    204   _dtmfDetectorB = new(DTMFDetector);
    205   EXPECT_EQ(0, _acmB->RegisterIncomingMessagesCallback(_dtmfDetectorB, ACMUSA));
    206 #endif
    207 
    208   //--- Set ref-B codecs
    209   EXPECT_EQ(0, _acmRefB->RegisterSendCodec(codecInst_B));
    210   EXPECT_EQ(0, _acmRefB->RegisterReceiveCodec(codecInst_A));
    211 
    212   uint16_t frequencyHz;
    213 
    214   //--- Input A and B
    215   std::string in_file_name = webrtc::test::ResourcePath(
    216       "audio_coding/testfile32kHz", "pcm");
    217   frequencyHz = 16000;
    218   _inFileA.Open(in_file_name, frequencyHz, "rb");
    219   _inFileB.Open(in_file_name, frequencyHz, "rb");
    220 
    221   //--- Output A
    222   std::string output_file_a = webrtc::test::OutputPath() + "outAutotestA.pcm";
    223   frequencyHz = 16000;
    224   _outFileA.Open(output_file_a, frequencyHz, "wb");
    225   std::string output_ref_file_a = webrtc::test::OutputPath()
    226       + "ref_outAutotestA.pcm";
    227   _outFileRefA.Open(output_ref_file_a, frequencyHz, "wb");
    228 
    229   //--- Output B
    230   std::string output_file_b = webrtc::test::OutputPath() + "outAutotestB.pcm";
    231   frequencyHz = 16000;
    232   _outFileB.Open(output_file_b, frequencyHz, "wb");
    233   std::string output_ref_file_b = webrtc::test::OutputPath()
    234       + "ref_outAutotestB.pcm";
    235   _outFileRefB.Open(output_ref_file_b, frequencyHz, "wb");
    236 
    237   //--- Set A-to-B channel
    238   _channel_A2B = new Channel;
    239   _acmA->RegisterTransportCallback(_channel_A2B);
    240   _channel_A2B->RegisterReceiverACM(_acmB.get());
    241   //--- Do the same for the reference
    242   _channelRef_A2B = new Channel;
    243   _acmRefA->RegisterTransportCallback(_channelRef_A2B);
    244   _channelRef_A2B->RegisterReceiverACM(_acmRefB.get());
    245 
    246   //--- Set B-to-A channel
    247   _channel_B2A = new Channel;
    248   _acmB->RegisterTransportCallback(_channel_B2A);
    249   _channel_B2A->RegisterReceiverACM(_acmA.get());
    250   //--- Do the same for reference
    251   _channelRef_B2A = new Channel;
    252   _acmRefB->RegisterTransportCallback(_channelRef_B2A);
    253   _channelRef_B2A->RegisterReceiverACM(_acmRefA.get());
    254 
    255   // The clicks will be more obvious when we
    256   // are in FAX mode.
    257   EXPECT_EQ(0, _acmB->SetPlayoutMode(fax));
    258   EXPECT_EQ(0, _acmRefB->SetPlayoutMode(fax));
    259 }
    260 
    261 void TwoWayCommunication::Perform() {
    262   if (_testMode == 0) {
    263     SetUpAutotest();
    264   } else {
    265     SetUp();
    266   }
    267   unsigned int msecPassed = 0;
    268   unsigned int secPassed = 0;
    269 
    270   int32_t outFreqHzA = _outFileA.SamplingFrequency();
    271   int32_t outFreqHzB = _outFileB.SamplingFrequency();
    272 
    273   AudioFrame audioFrame;
    274 
    275   CodecInst codecInst_B;
    276   CodecInst dummy;
    277 
    278   EXPECT_EQ(0, _acmB->SendCodec(&codecInst_B));
    279 
    280   // In the following loop we tests that the code can handle misuse of the APIs.
    281   // In the middle of a session with data flowing between two sides, called A
    282   // and B, APIs will be called, like ResetEncoder(), and the code should
    283   // continue to run, and be able to recover.
    284   bool expect_error_add = false;
    285   bool expect_error_process = false;
    286   while (!_inFileA.EndOfFile() && !_inFileB.EndOfFile()) {
    287     msecPassed += 10;
    288     EXPECT_GT(_inFileA.Read10MsData(audioFrame), 0);
    289     EXPECT_EQ(0, _acmA->Add10MsData(audioFrame));
    290     EXPECT_EQ(0, _acmRefA->Add10MsData(audioFrame));
    291 
    292     EXPECT_GT(_inFileB.Read10MsData(audioFrame), 0);
    293 
    294     // Expect call to pass except for the time when no send codec is registered.
    295     if (!expect_error_add) {
    296       EXPECT_EQ(0, _acmB->Add10MsData(audioFrame));
    297     } else {
    298       EXPECT_EQ(-1, _acmB->Add10MsData(audioFrame));
    299     }
    300     // Expect to pass except for the time when there either is no send codec
    301     // registered, or no receive codec.
    302     if (!expect_error_process) {
    303       EXPECT_GT(_acmB->Process(), -1);
    304     } else {
    305       EXPECT_EQ(_acmB->Process(), -1);
    306     }
    307     EXPECT_EQ(0, _acmRefB->Add10MsData(audioFrame));
    308     EXPECT_GT(_acmA->Process(), -1);
    309     EXPECT_GT(_acmRefA->Process(), -1);
    310     EXPECT_GT(_acmRefB->Process(), -1);
    311     EXPECT_EQ(0, _acmA->PlayoutData10Ms(outFreqHzA, &audioFrame));
    312     _outFileA.Write10MsData(audioFrame);
    313     EXPECT_EQ(0, _acmRefA->PlayoutData10Ms(outFreqHzA, &audioFrame));
    314     _outFileRefA.Write10MsData(audioFrame);
    315     EXPECT_EQ(0, _acmB->PlayoutData10Ms(outFreqHzB, &audioFrame));
    316     _outFileB.Write10MsData(audioFrame);
    317     EXPECT_EQ(0, _acmRefB->PlayoutData10Ms(outFreqHzB, &audioFrame));
    318     _outFileRefB.Write10MsData(audioFrame);
    319 
    320     // Update time counters each time a second of data has passed.
    321     if (msecPassed >= 1000) {
    322       msecPassed = 0;
    323       secPassed++;
    324     }
    325     // Call RestEncoder for ACM on side A, and InitializeSender for ACM on
    326     // side B.
    327     if (((secPassed % 5) == 4) && (msecPassed == 0)) {
    328       EXPECT_EQ(0, _acmA->ResetEncoder());
    329       EXPECT_EQ(0, _acmB->InitializeSender());
    330       expect_error_add = true;
    331       expect_error_process = true;
    332     }
    333     // Re-register send codec on side B.
    334     if (((secPassed % 5) == 4) && (msecPassed >= 990)) {
    335       EXPECT_EQ(0, _acmB->RegisterSendCodec(codecInst_B));
    336       EXPECT_EQ(0, _acmB->SendCodec(&dummy));
    337       expect_error_add = false;
    338       expect_error_process = false;
    339     }
    340     // Reset decoder on side B, and initialize receiver on side A.
    341     if (((secPassed % 7) == 6) && (msecPassed == 0)) {
    342       EXPECT_EQ(0, _acmB->ResetDecoder());
    343       EXPECT_EQ(0, _acmA->InitializeReceiver());
    344     }
    345     // Re-register codec on side A.
    346     if (((secPassed % 7) == 6) && (msecPassed >= 990)) {
    347       EXPECT_EQ(0, _acmA->RegisterReceiveCodec(codecInst_B));
    348     }
    349   }
    350 }
    351 
    352 }  // namespace webrtc
    353