blob: f3f151385cda9855cb170c8e5fc8845291b7962d (
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
129
130
131
132
133
134
135
136
137
138
139
140
141
|
// 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 <stdint.h>
#include <algorithm>
#include <cmath>
#include "base/logging.h"
#include "build/build_config.h"
using base::AutoLock;
using media::AudioParameters;
namespace media {
#if !defined(OS_WIN)
// 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;
}
// static
int AudioHardwareConfig::GetHighLatencyBufferSize(int sample_rate,
int buffer_size) {
// Empirically, we consider 20ms of samples to be high latency.
const double twenty_ms_size = 2.0 * sample_rate / 100;
#if defined(OS_WIN)
buffer_size = std::max(buffer_size, 1);
// Windows doesn't use power of two buffer sizes, so we should always round up
// to the nearest multiple of the output buffer size.
const int high_latency_buffer_size =
std::ceil(twenty_ms_size / buffer_size) * buffer_size;
#else
// On other platforms use the nearest higher power of two buffer size. 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.
const int high_latency_buffer_size = RoundUpToPowerOfTwo(twenty_ms_size);
#endif // defined(OS_WIN)
return std::max(buffer_size, high_latency_buffer_size);
}
int AudioHardwareConfig::GetHighLatencyBufferSize() const {
AutoLock auto_lock(config_lock_);
return GetHighLatencyBufferSize(output_params_.sample_rate(),
output_params_.frames_per_buffer());
}
} // namespace media
|
