blob: 65506ca8f05e144ddd4ca4eb2bdd0cce56eac103 (
plain)
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
// Copyright (c) 2013 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/base/audio_hardware_config.h"
#include <algorithm>
#include "base/logging.h"
#include "build/build_config.h"
using base::AutoLock;
using media::AudioParameters;
namespace media {
#if defined(OS_LINUX) || defined(OS_MACOSX)
#define HIGH_LATENCY_AUDIO_SUPPORT 1
#endif
#if defined(HIGH_LATENCY_AUDIO_SUPPORT)
// Taken from "Bit Twiddling Hacks"
// http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
static uint32_t RoundUpToPowerOfTwo(uint32_t v) {
v--;
v |= v >> 1;
v |= v >> 2;
v |= v >> 4;
v |= v >> 8;
v |= v >> 16;
v++;
return v;
}
#endif
AudioHardwareConfig::AudioHardwareConfig(
const AudioParameters& input_params,
const AudioParameters& output_params)
: input_params_(input_params),
output_params_(output_params) {}
AudioHardwareConfig::~AudioHardwareConfig() {}
int AudioHardwareConfig::GetOutputBufferSize() const {
AutoLock auto_lock(config_lock_);
return output_params_.frames_per_buffer();
}
int AudioHardwareConfig::GetOutputSampleRate() const {
AutoLock auto_lock(config_lock_);
return output_params_.sample_rate();
}
ChannelLayout AudioHardwareConfig::GetOutputChannelLayout() const {
AutoLock auto_lock(config_lock_);
return output_params_.channel_layout();
}
int AudioHardwareConfig::GetOutputChannels() const {
AutoLock auto_lock(config_lock_);
return output_params_.channels();
}
int AudioHardwareConfig::GetInputSampleRate() const {
AutoLock auto_lock(config_lock_);
return input_params_.sample_rate();
}
ChannelLayout AudioHardwareConfig::GetInputChannelLayout() const {
AutoLock auto_lock(config_lock_);
return input_params_.channel_layout();
}
int AudioHardwareConfig::GetInputChannels() const {
AutoLock auto_lock(config_lock_);
return input_params_.channels();
}
media::AudioParameters
AudioHardwareConfig::GetInputConfig() const {
AutoLock auto_lock(config_lock_);
return input_params_;
}
media::AudioParameters
AudioHardwareConfig::GetOutputConfig() const {
AutoLock auto_lock(config_lock_);
return output_params_;
}
void AudioHardwareConfig::UpdateInputConfig(
const AudioParameters& input_params) {
AutoLock auto_lock(config_lock_);
input_params_ = input_params;
}
void AudioHardwareConfig::UpdateOutputConfig(
const AudioParameters& output_params) {
AutoLock auto_lock(config_lock_);
output_params_ = output_params;
}
int AudioHardwareConfig::GetHighLatencyBufferSize() const {
AutoLock auto_lock(config_lock_);
#if defined(HIGH_LATENCY_AUDIO_SUPPORT)
// Empirically, use the nearest higher power of two buffer size corresponding
// to 20 ms worth of samples. For a given sample rate, this works out to:
//
// <= 3200 : 64
// <= 6400 : 128
// <= 12800 : 256
// <= 25600 : 512
// <= 51200 : 1024
// <= 102400 : 2048
// <= 204800 : 4096
//
// On Linux, the minimum hardware buffer size is 512, so the lower calculated
// values are unused. OSX may have a value as low as 128. Windows is device
// dependent but will generally be sample_rate() / 100.
const int high_latency_buffer_size =
RoundUpToPowerOfTwo(2 * output_params_.sample_rate() / 100);
return std::max(output_params_.frames_per_buffer(), high_latency_buffer_size);
#else
return output_params_.frames_per_buffer();
#endif
}
} // namespace media
|
