src/third_party/webrtc/modules/audio_processing/test/test_utils.h

   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 <limits>
  12
  13 #include "webrtc/audio_processing/debug.pb.h"
  14 #include "webrtc/common_audio/include/audio_util.h"
  15 #include "webrtc/common_audio/wav_writer.h"
  16 #include "webrtc/modules/audio_processing/common.h"
  17 #include "webrtc/modules/audio_processing/include/audio_processing.h"
  18 #include "webrtc/modules/interface/module_common_types.h"
  19 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
  20
  21 namespace webrtc {
  22
  23 static const AudioProcessing::Error kNoErr = AudioProcessing::kNoError;
  24 #define EXPECT_NOERR(expr) EXPECT_EQ(kNoErr, (expr))
  25
  26 class RawFile {
  27  public:
  28   RawFile(const std::string& filename)
  29       : file_handle_(fopen(filename.c_str(), "wb")) {}
  30
  31   ~RawFile() {
  32     fclose(file_handle_);
  33   }
  34
  35   void WriteSamples(const int16_t* samples, size_t num_samples) {
  36 #ifndef WEBRTC_ARCH_LITTLE_ENDIAN
  37 #error "Need to convert samples to little-endian when writing to PCM file"
  38 #endif
  39     fwrite(samples, sizeof(*samples), num_samples, file_handle_);
  40   }
  41
  42   void WriteSamples(const float* samples, size_t num_samples) {
  43     fwrite(samples, sizeof(*samples), num_samples, file_handle_);
  44   }
  45
  46  private:
  47   FILE* file_handle_;
  48 };
  49
  50 static inline void WriteIntData(const int16_t* data,
  51                                 size_t length,
  52                                 WavFile* wav_file,
  53                                 RawFile* raw_file) {
  54   if (wav_file) {
  55     wav_file->WriteSamples(data, length);
  56   }
  57   if (raw_file) {
  58     raw_file->WriteSamples(data, length);
  59   }
  60 }
  61
  62 static inline void WriteFloatData(const float* const* data,
  63                                   size_t samples_per_channel,
  64                                   int num_channels,
  65                                   WavFile* wav_file,
  66                                   RawFile* raw_file) {
  67   size_t length = num_channels * samples_per_channel;
  68   scoped_ptr<float[]> buffer(new float[length]);
  69   Interleave(data, samples_per_channel, num_channels, buffer.get());
  70   if (raw_file) {
  71     raw_file->WriteSamples(buffer.get(), length);
  72   }
  73   // TODO(aluebs): Use ScaleToInt16Range() from audio_util
  74   for (size_t i = 0; i < length; ++i) {
  75     buffer[i] = buffer[i] > 0 ?
  76                 buffer[i] * std::numeric_limits<int16_t>::max() :
  77                 -buffer[i] * std::numeric_limits<int16_t>::min();
  78   }
  79   if (wav_file) {
  80     wav_file->WriteSamples(buffer.get(), length);
  81   }
  82 }
  83
  84 // Exits on failure; do not use in unit tests.
  85 static inline FILE* OpenFile(const std::string& filename, const char* mode) {
  86   FILE* file = fopen(filename.c_str(), mode);
  87   if (!file) {
  88     printf("Unable to open file %s\n", filename.c_str());
  89     exit(1);
  90   }
  91   return file;
  92 }
  93
  94 static inline int SamplesFromRate(int rate) {
  95   return AudioProcessing::kChunkSizeMs * rate / 1000;
  96 }
  97
  98 static inline void SetFrameSampleRate(AudioFrame* frame,
  99                                       int sample_rate_hz) {
 100   frame->sample_rate_hz_ = sample_rate_hz;
 101   frame->samples_per_channel_ = AudioProcessing::kChunkSizeMs *
 102       sample_rate_hz / 1000;
 103 }
 104
 105 template <typename T>
 106 void SetContainerFormat(int sample_rate_hz,
 107                         int num_channels,
 108                         AudioFrame* frame,
 109                         scoped_ptr<ChannelBuffer<T> >* cb) {
 110   SetFrameSampleRate(frame, sample_rate_hz);
 111   frame->num_channels_ = num_channels;
 112   cb->reset(new ChannelBuffer<T>(frame->samples_per_channel_, num_channels));
 113 }
 114
 115 static inline AudioProcessing::ChannelLayout LayoutFromChannels(
 116     int num_channels) {
 117   switch (num_channels) {
 118     case 1:
 119       return AudioProcessing::kMono;
 120     case 2:
 121       return AudioProcessing::kStereo;
 122     default:
 123       assert(false);
 124       return AudioProcessing::kMono;
 125   }
 126 }
 127
 128 // Allocates new memory in the scoped_ptr to fit the raw message and returns the
 129 // number of bytes read.
 130 static inline size_t ReadMessageBytesFromFile(FILE* file,
 131                                               scoped_ptr<uint8_t[]>* bytes) {
 132   // The "wire format" for the size is little-endian. Assume we're running on
 133   // a little-endian machine.
 134   int32_t size = 0;
 135   if (fread(&size, sizeof(size), 1, file) != 1)
 136     return 0;
 137   if (size <= 0)
 138     return 0;
 139
 140   bytes->reset(new uint8_t[size]);
 141   return fread(bytes->get(), sizeof((*bytes)[0]), size, file);
 142 }
 143
 144 // Returns true on success, false on error or end-of-file.
 145 static inline bool ReadMessageFromFile(FILE* file,
 146                                        ::google::protobuf::MessageLite* msg) {
 147   scoped_ptr<uint8_t[]> bytes;
 148   size_t size = ReadMessageBytesFromFile(file, &bytes);
 149   if (!size)
 150     return false;
 151
 152   msg->Clear();
 153   return msg->ParseFromArray(bytes.get(), size);
 154 }
 155
 156 }  // namespace webrtc