src/third_party/webrtc/modules/audio_coding/neteq4/tools/neteq_quality_test.cc

   1 /*
   2  *  Copyright (c) 2014 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 <stdio.h>
  12 #include "webrtc/modules/audio_coding/neteq4/tools/neteq_quality_test.h"
  13
  14 namespace webrtc {
  15 namespace test {
  16
  17 const uint8_t kPayloadType = 95;
  18 const int kOutputSizeMs = 10;
  19
  20 NetEqQualityTest::NetEqQualityTest(int block_duration_ms,
  21                                    int in_sampling_khz,
  22                                    int out_sampling_khz,
  23                                    enum NetEqDecoder decoder_type,
  24                                    int channels,
  25                                    double drift_factor,
  26                                    std::string in_filename,
  27                                    std::string out_filename)
  28     : decoded_time_ms_(0),
  29       decodable_time_ms_(0),
  30       drift_factor_(drift_factor),
  31       block_duration_ms_(block_duration_ms),
  32       in_sampling_khz_(in_sampling_khz),
  33       out_sampling_khz_(out_sampling_khz),
  34       decoder_type_(decoder_type),
  35       channels_(channels),
  36       in_filename_(in_filename),
  37       out_filename_(out_filename),
  38       in_size_samples_(in_sampling_khz_ * block_duration_ms_),
  39       out_size_samples_(out_sampling_khz_ * kOutputSizeMs),
  40       payload_size_bytes_(0),
  41       max_payload_bytes_(0),
  42       in_file_(new InputAudioFile(in_filename_)),
  43       out_file_(NULL),
  44       rtp_generator_(new RtpGenerator(in_sampling_khz_, 0, 0,
  45                                       decodable_time_ms_)) {
  46   NetEq::Config config;
  47   config.sample_rate_hz = out_sampling_khz_ * 1000;
  48   neteq_.reset(NetEq::Create(config));
  49   max_payload_bytes_ = in_size_samples_ * channels_ * sizeof(int16_t);
  50   in_data_.reset(new int16_t[in_size_samples_ * channels_]);
  51   payload_.reset(new uint8_t[max_payload_bytes_]);
  52   out_data_.reset(new int16_t[out_size_samples_ * channels_]);
  53 }
  54
  55 void NetEqQualityTest::SetUp() {
  56   out_file_ = fopen(out_filename_.c_str(), "wb");
  57   ASSERT_TRUE(out_file_ != NULL);
  58   ASSERT_EQ(0, neteq_->RegisterPayloadType(decoder_type_, kPayloadType));
  59   rtp_generator_->set_drift_factor(drift_factor_);
  60 }
  61
  62 void NetEqQualityTest::TearDown() {
  63   fclose(out_file_);
  64 }
  65
  66 int NetEqQualityTest::Transmit() {
  67   int packet_input_time_ms =
  68       rtp_generator_->GetRtpHeader(kPayloadType, in_size_samples_,
  69                                    &rtp_header_);
  70   if (!PacketLost(packet_input_time_ms) && payload_size_bytes_ > 0) {
  71     int ret = neteq_->InsertPacket(rtp_header_, &payload_[0],
  72                                    payload_size_bytes_,
  73                                    packet_input_time_ms * in_sampling_khz_);
  74     if (ret != NetEq::kOK)
  75       return -1;
  76   }
  77   return packet_input_time_ms;
  78 }
  79
  80 int NetEqQualityTest::DecodeBlock() {
  81   int channels;
  82   int samples;
  83   int ret = neteq_->GetAudio(out_size_samples_ * channels_, &out_data_[0],
  84                              &samples, &channels, NULL);
  85
  86   if (ret != NetEq::kOK) {
  87     return -1;
  88   } else {
  89     assert(channels == channels_);
  90     assert(samples == kOutputSizeMs * out_sampling_khz_);
  91     fwrite(&out_data_[0], sizeof(int16_t), samples * channels, out_file_);
  92     return samples;
  93   }
  94 }
  95
  96 void NetEqQualityTest::Simulate(int end_time_ms) {
  97   int audio_size_samples;
  98
  99   while (decoded_time_ms_ < end_time_ms) {
 100     while (decodable_time_ms_ - kOutputSizeMs < decoded_time_ms_) {
 101       ASSERT_TRUE(in_file_->Read(in_size_samples_ * channels_, &in_data_[0]));
 102       payload_size_bytes_ = EncodeBlock(&in_data_[0],
 103                                         in_size_samples_, &payload_[0],
 104                                         max_payload_bytes_);
 105       decodable_time_ms_ = Transmit() + block_duration_ms_;
 106     }
 107     audio_size_samples = DecodeBlock();
 108     if (audio_size_samples > 0) {
 109       decoded_time_ms_ += audio_size_samples / out_sampling_khz_;
 110     }
 111   }
 112 }
 113
 114 }  // namespace test
 115 }  // namespace webrtc