1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
|
// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef MEDIA_AUDIO_AUDIO_DEBUG_FILE_WRITER_H_
#define MEDIA_AUDIO_AUDIO_DEBUG_FILE_WRITER_H_
#include <stdint.h>
#include <memory>
#include <optional>
#include "base/containers/heap_array.h"
#include "base/files/file.h"
#include "base/memory/scoped_refptr.h"
#include "base/memory/weak_ptr.h"
#include "base/task/sequenced_task_runner.h"
#include "base/task/thread_pool.h"
#include "media/base/audio_parameters.h"
#include "media/base/media_export.h"
namespace media {
class AudioBus;
class AudioBusPool;
// Writes audio data to a 16 bit PCM WAVE file used for debugging purposes.
// Functions are virtual for the purpose of test mocking. This class can be
// created and used anywhere, but must be destroyed using the
// OnTaskRunnerDeleter provided by Create(). It starts writing on Create(), and
// stops writing on destruction.
class MEDIA_EXPORT AudioDebugFileWriter {
public:
AudioDebugFileWriter(const AudioDebugFileWriter&) = delete;
AudioDebugFileWriter& operator=(const AudioDebugFileWriter&) = delete;
virtual ~AudioDebugFileWriter();
// Write |data| to file.
virtual void Write(const AudioBus& data);
using Ptr = std::unique_ptr<AudioDebugFileWriter, base::OnTaskRunnerDeleter>;
// Number of channels and sample rate are used from |params|, the other
// parameters are ignored. The number of channels in the data passed to
// Write() must match |params|. Write() must be called on the sequence that
// task_runner belongs to.
static Ptr Create(const AudioParameters& params, base::File file);
protected:
// Protected for testing.
AudioDebugFileWriter(const AudioParameters& params,
base::File file,
std::unique_ptr<AudioBusPool> audio_bus_pool);
// Create with a custom AudioBusPool.
static Ptr Create(const AudioParameters& params,
base::File file,
std::unique_ptr<AudioBusPool> audio_bus_pool);
const AudioParameters params_;
const scoped_refptr<base::SequencedTaskRunner> task_runner_ =
base::ThreadPool::CreateSequencedTaskRunner(
{base::MayBlock(), base::TaskPriority::BEST_EFFORT,
base::TaskShutdownBehavior::BLOCK_SHUTDOWN});
private:
// Write wave header to file. Called twice: on Create() the size of the wave
// data is unknown, so the header is written with zero sizes; then on
// destruction it is re-written with the actual size info accumulated
// throughout the object lifetime.
void WriteHeader();
void DoWrite(std::unique_ptr<AudioBus> data);
// The file to write to.
base::File file_;
// Number of written samples.
uint64_t samples_ = 0;
// Intermediate buffer to be written to file. Interleaved 16 bit audio data.
std::optional<base::HeapArray<int16_t>> interleaved_data_;
// Stores AudioBuses to be reused.
const std::unique_ptr<AudioBusPool> audio_bus_pool_;
// The number of AudioBuses that should be preallocated on creation.
static constexpr size_t kPreallocatedAudioBuses = 100;
// The maximum number of AudioBuses we should cache at once.
static constexpr size_t kMaxCachedAudioBuses = 500;
base::WeakPtr<AudioDebugFileWriter> weak_this_;
base::WeakPtrFactory<AudioDebugFileWriter> weak_factory_{this};
};
} // namespace media
#endif // MEDIA_AUDIO_AUDIO_DEBUG_FILE_WRITER_H_
|
