Audio output debug recording.

media/audio/audio_debug_file_writer.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/audio/audio_debug_file_writer.h"
 
 #include <stdint.h>
 #include <array>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/sys_byteorder.h"
 #include "media/base/audio_bus.h"
+#include "media/base/audio_sample_types.h"
 
 namespace media {
 
 namespace {
 
 // Windows WAVE format header
 // Byte order: Little-endian
 // Offset Length  Content
 //  0      4     "RIFF"
 //  4      4     <file length - 8>
@@ skipping 137 matching lines @@
   void WriteHeader();
 
   void CreateRecordingFile(const base::FilePath& file_name);
 
   // The file to write to.
   base::File file_;
 
   // Number of written samples.
   uint64_t samples_;
 
-  // Input audio parameters required to build wave header.
+  // Audio parameters required to build wave header. Number of channels and
+  // sample rate are used.
   const AudioParameters params_;
 
   // Intermediate buffer to be written to file. Interleaved 16 bit audio data.
   std::unique_ptr<int16_t[]> interleaved_data_;
   int interleaved_data_size_;
 
   // The task runner this class operates on.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 };
 
@@ skipping 39 matching lines @@
                  base::Unretained(file_writer.get()), file_name));
   return file_writer;
 }
 
 AudioDebugFileWriter::AudioFileWriter::AudioFileWriter(
     const AudioParameters& params,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : samples_(0),
       params_(params),
       interleaved_data_size_(0),
-      task_runner_(std::move(task_runner)) {
-  DCHECK_EQ(params.bits_per_sample(), kBytesPerSample * 8);
-}
+      task_runner_(std::move(task_runner)) {}
 
 AudioDebugFileWriter::AudioFileWriter::~AudioFileWriter() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (file_.IsValid())
     WriteHeader();
 }
 
 void AudioDebugFileWriter::AudioFileWriter::Write(const AudioBus* data) {
   DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK_EQ(params_.channels(), data->channels());
   if (!file_.IsValid())
     return;
 
   // Convert to 16 bit audio and write to file.
   int data_size = data->frames() * data->channels();
   if (!interleaved_data_ || interleaved_data_size_ < data_size) {
     interleaved_data_.reset(new int16_t[data_size]);
     interleaved_data_size_ = data_size;
   }
   samples_ += data_size;
-  data->ToInterleaved(data->frames(), sizeof(interleaved_data_[0]),
-                      interleaved_data_.get());
+  data->ToInterleaved<media::SignedInt16SampleTypeTraits>(
+      data->frames(), interleaved_data_.get());
 
 #ifndef ARCH_CPU_LITTLE_ENDIAN
   static_assert(sizeof(interleaved_data_[0]) == sizeof(uint16_t),
                 "Only 2 bytes per channel is supported.");
   for (int i = 0; i < data_size; ++i)
     interleaved_data_[i] = base::ByteSwapToLE16(interleaved_data_[i]);
 #endif
 
   file_.WriteAtCurrentPos(reinterpret_cast<char*>(interleaved_data_.get()),
                           data_size * sizeof(interleaved_data_[0]));
@@ skipping 75 matching lines @@
 
 bool AudioDebugFileWriter::WillWrite() {
   // Note that if this is called from any place other than
   // |client_sequence_checker_| then there is a data race here, but it's fine,
   // because Write() will check for |file_writer_|. So, we are not very precise
   // here, but it's fine: we can afford missing some data or scheduling some
   // no-op writes.
   return !!file_writer_;
 }
 
+const base::FilePath::CharType* AudioDebugFileWriter::GetFileNameExtension() {
+  return FILE_PATH_LITERAL("wav");
+}
+
 }  // namspace media