1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "build/build_config.h"
6 #include "ppapi/shared_impl/ppb_audio_config_shared.h"
7 #include "ppapi/thunk/enter.h"
8 #include "ppapi/thunk/ppb_instance_api.h"
9
10 namespace ppapi {
11
12 // Rounds up requested_size to the nearest multiple of minimum_size.
CalculateMultipleOfSampleFrameCount(uint32_t minimum_size,uint32_t requested_size)13 static uint32_t CalculateMultipleOfSampleFrameCount(uint32_t minimum_size,
14 uint32_t requested_size) {
15 const uint32_t multiple = (requested_size + minimum_size - 1) / minimum_size;
16 return std::min(minimum_size * multiple,
17 static_cast<uint32_t>(PP_AUDIOMAXSAMPLEFRAMECOUNT));
18 }
19
PPB_AudioConfig_Shared(ResourceObjectType type,PP_Instance instance)20 PPB_AudioConfig_Shared::PPB_AudioConfig_Shared(ResourceObjectType type,
21 PP_Instance instance)
22 : Resource(type, instance),
23 sample_rate_(PP_AUDIOSAMPLERATE_NONE),
24 sample_frame_count_(0) {}
25
~PPB_AudioConfig_Shared()26 PPB_AudioConfig_Shared::~PPB_AudioConfig_Shared() {}
27
Create(ResourceObjectType type,PP_Instance instance,PP_AudioSampleRate sample_rate,uint32_t sample_frame_count)28 PP_Resource PPB_AudioConfig_Shared::Create(ResourceObjectType type,
29 PP_Instance instance,
30 PP_AudioSampleRate sample_rate,
31 uint32_t sample_frame_count) {
32 scoped_refptr<PPB_AudioConfig_Shared> object(
33 new PPB_AudioConfig_Shared(type, instance));
34 if (!object->Init(sample_rate, sample_frame_count))
35 return 0;
36 return object->GetReference();
37 }
38
39 // static
RecommendSampleFrameCount_1_0(PP_AudioSampleRate sample_rate,uint32_t requested_sample_frame_count)40 uint32_t PPB_AudioConfig_Shared::RecommendSampleFrameCount_1_0(
41 PP_AudioSampleRate sample_rate,
42 uint32_t requested_sample_frame_count) {
43 // Version 1.0: Don't actually query to get a value from the
44 // hardware; instead return the input for in-range values.
45 if (requested_sample_frame_count < PP_AUDIOMINSAMPLEFRAMECOUNT)
46 return PP_AUDIOMINSAMPLEFRAMECOUNT;
47 if (requested_sample_frame_count > PP_AUDIOMAXSAMPLEFRAMECOUNT)
48 return PP_AUDIOMAXSAMPLEFRAMECOUNT;
49 return requested_sample_frame_count;
50 }
51
52 // static
RecommendSampleFrameCount_1_1(PP_Instance instance,PP_AudioSampleRate sample_rate,uint32_t sample_frame_count)53 uint32_t PPB_AudioConfig_Shared::RecommendSampleFrameCount_1_1(
54 PP_Instance instance,
55 PP_AudioSampleRate sample_rate,
56 uint32_t sample_frame_count) {
57 // Version 1.1: Query the back-end hardware for sample rate and buffer size,
58 // and recommend a best fit based on request.
59 thunk::EnterInstanceNoLock enter(instance);
60 if (enter.failed())
61 return 0;
62
63 // Get the hardware config.
64 PP_AudioSampleRate hardware_sample_rate = static_cast<PP_AudioSampleRate>(
65 enter.functions()->GetAudioHardwareOutputSampleRate(instance));
66 uint32_t hardware_sample_frame_count =
67 enter.functions()->GetAudioHardwareOutputBufferSize(instance);
68 if (sample_frame_count < PP_AUDIOMINSAMPLEFRAMECOUNT)
69 sample_frame_count = PP_AUDIOMINSAMPLEFRAMECOUNT;
70
71 // If hardware information isn't available we're connected to a fake audio
72 // output stream on the browser side, so we can use whatever sample count the
73 // client wants.
74 if (!hardware_sample_frame_count || !hardware_sample_rate)
75 return sample_frame_count;
76
77 // Note: All the values below were determined through experimentation to
78 // minimize jitter and back-to-back callbacks from the browser. Please take
79 // care when modifying these values as they impact a large number of users.
80 // TODO(dalecurtis): Land jitter test and add documentation for updating this.
81
82 // Should track the value reported by XP and ALSA backends.
83 const uint32_t kHighLatencySampleFrameCount = 2048;
84 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
85 // TODO(ihf): Remove this once ARM Chromebooks support low latency audio. For
86 // now we classify them as high latency. See crbug.com/289770. Note that
87 // Adobe Flash is affected but not HTML5, WebRTC and WebAudio (they are using
88 // real time threads).
89 const bool kHighLatencyDevice = true;
90 #else
91 const bool kHighLatencyDevice = false;
92 #endif
93
94 // If client is using same sample rate as audio hardware, then recommend a
95 // multiple of the audio hardware's sample frame count.
96 if (!kHighLatencyDevice && hardware_sample_rate == sample_rate) {
97 return CalculateMultipleOfSampleFrameCount(hardware_sample_frame_count,
98 sample_frame_count);
99 }
100
101 // If the hardware requires a high latency buffer or we're at a low sample
102 // rate w/ a buffer that's larger than 10ms, choose the nearest multiple of
103 // the high latency sample frame count. An example of too low and too large
104 // is 16kHz and a sample frame count greater than 160 frames.
105 if (kHighLatencyDevice ||
106 hardware_sample_frame_count >= kHighLatencySampleFrameCount ||
107 (hardware_sample_rate < 44100 &&
108 hardware_sample_frame_count > hardware_sample_rate / 100u)) {
109 return CalculateMultipleOfSampleFrameCount(
110 sample_frame_count,
111 std::max(kHighLatencySampleFrameCount, hardware_sample_frame_count));
112 }
113
114 // All low latency clients should be able to handle a 512 frame buffer with
115 // resampling from 44.1kHz and 48kHz to higher sample rates.
116 // TODO(dalecurtis): We may need to investigate making the callback thread
117 // high priority to handle buffers at the absolute minimum w/o glitching.
118 const uint32_t kLowLatencySampleFrameCount = 512;
119
120 // Special case for 48kHz -> 44.1kHz and buffer sizes greater than 10ms. In
121 // testing most buffer sizes > 10ms led to glitching, so we choose a size we
122 // know won't cause jitter.
123 int min_sample_frame_count = kLowLatencySampleFrameCount;
124 if (hardware_sample_rate == 44100 && sample_rate == 48000 &&
125 hardware_sample_frame_count > hardware_sample_rate / 100u) {
126 min_sample_frame_count =
127 std::max(2 * kLowLatencySampleFrameCount, hardware_sample_frame_count);
128 }
129
130 return CalculateMultipleOfSampleFrameCount(min_sample_frame_count,
131 sample_frame_count);
132 }
133
134 // static
RecommendSampleRate(PP_Instance instance)135 PP_AudioSampleRate PPB_AudioConfig_Shared::RecommendSampleRate(
136 PP_Instance instance) {
137 thunk::EnterInstanceNoLock enter(instance);
138 if (enter.failed())
139 return PP_AUDIOSAMPLERATE_NONE;
140 PP_AudioSampleRate hardware_sample_rate = static_cast<PP_AudioSampleRate>(
141 enter.functions()->GetAudioHardwareOutputSampleRate(instance));
142 return hardware_sample_rate;
143 }
144
AsPPB_AudioConfig_API()145 thunk::PPB_AudioConfig_API* PPB_AudioConfig_Shared::AsPPB_AudioConfig_API() {
146 return this;
147 }
148
GetSampleRate()149 PP_AudioSampleRate PPB_AudioConfig_Shared::GetSampleRate() {
150 return sample_rate_;
151 }
152
GetSampleFrameCount()153 uint32_t PPB_AudioConfig_Shared::GetSampleFrameCount() {
154 return sample_frame_count_;
155 }
156
Init(PP_AudioSampleRate sample_rate,uint32_t sample_frame_count)157 bool PPB_AudioConfig_Shared::Init(PP_AudioSampleRate sample_rate,
158 uint32_t sample_frame_count) {
159 // TODO(brettw): Currently we don't actually check what the hardware
160 // supports, so just allow sample rates of the "guaranteed working" ones.
161 // TODO(dalecurtis): If sample rates are added RecommendSampleFrameCount_1_1()
162 // must be updated to account for the new rates.
163 if (sample_rate != PP_AUDIOSAMPLERATE_44100 &&
164 sample_rate != PP_AUDIOSAMPLERATE_48000)
165 return false;
166
167 // TODO(brettw): Currently we don't actually query to get a value from the
168 // hardware, so just validate the range.
169 if (sample_frame_count > PP_AUDIOMAXSAMPLEFRAMECOUNT ||
170 sample_frame_count < PP_AUDIOMINSAMPLEFRAMECOUNT)
171 return false;
172
173 sample_rate_ = sample_rate;
174 sample_frame_count_ = sample_frame_count;
175 return true;
176 }
177
178 } // namespace ppapi
179