1.APP应用层
厂商开发自己的音乐、导航、日历等应用软件。
2.Framework
Android系统对外提供了AudioRecord和AudioTrack两个API类，通过它们可以完成android平台上音频数据的采集和输出任务。
3.Libraries
Audio接口的具体功能实现放在了库中。AudioFlinger:它是audio系统的工作引擎，管理着系统的输入输出音频流，并承担音频数据的混音，以及读写audio硬件等工作以实现数据的输入输出功能。AudioPolicyService : 它是Audio系统的策略控制中心，控制着声音设备的选择和切换、音量控制等功能。
4 HAL
HAL的目的是为了将AudioFlinger、AudioPolicyService和硬件设备关联起来。提供了统一的接口来定义它与AudioFlinger、AudioPolicyService之间的通信方式。
HAL调用流程及源码分析
xref: /hardware/libhardware_legacy/audio/audio_hw_hal.cpp
HistoryAnnotate Line# Scopes# Navigate#Raw Download current directory
1 /*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "legacy_audio_hw_hal"
18 //#define LOG_NDEBUG 0
19
20 #include <stdint.h>
21
22 #include <hardware/hardware.h>
23 #include <system/audio.h>
24 #include <hardware/audio.h>
25
26 #include <hardware_legacy/AudioHardwareInterface.h>
27 #include <hardware_legacy/AudioSystemLegacy.h>
28
29 namespace android_audio_legacy {
30
31 class AudioHardwareInterface;
32
33 extern "C" {
34
35 struct legacy_audio_module {
36 struct audio_module module;
37 };
38
39 struct legacy_audio_device {
40 struct audio_hw_device device;
41
42 AudioHardwareInterface *hwif;
43 };
44
45 struct legacy_stream_out {
46 struct audio_stream_out stream;
47
48 AudioStreamOut *legacy_out;
49 };
50
51 struct legacy_stream_in {
52 struct audio_stream_in stream;
53
54 AudioStreamIn *legacy_in;
55 };
56
57
58 enum {
59 HAL_API_REV_1_0,
60 HAL_API_REV_2_0,
61 HAL_API_REV_NUM
62 } hal_api_rev;
63
64 static uint32_t audio_device_conv_table[][HAL_API_REV_NUM] =
65 {
66 /* output devices */
67 { AudioSystem::DEVICE_OUT_EARPIECE, AUDIO_DEVICE_OUT_EARPIECE },
68 { AudioSystem::DEVICE_OUT_SPEAKER, AUDIO_DEVICE_OUT_SPEAKER },
69 { AudioSystem::DEVICE_OUT_WIRED_HEADSET, AUDIO_DEVICE_OUT_WIRED_HEADSET },
70 { AudioSystem::DEVICE_OUT_WIRED_HEADPHONE, AUDIO_DEVICE_OUT_WIRED_HEADPHONE },
71 { AudioSystem::DEVICE_OUT_BLUETOOTH_SCO, AUDIO_DEVICE_OUT_BLUETOOTH_SCO },
72 { AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET, AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET },
73 { AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT, AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT },
74 { AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP, AUDIO_DEVICE_OUT_BLUETOOTH_A2DP },
75 { AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES, AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES },
76 { AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER, AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER },
77 { AudioSystem::DEVICE_OUT_AUX_DIGITAL, AUDIO_DEVICE_OUT_AUX_DIGITAL },
78 { AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET, AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET },
79 { AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET, AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET },
80 { AudioSystem::DEVICE_OUT_DEFAULT, AUDIO_DEVICE_OUT_DEFAULT },
81 /* input devices */
82 { AudioSystem::DEVICE_IN_COMMUNICATION, AUDIO_DEVICE_IN_COMMUNICATION },
83 { AudioSystem::DEVICE_IN_AMBIENT, AUDIO_DEVICE_IN_AMBIENT },
84 { AudioSystem::DEVICE_IN_BUILTIN_MIC, AUDIO_DEVICE_IN_BUILTIN_MIC },
85 { AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET, AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET },
86 { AudioSystem::DEVICE_IN_WIRED_HEADSET, AUDIO_DEVICE_IN_WIRED_HEADSET },
87 { AudioSystem::DEVICE_IN_AUX_DIGITAL, AUDIO_DEVICE_IN_AUX_DIGITAL },
88 { AudioSystem::DEVICE_IN_VOICE_CALL, AUDIO_DEVICE_IN_VOICE_CALL },
89 { AudioSystem::DEVICE_IN_BACK_MIC, AUDIO_DEVICE_IN_BACK_MIC },
90 { AudioSystem::DEVICE_IN_DEFAULT, AUDIO_DEVICE_IN_DEFAULT },
91 };
92
93 static uint32_t convert_audio_device(uint32_t from_device, int from_rev, int to_rev)
94 {
95 const uint32_t k_num_devices = sizeof(audio_device_conv_table)/sizeof(uint32_t)/HAL_API_REV_NUM;
96 uint32_t to_device = AUDIO_DEVICE_NONE;
97 uint32_t in_bit = 0;
98
99 if (from_rev != HAL_API_REV_1_0) {
100 in_bit = from_device & AUDIO_DEVICE_BIT_IN;
101 from_device &= ~AUDIO_DEVICE_BIT_IN;
102 }
103
104 while (from_device) {
105 uint32_t i = 31 - __builtin_clz(from_device);
106 uint32_t cur_device = (1 << i) | in_bit;
107
108 for (i = 0; i < k_num_devices; i++) {
109 if (audio_device_conv_table[i][from_rev] == cur_device) {
110 to_device |= audio_device_conv_table[i][to_rev];
111 break;
112 }
113 }
114 from_device &= ~cur_device;
115 }
116 return to_device;
117 }
118
119
120 /** audio_stream_out implementation **/
121 static uint32_t out_get_sample_rate(const struct audio_stream *stream)
122 {
123 const struct legacy_stream_out *out =
124 reinterpret_cast<const struct legacy_stream_out *>(stream);
125 return out->legacy_out->sampleRate();
126 }
127
128 static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
129 {
130 struct legacy_stream_out *out =
131 reinterpret_cast<struct legacy_stream_out *>(stream);
132
133 ALOGE("(%s:%d) %s: Implement me!", __FILE__, __LINE__, __func__);
134 /* TODO: implement this */
135 return 0;
136 }
137
138 static size_t out_get_buffer_size(const struct audio_stream *stream)
139 {
140 const struct legacy_stream_out *out =
141 reinterpret_cast<const struct legacy_stream_out *>(stream);
142 return out->legacy_out->bufferSize();
143 }
144
145 static audio_channel_mask_t out_get_channels(const struct audio_stream *stream)
146 {
147 const struct legacy_stream_out *out =
148 reinterpret_cast<const struct legacy_stream_out *>(stream);
149 return (audio_channel_mask_t) out->legacy_out->channels();
150 }
151
152 static audio_format_t out_get_format(const struct audio_stream *stream)
153 {
154 const struct legacy_stream_out *out =
155 reinterpret_cast<const struct legacy_stream_out *>(stream);
156 // legacy API, don't change return type
157 return (audio_format_t) out->legacy_out->format();
158 }
159
160 static int out_set_format(struct audio_stream *stream, audio_format_t format)
161 {
162 struct legacy_stream_out *out =
163 reinterpret_cast<struct legacy_stream_out *>(stream);
164 ALOGE("(%s:%d) %s: Implement me!", __FILE__, __LINE__, __func__);
165 /* TODO: implement me */
166 return 0;
167 }
168
169 static int out_standby(struct audio_stream *stream)
170 {
171 struct legacy_stream_out *out =
172 reinterpret_cast<struct legacy_stream_out *>(stream);
173 return out->legacy_out->standby();
174 }
175
176 static int out_dump(const struct audio_stream *stream, int fd)
177 {
178 const struct legacy_stream_out *out =
179 reinterpret_cast<const struct legacy_stream_out *>(stream);
180 Vector<String16> args;
181 return out->legacy_out->dump(fd, args);
182 }
183
184 static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
185 {
186 struct legacy_stream_out *out =
187 reinterpret_cast<struct legacy_stream_out *>(stream);
188 int val;
189 String8 s8 = String8(kvpairs);
190 AudioParameter parms = AudioParameter(String8(kvpairs));
191
192 if (parms.getInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val) == NO_ERROR) {
193 val = convert_audio_device(val, HAL_API_REV_2_0, HAL_API_REV_1_0);
194 parms.remove(String8(AUDIO_PARAMETER_STREAM_ROUTING));
195 parms.addInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val);
196 s8 = parms.toString();
197 }
198
199 return out->legacy_out->setParameters(s8);
200 }
201
202 static char * out_get_parameters(const struct audio_stream *stream, const char *keys)
203 {
204 const struct legacy_stream_out *out =
205 reinterpret_cast<const struct legacy_stream_out *>(stream);
206 String8 s8;
207 int val;
208
209 s8 = out->legacy_out->getParameters(String8(keys));
210
211 AudioParameter parms = AudioParameter(s8);
212 if (parms.getInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val) == NO_ERROR) {
213 val = convert_audio_device(val, HAL_API_REV_1_0, HAL_API_REV_2_0);
214 parms.remove(String8(AUDIO_PARAMETER_STREAM_ROUTING));
215 parms.addInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val);
216 s8 = parms.toString();
217 }
218
219 return strdup(s8.string());
220 }
221
222 static uint32_t out_get_latency(const struct audio_stream_out *stream)
223 {
224 const struct legacy_stream_out *out =
225 reinterpret_cast<const struct legacy_stream_out *>(stream);
226 return out->legacy_out->latency();
227 }
228
229 static int out_set_volume(struct audio_stream_out *stream, float left,
230 float right)
231 {
232 struct legacy_stream_out *out =
233 reinterpret_cast<struct legacy_stream_out *>(stream);
234 return out->legacy_out->setVolume(left, right);
235 }
236
237 static ssize_t out_write(struct audio_stream_out *stream, const void* buffer,
238 size_t bytes)
239 {
240 struct legacy_stream_out *out =
241 reinterpret_cast<struct legacy_stream_out *>(stream);
242 return out->legacy_out->write(buffer, bytes);
243 }
244
245 static int out_get_render_position(const struct audio_stream_out *stream,
246 uint32_t *dsp_frames)
247 {
248 const struct legacy_stream_out *out =
249 reinterpret_cast<const struct legacy_stream_out *>(stream);
250 return out->legacy_out->getRenderPosition(dsp_frames);
251 }
252
253 static int out_get_next_write_timestamp(const struct audio_stream_out *stream,
254 int64_t *timestamp)
255 {
256 const struct legacy_stream_out *out =
257 reinterpret_cast<const struct legacy_stream_out *>(stream);
258 return out->legacy_out->getNextWriteTimestamp(timestamp);
259 }
260
261 static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
262 {
263 return 0;
264 }
265
266 static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
267 {
268 return 0;
269 }
270
271 /** audio_stream_in implementation **/
272 static uint32_t in_get_sample_rate(const struct audio_stream *stream)
273 {
274 const struct legacy_stream_in *in =
275 reinterpret_cast<const struct legacy_stream_in *>(stream);
276 return in->legacy_in->sampleRate();
277 }
278
279 static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
280 {
281 struct legacy_stream_in *in =
282 reinterpret_cast<struct legacy_stream_in *>(stream);
283
284 ALOGE("(%s:%d) %s: Implement me!", __FILE__, __LINE__, __func__);
285 /* TODO: implement this */
286 return 0;
287 }
288
289 static size_t in_get_buffer_size(const struct audio_stream *stream)
290 {
291 const struct legacy_stream_in *in =
292 reinterpret_cast<const struct legacy_stream_in *>(stream);
293 return in->legacy_in->bufferSize();
294 }
295
296 static audio_channel_mask_t in_get_channels(const struct audio_stream *stream)
297 {
298 const struct legacy_stream_in *in =
299 reinterpret_cast<const struct legacy_stream_in *>(stream);
300 return (audio_channel_mask_t) in->legacy_in->channels();
301 }
302
303 static audio_format_t in_get_format(const struct audio_stream *stream)
304 {
305 const struct legacy_stream_in *in =
306 reinterpret_cast<const struct legacy_stream_in *>(stream);
307 // legacy API, don't change return type
308 return (audio_format_t) in->legacy_in->format();
309 }
310
311 static int in_set_format(struct audio_stream *stream, audio_format_t format)
312 {
313 struct legacy_stream_in *in =
314 reinterpret_cast<struct legacy_stream_in *>(stream);
315 ALOGE("(%s:%d) %s: Implement me!", __FILE__, __LINE__, __func__);
316 /* TODO: implement me */
317 return 0;
318 }
319
320 static int in_standby(struct audio_stream *stream)
321 {
322 struct legacy_stream_in *in = reinterpret_cast<struct legacy_stream_in *>(stream);
323 return in->legacy_in->standby();
324 }
325
326 static int in_dump(const struct audio_stream *stream, int fd)
327 {
328 const struct legacy_stream_in *in =
329 reinterpret_cast<const struct legacy_stream_in *>(stream);
330 Vector<String16> args;
331 return in->legacy_in->dump(fd, args);
332 }
333
334 static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
335 {
336 struct legacy_stream_in *in =
337 reinterpret_cast<struct legacy_stream_in *>(stream);
338 int val;
339 AudioParameter parms = AudioParameter(String8(kvpairs));
340 String8 s8 = String8(kvpairs);
341
342 if (parms.getInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val) == NO_ERROR) {
343 val = convert_audio_device(val, HAL_API_REV_2_0, HAL_API_REV_1_0);
344 parms.remove(String8(AUDIO_PARAMETER_STREAM_ROUTING));
345 parms.addInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val);
346 s8 = parms.toString();
347 }
348
349 return in->legacy_in->setParameters(s8);
350 }
351
352 static char * in_get_parameters(const struct audio_stream *stream,
353 const char *keys)
354 {
355 const struct legacy_stream_in *in =
356 reinterpret_cast<const struct legacy_stream_in *>(stream);
357 String8 s8;
358 int val;
359
360 s8 = in->legacy_in->getParameters(String8(keys));
361
362 AudioParameter parms = AudioParameter(s8);
363 if (parms.getInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val) == NO_ERROR) {
364 val = convert_audio_device(val, HAL_API_REV_1_0, HAL_API_REV_2_0);
365 parms.remove(String8(AUDIO_PARAMETER_STREAM_ROUTING));
366 parms.addInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), val);
367 s8 = parms.toString();
368 }
369
370 return strdup(s8.string());
371 }
372
373 static int in_set_gain(struct audio_stream_in *stream, float gain)
374 {
375 struct legacy_stream_in *in =
376 reinterpret_cast<struct legacy_stream_in *>(stream);
377 return in->legacy_in->setGain(gain);
378 }
379
380 static ssize_t in_read(struct audio_stream_in *stream, void* buffer,
381 size_t bytes)
382 {
383 struct legacy_stream_in *in =
384 reinterpret_cast<struct legacy_stream_in *>(stream);
385 return in->legacy_in->read(buffer, bytes);
386 }
387
388 static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream)
389 {
390 struct legacy_stream_in *in =
391 reinterpret_cast<struct legacy_stream_in *>(stream);
392 return in->legacy_in->getInputFramesLost();
393 }
394
395 static int in_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
396 {
397 const struct legacy_stream_in *in =
398 reinterpret_cast<const struct legacy_stream_in *>(stream);
399 return in->legacy_in->addAudioEffect(effect);
400 }
401
402 static int in_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
403 {
404 const struct legacy_stream_in *in =
405 reinterpret_cast<const struct legacy_stream_in *>(stream);
406 return in->legacy_in->removeAudioEffect(effect);
407 }
408
409 /** audio_hw_device implementation **/
410 static inline struct legacy_audio_device * to_ladev(struct audio_hw_device *dev)
411 {
412 return reinterpret_cast<struct legacy_audio_device *>(dev);
413 }
414
415 static inline const struct legacy_audio_device * to_cladev(const struct audio_hw_device *dev)
416 {
417 return reinterpret_cast<const struct legacy_audio_device *>(dev);
418 }
419
420 static int adev_init_check(const struct audio_hw_device *dev)
421 {
422 const struct legacy_audio_device *ladev = to_cladev(dev);
423
424 return ladev->hwif->initCheck();
425 }
426
427 static int adev_set_voice_volume(struct audio_hw_device *dev, float volume)
428 {
429 struct legacy_audio_device *ladev = to_ladev(dev);
430 return ladev->hwif->setVoiceVolume(volume);
431 }
432
433 static int adev_set_master_volume(struct audio_hw_device *dev, float volume)
434 {
435 struct legacy_audio_device *ladev = to_ladev(dev);
436 return ladev->hwif->setMasterVolume(volume);
437 }
438
439 static int adev_get_master_volume(struct audio_hw_device *dev, float* volume)
440 {
441 struct legacy_audio_device *ladev = to_ladev(dev);
442 return ladev->hwif->getMasterVolume(volume);
443 }
444
445 static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode)
446 {
447 struct legacy_audio_device *ladev = to_ladev(dev);
448 // as this is the legacy API, don't change it to use audio_mode_t instead of int
449 return ladev->hwif->setMode((int) mode);
450 }
451
452 static int adev_set_mic_mute(struct audio_hw_device *dev, bool state)
453 {
454 struct legacy_audio_device *ladev = to_ladev(dev);
455 return ladev->hwif->setMicMute(state);
456 }
457
458 static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state)
459 {
460 const struct legacy_audio_device *ladev = to_cladev(dev);
461 return ladev->hwif->getMicMute(state);
462 }
463
464 static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs)
465 {
466 struct legacy_audio_device *ladev = to_ladev(dev);
467 return ladev->hwif->setParameters(String8(kvpairs));
468 }
469
470 static char * adev_get_parameters(const struct audio_hw_device *dev,
471 const char *keys)
472 {
473 const struct legacy_audio_device *ladev = to_cladev(dev);
474 String8 s8;
475
476 s8 = ladev->hwif->getParameters(String8(keys));
477 return strdup(s8.string());
478 }
479
480 static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev,
481 const struct audio_config *config)
482 {
483 const struct legacy_audio_device *ladev = to_cladev(dev);
484 return ladev->hwif->getInputBufferSize(config->sample_rate, (int) config->format,
485 audio_channel_count_from_in_mask(config->channel_mask));
486 }
487
488 static int adev_open_output_stream(struct audio_hw_device *dev,
489 audio_io_handle_t handle,
490 audio_devices_t devices,
491 audio_output_flags_t flags,
492 struct audio_config *config,
493 struct audio_stream_out **stream_out,
494 const char *address __unused)
495 {
496 struct legacy_audio_device *ladev = to_ladev(dev);
497 status_t status;
498 struct legacy_stream_out *out;
499 int ret;
500
501 out = (struct legacy_stream_out *)calloc(1, sizeof(*out));
502 if (!out)
503 return -ENOMEM;
504
505 devices = convert_audio_device(devices, HAL_API_REV_2_0, HAL_API_REV_1_0);
506
507 out->legacy_out = ladev->hwif->openOutputStreamWithFlags(devices, flags,
508 (int *) &config->format,
509 &config->channel_mask,
510 &config->sample_rate, &status);
511 if (!out->legacy_out) {
512 ret = status;
513 goto err_open;
514 }
515
516 out->stream.common.get_sample_rate = out_get_sample_rate;
517 out->stream.common.set_sample_rate = out_set_sample_rate;
518 out->stream.common.get_buffer_size = out_get_buffer_size;
519 out->stream.common.get_channels = out_get_channels;
520 out->stream.common.get_format = out_get_format;
521 out->stream.common.set_format = out_set_format;
522 out->stream.common.standby = out_standby;
523 out->stream.common.dump = out_dump;
524 out->stream.common.set_parameters = out_set_parameters;
525 out->stream.common.get_parameters = out_get_parameters;
526 out->stream.common.add_audio_effect = out_add_audio_effect;
527 out->stream.common.remove_audio_effect = out_remove_audio_effect;
528 out->stream.get_latency = out_get_latency;
529 out->stream.set_volume = out_set_volume;
530 out->stream.write = out_write;
531 out->stream.get_render_position = out_get_render_position;
532 out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
533
534 *stream_out = &out->stream;
535 return 0;
536
537 err_open:
538 free(out);
539 *stream_out = NULL;
540 return ret;
541 }
542
543 static void adev_close_output_stream(struct audio_hw_device *dev,
544 struct audio_stream_out* stream)
545 {
546 struct legacy_audio_device *ladev = to_ladev(dev);
547 struct legacy_stream_out *out = reinterpret_cast<struct legacy_stream_out *>(stream);
548
549 ladev->hwif->closeOutputStream(out->legacy_out);
550 free(out);
551 }
552
553 /** This method creates and opens the audio hardware input stream */
554 static int adev_open_input_stream(struct audio_hw_device *dev,
555 audio_io_handle_t handle,
556 audio_devices_t devices,
557 struct audio_config *config,
558 struct audio_stream_in **stream_in,
559 audio_input_flags_t flags __unused,
560 const char *address __unused,
561 audio_source_t source __unused)
562 {
563 struct legacy_audio_device *ladev = to_ladev(dev);
564 status_t status;
565 struct legacy_stream_in *in;
566 int ret;
567
568 in = (struct legacy_stream_in *)calloc(1, sizeof(*in));
569 if (!in)
570 return -ENOMEM;
571
572 devices = convert_audio_device(devices, HAL_API_REV_2_0, HAL_API_REV_1_0);
573
574 in->legacy_in = ladev->hwif->openInputStream(devices, (int *) &config->format,
575 &config->channel_mask, &config->sample_rate,
576 &status, (AudioSystem::audio_in_acoustics)0);
577 if (!in->legacy_in) {
578 ret = status;
579 goto err_open;
580 }
581
582 in->stream.common.get_sample_rate = in_get_sample_rate;
583 in->stream.common.set_sample_rate = in_set_sample_rate;
584 in->stream.common.get_buffer_size = in_get_buffer_size;
585 in->stream.common.get_channels = in_get_channels;
586 in->stream.common.get_format = in_get_format;
587 in->stream.common.set_format = in_set_format;
588 in->stream.common.standby = in_standby;
589 in->stream.common.dump = in_dump;
590 in->stream.common.set_parameters = in_set_parameters;
591 in->stream.common.get_parameters = in_get_parameters;
592 in->stream.common.add_audio_effect = in_add_audio_effect;
593 in->stream.common.remove_audio_effect = in_remove_audio_effect;
594 in->stream.set_gain = in_set_gain;
595 in->stream.read = in_read;
596 in->stream.get_input_frames_lost = in_get_input_frames_lost;
597
598 *stream_in = &in->stream;
599 return 0;
600
601 err_open:
602 free(in);
603 *stream_in = NULL;
604 return ret;
605 }
606
607 static void adev_close_input_stream(struct audio_hw_device *dev,
608 struct audio_stream_in *stream)
609 {
610 struct legacy_audio_device *ladev = to_ladev(dev);
611 struct legacy_stream_in *in =
612 reinterpret_cast<struct legacy_stream_in *>(stream);
613
614 ladev->hwif->closeInputStream(in->legacy_in);
615 free(in);
616 }
617
618 static int adev_dump(const struct audio_hw_device *dev, int fd)
619 {
620 const struct legacy_audio_device *ladev = to_cladev(dev);
621 Vector<String16> args;
622
623 return ladev->hwif->dumpState(fd, args);
624 }
625
626 static int legacy_adev_close(hw_device_t* device)
627 {
628 struct audio_hw_device *hwdev =
629 reinterpret_cast<struct audio_hw_device *>(device);
630 struct legacy_audio_device *ladev = to_ladev(hwdev);
631
632 if (!ladev)
633 return 0;
634
635 if (ladev->hwif)
636 delete ladev->hwif;
637
638 free(ladev);
639 return 0;
640 }
641
642 static int legacy_adev_open(const hw_module_t* module, const char* name,
643 hw_device_t** device)
644 {
645 struct legacy_audio_device *ladev;
646 int ret;
647
648 if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0)
649 return -EINVAL;
650
651 ladev = (struct legacy_audio_device *)calloc(1, sizeof(*ladev));
652 if (!ladev)
653 return -ENOMEM;
654
655 ladev->device.common.tag = HARDWARE_DEVICE_TAG;
656 ladev->device.common.version = AUDIO_DEVICE_API_VERSION_2_0;
657 ladev->device.common.module = const_cast<hw_module_t*>(module);
658 ladev->device.common.close = legacy_adev_close;
659
660 ladev->device.init_check = adev_init_check;
661 ladev->device.set_voice_volume = adev_set_voice_volume;
662 ladev->device.set_master_volume = adev_set_master_volume;
663 ladev->device.get_master_volume = adev_get_master_volume;
664 ladev->device.set_mode = adev_set_mode;
665 ladev->device.set_mic_mute = adev_set_mic_mute;
666 ladev->device.get_mic_mute = adev_get_mic_mute;
667 ladev->device.set_parameters = adev_set_parameters;
668 ladev->device.get_parameters = adev_get_parameters;
669 ladev->device.get_input_buffer_size = adev_get_input_buffer_size;
670 ladev->device.open_output_stream = adev_open_output_stream;
671 ladev->device.close_output_stream = adev_close_output_stream;
672 ladev->device.open_input_stream = adev_open_input_stream;
673 ladev->device.close_input_stream = adev_close_input_stream;
674 ladev->device.dump = adev_dump;
675
676 ladev->hwif = createAudioHardware();
677 if (!ladev->hwif) {
678 ret = -EIO;
679 goto err_create_audio_hw;
680 }
681
682 *device = &ladev->device.common;
683
684 return 0;
685
686 err_create_audio_hw:
687 free(ladev);
688 return ret;
689 }
690
691 static struct hw_module_methods_t legacy_audio_module_methods = {
692 open: legacy_adev_open
693 };
694
695 struct legacy_audio_module HAL_MODULE_INFO_SYM = {
696 module: {
697 common: {
698 tag: HARDWARE_MODULE_TAG,
699 module_api_version: AUDIO_MODULE_API_VERSION_0_1,
700 hal_api_version: HARDWARE_HAL_API_VERSION,
701 id: AUDIO_HARDWARE_MODULE_ID,
702 name: "LEGACY Audio HW HAL",
703 author: "The Android Open Source Project",
704 methods: &legacy_audio_module_methods,
705 dso : NULL,
706 reserved : {0},
707 },
708 },
709 };
710
711 }; // extern "C"
712
713 }; // namespace android_audio_legacy
===========================================================
39 struct legacy_audio_device {
40 struct audio_hw_device device;
41
42 AudioHardwareInterface *hwif;
43 };
44
45 struct legacy_stream_out {
46 struct audio_stream_out stream;
47
48 AudioStreamOut *legacy_out;
49 };
50
51 struct legacy_stream_in {
52 struct audio_stream_in stream;
53
54 AudioStreamIn *legacy_in;
55 };audio_hw_device: 用于hal向上提供统一的接口，供AudioFlinger调用
audio_stream_out: legacy_stream_out中的audio_stream_out结构体，它是厂家向上提供的输出接口，表示输出功能。
audio_stream_in: legacy_stream_in中的audio_stream_in结构体，它是厂家向上提供的录音接口，表示输入功能。
在audio_hw_hal.cpp的legacy_adev_open函数中，会构建legacy_audio_device结构体， legacy_audio_device结构体中包含了audio_hw_device结构体，该结构体中有各类函数，特别是open_output_stream/open_input_stream。AudioFlinger会根据audio_hw_device结构体构造一个AudioHwDev对象并放入mAudioHwDevs。
createAudioHardware()创建的AudioHardware是由相关的厂家提供源码，通过AudioHardware向下访问硬件。
xref: /frameworks/av/services/audioflinger/AudioFlinger.cpp
1994 audio_module_handle_t AudioFlinger::loadHwModule(const char *name)
1995 {
1996 if (name == NULL) {
1997 return AUDIO_MODULE_HANDLE_NONE;
1998 }
1999 if (!settingsAllowed()) {
2000 return AUDIO_MODULE_HANDLE_NONE;
2001 }
2002 Mutex::Autolock _l(mLock);
2003 return loadHwModule_l(name);
2004 }
2005
2006 // loadHwModule_l() must be called with AudioFlinger::mLock held
2007 audio_module_handle_t AudioFlinger::loadHwModule_l(const char *name)
2008 {
2009 for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
2010 if (strncmp(mAudioHwDevs.valueAt(i)->moduleName(), name, strlen(name)) == 0) {
2011 ALOGW("loadHwModule() module %s already loaded", name);
2012 return mAudioHwDevs.keyAt(i);
2013 }
2014 }
2015
2016 sp<DeviceHalInterface> dev;
2017
2018 int rc = mDevicesFactoryHal->openDevice(name, &dev);
2019 if (rc) {
2020 ALOGE("loadHwModule() error %d loading module %s", rc, name);
2021 return AUDIO_MODULE_HANDLE_NONE;
2022 }
2023
2024 mHardwareStatus = AUDIO_HW_INIT;
2025 rc = dev->initCheck();
2026 mHardwareStatus = AUDIO_HW_IDLE;
2027 if (rc) {
2028 ALOGE("loadHwModule() init check error %d for module %s", rc, name);
2029 return AUDIO_MODULE_HANDLE_NONE;
2030 }
2031
2032 // Check and cache this HAL's level of support for master mute and master
2033 // volume. If this is the first HAL opened, and it supports the get
2034 // methods, use the initial values provided by the HAL as the current
2035 // master mute and volume settings.
2036
2037 AudioHwDevice::Flags flags = static_cast<AudioHwDevice::Flags>(0);
2038 { // scope for auto-lock pattern
2039 AutoMutex lock(mHardwareLock);
2040
2041 if (0 == mAudioHwDevs.size()) {
2042 mHardwareStatus = AUDIO_HW_GET_MASTER_VOLUME;
2043 float mv;
2044 if (OK == dev->getMasterVolume(&mv)) {
2045 mMasterVolume = mv;
2046 }
2047
2048 mHardwareStatus = AUDIO_HW_GET_MASTER_MUTE;
2049 bool mm;
2050 if (OK == dev->getMasterMute(&mm)) {
2051 mMasterMute = mm;
2052 }
2053 }
2054
2055 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
2056 if (OK == dev->setMasterVolume(mMasterVolume)) {
2057 flags = static_cast<AudioHwDevice::Flags>(flags |
2058 AudioHwDevice::AHWD_CAN_SET_MASTER_VOLUME);
2059 }
2060
2061 mHardwareStatus = AUDIO_HW_SET_MASTER_MUTE;
2062 if (OK == dev->setMasterMute(mMasterMute)) {
2063 flags = static_cast<AudioHwDevice::Flags>(flags |
2064 AudioHwDevice::AHWD_CAN_SET_MASTER_MUTE);
2065 }
2066
2067 mHardwareStatus = AUDIO_HW_IDLE;
2068 }
2069 if (strcmp(name, AUDIO_HARDWARE_MODULE_ID_MSD) == 0) {
2070 // An MSD module is inserted before hardware modules in order to mix encoded streams.
2071 flags = static_cast<AudioHwDevice::Flags>(flags | AudioHwDevice::AHWD_IS_INSERT);
2072 }
2073
2074 audio_module_handle_t handle = (audio_module_handle_t) nextUniqueId(AUDIO_UNIQUE_ID_USE_MODULE);
2075 mAudioHwDevs.add(handle, new AudioHwDevice(handle, name, dev, flags));
2076
2077 ALOGI("loadHwModule() Loaded %s audio interface, handle %d", name, handle);
2078
2079 return handle;
2080
2081 }5.AudioFlinger使用audio_hw_device
sp<DeviceHalInterface> dev;
mAudioHwDevs.add(handle, new AudioHwDevice(handle, name, dev, flags));
dev就是hal层构造的audio_hw_device，dev会被封装在AudioHwDevice中，然后添加到mAudioHwDevs数组中。
xref: /frameworks/av/services/audioflinger/AudioFlinger.cpp
2276 sp<AudioFlinger::ThreadBase> AudioFlinger::openOutput_l(audio_module_handle_t module,
2277 audio_io_handle_t *output,
2278 audio_config_t *config,
2279 audio_devices_t devices,
2280 const String8& address,
2281 audio_output_flags_t flags)
2282 {
2283 AudioHwDevice *outHwDev = findSuitableHwDev_l(module, devices);
2284 if (outHwDev == NULL) {
2285 return 0;
2286 }
2287
2288 if (*output == AUDIO_IO_HANDLE_NONE) {
2289 *output = nextUniqueId(AUDIO_UNIQUE_ID_USE_OUTPUT);
2290 } else {
2291 // Audio Policy does not currently request a specific output handle.
2292 // If this is ever needed, see openInput_l() for example code.
2293 ALOGE("openOutput_l requested output handle %d is not AUDIO_IO_HANDLE_NONE", *output);
2294 return 0;
2295 }
2296
2297 mHardwareStatus = AUDIO_HW_OUTPUT_OPEN;
2298
2299 // FOR TESTING ONLY:
2300 // This if statement allows overriding the audio policy settings
2301 // and forcing a specific format or channel mask to the HAL/Sink device for testing.
2302 if (!(flags & (AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD | AUDIO_OUTPUT_FLAG_DIRECT))) {
2303 // Check only for Normal Mixing mode
2304 if (kEnableExtendedPrecision) {
2305 // Specify format (uncomment one below to choose)
2306 //config->format = AUDIO_FORMAT_PCM_FLOAT;
2307 //config->format = AUDIO_FORMAT_PCM_24_BIT_PACKED;
2308 //config->format = AUDIO_FORMAT_PCM_32_BIT;
2309 //config->format = AUDIO_FORMAT_PCM_8_24_BIT;
2310 // ALOGV("openOutput_l() upgrading format to %#08x", config->format);
2311 }
2312 if (kEnableExtendedChannels) {
2313 // Specify channel mask (uncomment one below to choose)
2314 //config->channel_mask = audio_channel_out_mask_from_count(4); // for USB 4ch
2315 //config->channel_mask = audio_channel_mask_from_representation_and_bits(
2316 // AUDIO_CHANNEL_REPRESENTATION_INDEX, (1 << 4) - 1); // another 4ch example
2317 }
2318 }
2319
2320 AudioStreamOut *outputStream = NULL;
2321 status_t status = outHwDev->openOutputStream(
2322 &outputStream,
2323 *output,
2324 devices,
2325 flags,
2326 config,
2327 address.string());
2328
2329 mHardwareStatus = AUDIO_HW_IDLE;
2330
2331 if (status == NO_ERROR) {
2332 if (flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) {
2333 sp<MmapPlaybackThread> thread =
2334 new MmapPlaybackThread(this, *output, outHwDev, outputStream,
2335 devices, AUDIO_DEVICE_NONE, mSystemReady);
2336 mMmapThreads.add(*output, thread);
2337 ALOGV("openOutput_l() created mmap playback thread: ID %d thread %p",
2338 *output, thread.get());
2339 return thread;
2340 } else {
2341 sp<PlaybackThread> thread;
2342 if (flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
2343 thread = new OffloadThread(this, outputStream, *output, devices, mSystemReady);
2344 ALOGV("openOutput_l() created offload output: ID %d thread %p",
2345 *output, thread.get());
2346 } else if ((flags & AUDIO_OUTPUT_FLAG_DIRECT)
2347 || !isValidPcmSinkFormat(config->format)
2348 || !isValidPcmSinkChannelMask(config->channel_mask)) {
2349 thread = new DirectOutputThread(this, outputStream, *output, devices, mSystemReady);
2350 ALOGV("openOutput_l() created direct output: ID %d thread %p",
2351 *output, thread.get());
2352 } else {
2353 thread = new MixerThread(this, outputStream, *output, devices, mSystemReady);
2354 ALOGV("openOutput_l() created mixer output: ID %d thread %p",
2355 *output, thread.get());
2356 }
2357 mPlaybackThreads.add(*output, thread);
2358 mPatchPanel.notifyStreamOpened(outHwDev, *output);
2359 return thread;
2360 }
2361 }
2362
2363 return 0;
2364 }6.根据flag创建不同的线程
thread = new MixerThread(this, outputStream, *output, devices, mSystemReady);
根据配置文件的flag创建不同的线程，一般会创建MixerThread线程。
从hal层返回的audio_hw_device结构体中的open_output_stream会在AudioFlinger::openOutput_l方法中被封装成一个MixerThread,每个thread会跟一个output相对应被添加到mPlaybackThreads中，这样就将每一个播放线程跟outputStream对应。
xref: /frameworks/av/services/audioflinger/Threads.cpp
11 // shared by MIXER and DIRECT, overridden by DUPLICATING
2912 ssize_t AudioFlinger::PlaybackThread::threadLoop_write()
2913 {
2914 LOG_HIST_TS();
2915 mInWrite = true;
2916 ssize_t bytesWritten;
2917 const size_t offset = mCurrentWriteLength - mBytesRemaining;
2918
2919 // If an NBAIO sink is present, use it to write the normal mixer's submix
2920 if (mNormalSink != 0) {
2921
2922 const size_t count = mBytesRemaining / mFrameSize;
2923
2924 ATRACE_BEGIN("write");
2925 // update the setpoint when AudioFlinger::mScreenState changes
2926 uint32_t screenState = AudioFlinger::mScreenState;
2927 if (screenState != mScreenState) {
2928 mScreenState = screenState;
2929 MonoPipe *pipe = (MonoPipe *)mPipeSink.get();
2930 if (pipe != NULL) {
2931 pipe->setAvgFrames((mScreenState & 1) ?
2932 (pipe->maxFrames() * 7) / 8 : mNormalFrameCount * 2);
2933 }
2934 }
2935 ssize_t framesWritten = mNormalSink->write((char *)mSinkBuffer + offset, count);
2936 ATRACE_END();
2937 if (framesWritten > 0) {
2938 bytesWritten = framesWritten * mFrameSize;
2939 #ifdef TEE_SINK
2940 mTee.write((char *)mSinkBuffer + offset, framesWritten);
2941 #endif
2942 } else {
2943 bytesWritten = framesWritten;
2944 }
2945 // otherwise use the HAL / AudioStreamOut directly
2946 } else {
2947 // Direct output and offload threads
2948
2949 if (mUseAsyncWrite) {
2950 ALOGW_IF(mWriteAckSequence & 1, "threadLoop_write(): out of sequence write request");
2951 mWriteAckSequence += 2;
2952 mWriteAckSequence |= 1;
2953 ALOG_ASSERT(mCallbackThread != 0);
2954 mCallbackThread->setWriteBlocked(mWriteAckSequence);
2955 }
2956 // FIXME We should have an implementation of timestamps for direct output threads.
2957 // They are used e.g for multichannel PCM playback over HDMI.
2958 bytesWritten = mOutput->write((char *)mSinkBuffer + offset, mBytesRemaining);
2959
2960 if (mUseAsyncWrite &&
2961 ((bytesWritten < 0) || (bytesWritten == (ssize_t)mBytesRemaining))) {
2962 // do not wait for async callback in case of error of full write
2963 mWriteAckSequence &= ~1;
2964 ALOG_ASSERT(mCallbackThread != 0);
2965 mCallbackThread->setWriteBlocked(mWriteAckSequence);
2966 }
2967 }
2968
2969 mNumWrites++;
2970 mInWrite = false;
2971 mStandby = false;
2972 return bytesWritten;
2973 }7.播放：
调用AudioFlinger::PlaybackThread::threadLoop_write中的mNormalSink->write写入数据进行播放
～～～最后欢迎大家多多参与讨论～～～
扫一扫
183
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
