Add tests and modify tools for new float deinterleaved interface.
- Add an Initialize() overload to allow specification of format
parameters. This is mainly useful for testing, but could be used in
the cases where a consumer knows the format before the streams arrive.
- Add a reverse_sample_rate_hz_ parameter to prepare for mismatched
capture and render rates. There is no functional change as it is
currently constrained to match the capture rate.
- Fix a bug in the float dump: we need to use add_ rather than set_.
- Add a debug dump test for both int and float interfaces.
- Enable unpacking of float dumps.
- Enable audioproc to read float dumps.
- Move more shared functionality to test_utils.h, and generally tidy up
a bit by consolidating repeated code.
BUG=2894
TESTED=Verified that the output produced by the float debug dump test is
correct. Processed the resulting debug dump file with audioproc and
ensured that we get identical output. (This is crucial, as we need to
be able to exactly reproduce online results offline.)
R=aluebs@webrtc.org
Review URL: https://webrtc-codereview.appspot.com/9489004
git-svn-id: http://webrtc.googlecode.com/svn/trunk@5676 4adac7df-926f-26a2-2b94-8c16560cd09d
diff --git a/webrtc/modules/audio_processing/test/test_utils.h b/webrtc/modules/audio_processing/test/test_utils.h
index 452d843..c55b53e 100644
--- a/webrtc/modules/audio_processing/test/test_utils.h
+++ b/webrtc/modules/audio_processing/test/test_utils.h
@@ -8,14 +8,112 @@
* be found in the AUTHORS file in the root of the source tree.
*/
+#include "webrtc/audio_processing/debug.pb.h"
#include "webrtc/modules/audio_processing/include/audio_processing.h"
#include "webrtc/modules/interface/module_common_types.h"
+#include "webrtc/system_wrappers/interface/scoped_ptr.h"
+
+namespace webrtc {
+
+static const AudioProcessing::Error kNoErr = AudioProcessing::kNoError;
+#define EXPECT_NOERR(expr) EXPECT_EQ(kNoErr, (expr))
static const int kChunkSizeMs = 10;
-static const webrtc::AudioProcessing::Error kNoErr =
- webrtc::AudioProcessing::kNoError;
-static void SetFrameSampleRate(webrtc::AudioFrame* frame, int sample_rate_hz) {
+// Helper to encapsulate a contiguous data buffer with access to a pointer
+// array of the deinterleaved channels.
+template <typename T>
+class ChannelBuffer {
+ public:
+ ChannelBuffer(int samples_per_channel, int num_channels)
+ : data_(new T[samples_per_channel * num_channels]),
+ channels_(new T*[num_channels]),
+ samples_per_channel_(samples_per_channel) {
+ memset(data_.get(), 0, sizeof(T) * samples_per_channel * num_channels);
+ for (int i = 0; i < num_channels; ++i)
+ channels_[i] = &data_[i * samples_per_channel];
+ }
+ ~ChannelBuffer() {}
+
+ void CopyFrom(const void* channel_ptr, int index) {
+ memcpy(channels_[index], channel_ptr, samples_per_channel_ * sizeof(T));
+ }
+
+ T* data() { return data_.get(); }
+ T* channel(int index) { return channels_[index]; }
+ T** channels() { return channels_.get(); }
+
+ private:
+ scoped_ptr<T[]> data_;
+ scoped_ptr<T*[]> channels_;
+ int samples_per_channel_;
+};
+
+// Exits on failure; do not use in unit tests.
+static inline FILE* OpenFile(const std::string& filename, const char* mode) {
+ FILE* file = fopen(filename.c_str(), mode);
+ if (!file) {
+ printf("Unable to open file %s\n", filename.c_str());
+ exit(1);
+ }
+ return file;
+}
+
+static inline void SetFrameSampleRate(AudioFrame* frame,
+ int sample_rate_hz) {
frame->sample_rate_hz_ = sample_rate_hz;
frame->samples_per_channel_ = kChunkSizeMs * sample_rate_hz / 1000;
}
+
+template <typename T>
+void SetContainerFormat(int sample_rate_hz,
+ int num_channels,
+ AudioFrame* frame,
+ scoped_ptr<ChannelBuffer<T> >* cb) {
+ SetFrameSampleRate(frame, sample_rate_hz);
+ frame->num_channels_ = num_channels;
+ cb->reset(new ChannelBuffer<T>(frame->samples_per_channel_, num_channels));
+}
+
+static inline AudioProcessing::ChannelLayout LayoutFromChannels(
+ int num_channels) {
+ switch (num_channels) {
+ case 1:
+ return AudioProcessing::kMono;
+ case 2:
+ return AudioProcessing::kStereo;
+ default:
+ assert(false);
+ return AudioProcessing::kMono;
+ }
+}
+
+// Allocates new memory in the scoped_ptr to fit the raw message and returns the
+// number of bytes read.
+static inline size_t ReadMessageBytesFromFile(FILE* file,
+ scoped_ptr<uint8_t[]>* bytes) {
+ // The "wire format" for the size is little-endian. Assume we're running on
+ // a little-endian machine.
+ int32_t size = 0;
+ if (fread(&size, sizeof(size), 1, file) != 1)
+ return 0;
+ if (size <= 0)
+ return 0;
+
+ bytes->reset(new uint8_t[size]);
+ return fread(bytes->get(), sizeof((*bytes)[0]), size, file);
+}
+
+// Returns true on success, false on error or end-of-file.
+static inline bool ReadMessageFromFile(FILE* file,
+ ::google::protobuf::MessageLite* msg) {
+ scoped_ptr<uint8_t[]> bytes;
+ size_t size = ReadMessageBytesFromFile(file, &bytes);
+ if (!size)
+ return false;
+
+ msg->Clear();
+ return msg->ParseFromArray(bytes.get(), size);
+}
+
+} // namespace webrtc