2 * Copyright (C) 2012 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #define LOG_TAG "usb_audio_hw"
18 /*#define LOG_NDEBUG 0*/
28 #include <cutils/str_parms.h>
29 #include <cutils/properties.h>
31 #include <hardware/audio.h>
32 #include <hardware/audio_alsaops.h>
33 #include <hardware/hardware.h>
35 #include <system/audio.h>
37 #include <tinyalsa/asoundlib.h>
39 #include <audio_utils/channels.h>
42 * Set k_force_channels to force the number of channels to present to AudioFlinger.
43 * 0 disables (this is default: present the device channels to AudioFlinger).
44 * 2 forces to legacy stereo mode.
46 * Others values can be tried (up to 8).
47 * TODO: AudioFlinger cannot support more than 8 active output channels
48 * at this time, so limiting logic needs to be put here or communicated from above.
50 static const unsigned k_force_channels = 0;
52 #include "alsa_device_profile.h"
53 #include "alsa_device_proxy.h"
56 #define DEFAULT_INPUT_BUFFER_SIZE_MS 20
59 struct audio_hw_device hw_device;
61 pthread_mutex_t lock; /* see note below on mutex acquisition order */
64 alsa_device_profile out_profile;
67 alsa_device_profile in_profile;
73 struct audio_stream_out stream;
75 pthread_mutex_t lock; /* see note below on mutex acquisition order */
78 struct audio_device *dev; /* hardware information - only using this for the lock */
80 alsa_device_profile * profile;
81 alsa_device_proxy proxy; /* state of the stream */
83 unsigned hal_channel_count; /* channel count exposed to AudioFlinger.
84 * This may differ from the device channel count when
85 * the device is not compatible with AudioFlinger
86 * capabilities, e.g. exposes too many channels or
87 * too few channels. */
88 void * conversion_buffer; /* any conversions are put into here
89 * they could come from here too if
90 * there was a previous conversion */
91 size_t conversion_buffer_size; /* in bytes */
95 struct audio_stream_in stream;
97 pthread_mutex_t lock; /* see note below on mutex acquisition order */
100 struct audio_device *dev; /* hardware information - only using this for the lock */
102 alsa_device_profile * profile;
103 alsa_device_proxy proxy; /* state of the stream */
106 // struct audio_config hal_pcm_config;
108 /* We may need to read more data from the device in order to data reduce to 16bit, 4chan */
109 void * conversion_buffer; /* any conversions are put into here
110 * they could come from here too if
111 * there was a previous conversion */
112 size_t conversion_buffer_size; /* in bytes */
119 * Convert a buffer of packed (3-byte) PCM24LE samples to PCM16LE samples.
120 * in_buff points to the buffer of PCM24LE samples
121 * num_in_samples size of input buffer in SAMPLES
122 * out_buff points to the buffer to receive converted PCM16LE LE samples.
124 * the number of BYTES of output data.
125 * We are doing this since we *always* present to The Framework as A PCM16LE device, but need to
126 * support PCM24_3LE (24-bit, packed).
128 * This conversion is safe to do in-place (in_buff == out_buff).
129 * TODO Move this to a utilities module.
131 static size_t convert_24_3_to_16(const unsigned char * in_buff, size_t num_in_samples,
135 * Move from front to back so that the conversion can be done in-place
136 * i.e. in_buff == out_buff
138 /* we need 2 bytes in the output for every 3 bytes in the input */
139 unsigned char* dst_ptr = (unsigned char*)out_buff;
140 const unsigned char* src_ptr = in_buff;
141 size_t src_smpl_index;
142 for (src_smpl_index = 0; src_smpl_index < num_in_samples; src_smpl_index++) {
143 src_ptr++; /* lowest-(skip)-byte */
144 *dst_ptr++ = *src_ptr++; /* low-byte */
145 *dst_ptr++ = *src_ptr++; /* high-byte */
148 /* return number of *bytes* generated: */
149 return num_in_samples * 2;
153 * Convert a buffer of packed (3-byte) PCM32 samples to PCM16LE samples.
154 * in_buff points to the buffer of PCM32 samples
155 * num_in_samples size of input buffer in SAMPLES
156 * out_buff points to the buffer to receive converted PCM16LE LE samples.
158 * the number of BYTES of output data.
159 * We are doing this since we *always* present to The Framework as A PCM16LE device, but need to
160 * support PCM_FORMAT_S32_LE (32-bit).
162 * This conversion is safe to do in-place (in_buff == out_buff).
163 * TODO Move this to a utilities module.
165 static size_t convert_32_to_16(const int32_t * in_buff, size_t num_in_samples, short * out_buff)
168 * Move from front to back so that the conversion can be done in-place
169 * i.e. in_buff == out_buff
172 short * dst_ptr = out_buff;
173 const int32_t* src_ptr = in_buff;
174 size_t src_smpl_index;
175 for (src_smpl_index = 0; src_smpl_index < num_in_samples; src_smpl_index++) {
176 *dst_ptr++ = *src_ptr++ >> 16;
179 /* return number of *bytes* generated: */
180 return num_in_samples * 2;
183 static char * device_get_parameters(alsa_device_profile * profile, const char * keys)
185 ALOGV("usb:audio_hw::device_get_parameters() keys:%s", keys);
187 if (profile->card < 0 || profile->device < 0) {
191 struct str_parms *query = str_parms_create_str(keys);
192 struct str_parms *result = str_parms_create();
194 /* These keys are from hardware/libhardware/include/audio.h */
195 /* supported sample rates */
196 if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_SAMPLING_RATES)) {
197 char* rates_list = profile_get_sample_rate_strs(profile);
198 str_parms_add_str(result, AUDIO_PARAMETER_STREAM_SUP_SAMPLING_RATES,
203 /* supported channel counts */
204 if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_CHANNELS)) {
205 char* channels_list = profile_get_channel_count_strs(profile);
206 str_parms_add_str(result, AUDIO_PARAMETER_STREAM_SUP_CHANNELS,
211 /* supported sample formats */
212 if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_FORMATS)) {
213 char * format_params = profile_get_format_strs(profile);
214 str_parms_add_str(result, AUDIO_PARAMETER_STREAM_SUP_FORMATS,
218 str_parms_destroy(query);
220 char* result_str = str_parms_to_str(result);
221 str_parms_destroy(result);
223 ALOGV("usb:audio_hw::device_get_parameters = %s", result_str);
232 * NOTE: when multiple mutexes have to be acquired, always respect the
233 * following order: hw device > out stream
239 static uint32_t out_get_sample_rate(const struct audio_stream *stream)
241 uint32_t rate = proxy_get_sample_rate(&((struct stream_out*)stream)->proxy);
242 ALOGV("out_get_sample_rate() = %d", rate);
246 static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
251 static size_t out_get_buffer_size(const struct audio_stream *stream)
253 const struct stream_out* out = (const struct stream_out*)stream;
255 proxy_get_period_size(&out->proxy) * audio_stream_out_frame_size(&(out->stream));
256 ALOGV("out_get_buffer_size() = %zu", buffer_size);
260 static uint32_t out_get_channels(const struct audio_stream *stream)
262 const struct stream_out *out = (const struct stream_out*)stream;
263 return audio_channel_out_mask_from_count(out->hal_channel_count);
266 static audio_format_t out_get_format(const struct audio_stream *stream)
268 /* Note: The HAL doesn't do any FORMAT conversion at this time. It
269 * Relies on the framework to provide data in the specified format.
270 * This could change in the future.
272 alsa_device_proxy * proxy = &((struct stream_out*)stream)->proxy;
273 audio_format_t format = audio_format_from_pcm_format(proxy_get_format(proxy));
277 static int out_set_format(struct audio_stream *stream, audio_format_t format)
282 static int out_standby(struct audio_stream *stream)
284 struct stream_out *out = (struct stream_out *)stream;
286 pthread_mutex_lock(&out->dev->lock);
287 pthread_mutex_lock(&out->lock);
290 proxy_close(&out->proxy);
294 pthread_mutex_unlock(&out->lock);
295 pthread_mutex_unlock(&out->dev->lock);
300 static int out_dump(const struct audio_stream *stream, int fd)
305 static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
307 ALOGV("usb:audio_hw::out out_set_parameters() keys:%s", kvpairs);
309 struct stream_out *out = (struct stream_out *)stream;
318 struct str_parms * parms = str_parms_create_str(kvpairs);
319 pthread_mutex_lock(&out->dev->lock);
320 pthread_mutex_lock(&out->lock);
322 param_val = str_parms_get_str(parms, "card", value, sizeof(value));
326 param_val = str_parms_get_str(parms, "device", value, sizeof(value));
328 device = atoi(value);
330 if (card >= 0 && device >= 0) {
331 /* cannot read pcm device info if playback is active */
335 int saved_card = out->profile->card;
336 int saved_device = out->profile->device;
337 out->profile->card = card;
338 out->profile->device = device;
339 ret_value = profile_read_device_info(out->profile) ? 0 : -EINVAL;
340 if (ret_value != 0) {
341 out->profile->card = saved_card;
342 out->profile->device = saved_device;
346 pthread_mutex_unlock(&out->lock);
347 pthread_mutex_unlock(&out->dev->lock);
348 str_parms_destroy(parms);
353 static char * out_get_parameters(const struct audio_stream *stream, const char *keys)
355 struct stream_out *out = (struct stream_out *)stream;
356 pthread_mutex_lock(&out->dev->lock);
357 pthread_mutex_lock(&out->lock);
359 char * params_str = device_get_parameters(out->profile, keys);
361 pthread_mutex_unlock(&out->lock);
362 pthread_mutex_unlock(&out->dev->lock);
367 static uint32_t out_get_latency(const struct audio_stream_out *stream)
369 alsa_device_proxy * proxy = &((struct stream_out*)stream)->proxy;
370 return proxy_get_latency(proxy);
373 static int out_set_volume(struct audio_stream_out *stream, float left, float right)
378 /* must be called with hw device and output stream mutexes locked */
379 static int start_output_stream(struct stream_out *out)
381 ALOGV("usb:audio_hw::out start_output_stream(card:%d device:%d)",
382 out->profile->card, out->profile->device);
384 return proxy_open(&out->proxy);
387 static ssize_t out_write(struct audio_stream_out *stream, const void* buffer, size_t bytes)
390 struct stream_out *out = (struct stream_out *)stream;
392 pthread_mutex_lock(&out->dev->lock);
393 pthread_mutex_lock(&out->lock);
395 ret = start_output_stream(out);
397 pthread_mutex_unlock(&out->dev->lock);
400 out->standby = false;
402 pthread_mutex_unlock(&out->dev->lock);
405 alsa_device_proxy* proxy = &out->proxy;
406 const void * write_buff = buffer;
407 int num_write_buff_bytes = bytes;
408 const int num_device_channels = proxy_get_channel_count(proxy); /* what we told alsa */
409 const int num_req_channels = out->hal_channel_count; /* what we told AudioFlinger */
410 if (num_device_channels != num_req_channels) {
411 /* allocate buffer */
412 const size_t required_conversion_buffer_size =
413 bytes * num_device_channels / num_req_channels;
414 if (required_conversion_buffer_size > out->conversion_buffer_size) {
415 out->conversion_buffer_size = required_conversion_buffer_size;
416 out->conversion_buffer = realloc(out->conversion_buffer,
417 out->conversion_buffer_size);
420 const audio_format_t audio_format = out_get_format(&(out->stream.common));
421 const unsigned sample_size_in_bytes = audio_bytes_per_sample(audio_format);
422 num_write_buff_bytes =
423 adjust_channels(write_buff, num_req_channels,
424 out->conversion_buffer, num_device_channels,
425 sample_size_in_bytes, num_write_buff_bytes);
426 write_buff = out->conversion_buffer;
429 if (write_buff != NULL && num_write_buff_bytes != 0) {
430 proxy_write(&out->proxy, write_buff, num_write_buff_bytes);
433 pthread_mutex_unlock(&out->lock);
438 pthread_mutex_unlock(&out->lock);
440 usleep(bytes * 1000000 / audio_stream_out_frame_size(stream) /
441 out_get_sample_rate(&stream->common));
447 static int out_get_render_position(const struct audio_stream_out *stream, uint32_t *dsp_frames)
452 static int out_get_presentation_position(const struct audio_stream_out *stream,
453 uint64_t *frames, struct timespec *timestamp)
455 /* FIXME - This needs to be implemented */
459 static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
464 static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
469 static int out_get_next_write_timestamp(const struct audio_stream_out *stream, int64_t *timestamp)
474 static int adev_open_output_stream(struct audio_hw_device *dev,
475 audio_io_handle_t handle,
476 audio_devices_t devices,
477 audio_output_flags_t flags,
478 struct audio_config *config,
479 struct audio_stream_out **stream_out,
480 const char *address __unused)
482 ALOGV("usb:audio_hw::out adev_open_output_stream() handle:0x%X, device:0x%X, flags:0x%X",
483 handle, devices, flags);
485 struct audio_device *adev = (struct audio_device *)dev;
487 struct stream_out *out;
489 out = (struct stream_out *)calloc(1, sizeof(struct stream_out));
493 /* setup function pointers */
494 out->stream.common.get_sample_rate = out_get_sample_rate;
495 out->stream.common.set_sample_rate = out_set_sample_rate;
496 out->stream.common.get_buffer_size = out_get_buffer_size;
497 out->stream.common.get_channels = out_get_channels;
498 out->stream.common.get_format = out_get_format;
499 out->stream.common.set_format = out_set_format;
500 out->stream.common.standby = out_standby;
501 out->stream.common.dump = out_dump;
502 out->stream.common.set_parameters = out_set_parameters;
503 out->stream.common.get_parameters = out_get_parameters;
504 out->stream.common.add_audio_effect = out_add_audio_effect;
505 out->stream.common.remove_audio_effect = out_remove_audio_effect;
506 out->stream.get_latency = out_get_latency;
507 out->stream.set_volume = out_set_volume;
508 out->stream.write = out_write;
509 out->stream.get_render_position = out_get_render_position;
510 out->stream.get_presentation_position = out_get_presentation_position;
511 out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
515 out->profile = &adev->out_profile;
517 // build this to hand to the alsa_device_proxy
518 struct pcm_config proxy_config;
523 if (config->sample_rate == 0) {
524 proxy_config.rate = config->sample_rate = profile_get_default_sample_rate(out->profile);
525 } else if (profile_is_sample_rate_valid(out->profile, config->sample_rate)) {
526 proxy_config.rate = config->sample_rate;
528 proxy_config.rate = config->sample_rate = profile_get_default_sample_rate(out->profile);
533 if (config->format == AUDIO_FORMAT_DEFAULT) {
534 proxy_config.format = profile_get_default_format(out->profile);
535 config->format = audio_format_from_pcm_format(proxy_config.format);
537 enum pcm_format fmt = pcm_format_from_audio_format(config->format);
538 if (profile_is_format_valid(out->profile, fmt)) {
539 proxy_config.format = fmt;
541 proxy_config.format = profile_get_default_format(out->profile);
542 config->format = audio_format_from_pcm_format(proxy_config.format);
548 unsigned proposed_channel_count = profile_get_default_channel_count(out->profile);
549 if (k_force_channels) {
550 proposed_channel_count = k_force_channels;
551 } else if (config->channel_mask != AUDIO_CHANNEL_NONE) {
552 proposed_channel_count = audio_channel_count_from_out_mask(config->channel_mask);
554 /* we can expose any channel count mask, and emulate internally. */
555 config->channel_mask = audio_channel_out_mask_from_count(proposed_channel_count);
556 out->hal_channel_count = proposed_channel_count;
557 /* no validity checks are needed as proxy_prepare() forces channel_count to be valid.
558 * and we emulate any channel count discrepancies in out_write(). */
559 proxy_config.channels = proposed_channel_count;
561 proxy_prepare(&out->proxy, out->profile, &proxy_config);
563 /* TODO The retry mechanism isn't implemented in AudioPolicyManager/AudioFlinger. */
566 out->conversion_buffer = NULL;
567 out->conversion_buffer_size = 0;
571 *stream_out = &out->stream;
581 static void adev_close_output_stream(struct audio_hw_device *dev,
582 struct audio_stream_out *stream)
584 ALOGV("usb:audio_hw::out adev_close_output_stream()");
585 struct stream_out *out = (struct stream_out *)stream;
587 /* Close the pcm device */
588 out_standby(&stream->common);
590 free(out->conversion_buffer);
592 out->conversion_buffer = NULL;
593 out->conversion_buffer_size = 0;
598 static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev,
599 const struct audio_config *config)
601 /* TODO This needs to be calculated based on format/channels/rate */
608 static uint32_t in_get_sample_rate(const struct audio_stream *stream)
610 uint32_t rate = proxy_get_sample_rate(&((const struct stream_in *)stream)->proxy);
611 ALOGV("in_get_sample_rate() = %d", rate);
615 static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
617 ALOGV("in_set_sample_rate(%d) - NOPE", rate);
621 static size_t in_get_buffer_size(const struct audio_stream *stream)
623 const struct stream_in * in = ((const struct stream_in*)stream);
625 proxy_get_period_size(&in->proxy) * audio_stream_in_frame_size(&(in->stream));
626 ALOGV("in_get_buffer_size() = %zd", buffer_size);
631 static uint32_t in_get_channels(const struct audio_stream *stream)
633 /* TODO Here is the code we need when we support arbitrary channel counts
634 * alsa_device_proxy * proxy = ((struct stream_in*)stream)->proxy;
635 * unsigned channel_count = proxy_get_channel_count(proxy);
636 * uint32_t channel_mask = audio_channel_in_mask_from_count(channel_count);
637 * ALOGV("in_get_channels() = 0x%X count:%d", channel_mask, channel_count);
638 * return channel_mask;
640 /* TODO When AudioPolicyManager & AudioFlinger supports arbitrary channels
641 rewrite this to return the ACTUAL channel format */
642 return AUDIO_CHANNEL_IN_STEREO;
645 static audio_format_t in_get_format(const struct audio_stream *stream)
647 /* TODO Here is the code we need when we support arbitrary input formats
648 * alsa_device_proxy * proxy = ((struct stream_in*)stream)->proxy;
649 * audio_format_t format = audio_format_from_pcm_format(proxy_get_format(proxy));
650 * ALOGV("in_get_format() = %d", format);
653 /* Input only supports PCM16 */
654 /* TODO When AudioPolicyManager & AudioFlinger supports arbitrary input formats
655 rewrite this to return the ACTUAL channel format (above) */
656 return AUDIO_FORMAT_PCM_16_BIT;
659 static int in_set_format(struct audio_stream *stream, audio_format_t format)
661 ALOGV("in_set_format(%d) - NOPE", format);
666 static int in_standby(struct audio_stream *stream)
668 struct stream_in *in = (struct stream_in *)stream;
670 pthread_mutex_lock(&in->dev->lock);
671 pthread_mutex_lock(&in->lock);
674 proxy_close(&in->proxy);
678 pthread_mutex_unlock(&in->lock);
679 pthread_mutex_unlock(&in->dev->lock);
684 static int in_dump(const struct audio_stream *stream, int fd)
689 static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
691 ALOGV("usb: audio_hw::in in_set_parameters() keys:%s", kvpairs);
693 struct stream_in *in = (struct stream_in *)stream;
702 struct str_parms * parms = str_parms_create_str(kvpairs);
704 pthread_mutex_lock(&in->dev->lock);
705 pthread_mutex_lock(&in->lock);
708 param_val = str_parms_get_str(parms, "card", value, sizeof(value));
712 param_val = str_parms_get_str(parms, "device", value, sizeof(value));
714 device = atoi(value);
716 if (card >= 0 && device >= 0) {
717 /* cannot read pcm device info if playback is active */
721 int saved_card = in->profile->card;
722 int saved_device = in->profile->device;
723 in->profile->card = card;
724 in->profile->device = device;
725 ret_value = profile_read_device_info(in->profile) ? 0 : -EINVAL;
726 if (ret_value != 0) {
727 in->profile->card = saved_card;
728 in->profile->device = saved_device;
733 pthread_mutex_unlock(&in->lock);
734 pthread_mutex_unlock(&in->dev->lock);
736 str_parms_destroy(parms);
741 static char * in_get_parameters(const struct audio_stream *stream, const char *keys)
743 struct stream_in *in = (struct stream_in *)stream;
745 pthread_mutex_lock(&in->dev->lock);
746 pthread_mutex_lock(&in->lock);
748 char * params_str = device_get_parameters(in->profile, keys);
750 pthread_mutex_unlock(&in->lock);
751 pthread_mutex_unlock(&in->dev->lock);
756 static int in_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
761 static int in_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
766 static int in_set_gain(struct audio_stream_in *stream, float gain)
771 /* must be called with hw device and output stream mutexes locked */
772 static int start_input_stream(struct stream_in *in)
774 ALOGV("usb:audio_hw::start_input_stream(card:%d device:%d)",
775 in->profile->card, in->profile->device);
777 return proxy_open(&in->proxy);
780 /* TODO mutex stuff here (see out_write) */
781 static ssize_t in_read(struct audio_stream_in *stream, void* buffer, size_t bytes)
783 size_t num_read_buff_bytes = 0;
784 void * read_buff = buffer;
785 void * out_buff = buffer;
787 struct stream_in * in = (struct stream_in *)stream;
789 pthread_mutex_lock(&in->dev->lock);
790 pthread_mutex_lock(&in->lock);
792 if (start_input_stream(in) != 0) {
793 pthread_mutex_unlock(&in->dev->lock);
798 pthread_mutex_unlock(&in->dev->lock);
801 alsa_device_profile * profile = in->profile;
804 * OK, we need to figure out how much data to read to be able to output the requested
805 * number of bytes in the HAL format (16-bit, stereo).
807 num_read_buff_bytes = bytes;
808 int num_device_channels = proxy_get_channel_count(&in->proxy);
809 int num_req_channels = 2; /* always, for now */
811 if (num_device_channels != num_req_channels) {
812 num_read_buff_bytes = (num_device_channels * num_read_buff_bytes) / num_req_channels;
815 enum pcm_format format = proxy_get_format(&in->proxy);
816 if (format == PCM_FORMAT_S24_3LE) {
817 /* 24-bit USB device */
818 num_read_buff_bytes = (3 * num_read_buff_bytes) / 2;
819 } else if (format == PCM_FORMAT_S32_LE) {
820 /* 32-bit USB device */
821 num_read_buff_bytes = num_read_buff_bytes * 2;
824 /* Setup/Realloc the conversion buffer (if necessary). */
825 if (num_read_buff_bytes != bytes) {
826 if (num_read_buff_bytes > in->conversion_buffer_size) {
827 /*TODO Remove this when AudioPolicyManger/AudioFlinger support arbitrary formats
828 (and do these conversions themselves) */
829 in->conversion_buffer_size = num_read_buff_bytes;
830 in->conversion_buffer = realloc(in->conversion_buffer, in->conversion_buffer_size);
832 read_buff = in->conversion_buffer;
835 if (proxy_read(&in->proxy, read_buff, num_read_buff_bytes) == 0) {
837 * Do any conversions necessary to send the data in the format specified to/by the HAL
838 * (but different from the ALSA format), such as 24bit ->16bit, or 4chan -> 2chan.
840 if (format != PCM_FORMAT_S16_LE) {
841 /* we need to convert */
842 if (num_device_channels != num_req_channels) {
843 out_buff = read_buff;
846 if (format == PCM_FORMAT_S24_3LE) {
847 num_read_buff_bytes =
848 convert_24_3_to_16(read_buff, num_read_buff_bytes / 3, out_buff);
849 } else if (format == PCM_FORMAT_S32_LE) {
850 num_read_buff_bytes =
851 convert_32_to_16(read_buff, num_read_buff_bytes / 4, out_buff);
857 if (num_device_channels != num_req_channels) {
858 // ALOGV("chans dev:%d req:%d", num_device_channels, num_req_channels);
861 /* Num Channels conversion */
862 if (num_device_channels != num_req_channels) {
863 audio_format_t audio_format = in_get_format(&(in->stream.common));
864 unsigned sample_size_in_bytes = audio_bytes_per_sample(audio_format);
866 num_read_buff_bytes =
867 adjust_channels(read_buff, num_device_channels,
868 out_buff, num_req_channels,
869 sample_size_in_bytes, num_read_buff_bytes);
875 pthread_mutex_unlock(&in->lock);
877 return num_read_buff_bytes;
880 static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream)
885 static int adev_open_input_stream(struct audio_hw_device *dev,
886 audio_io_handle_t handle,
887 audio_devices_t devices,
888 struct audio_config *config,
889 struct audio_stream_in **stream_in,
890 audio_input_flags_t flags __unused,
891 const char *address __unused,
892 audio_source_t source __unused)
894 ALOGV("usb: in adev_open_input_stream() rate:%" PRIu32 ", chanMask:0x%" PRIX32 ", fmt:%" PRIu8,
895 config->sample_rate, config->channel_mask, config->format);
897 struct stream_in *in = (struct stream_in *)calloc(1, sizeof(struct stream_in));
903 /* setup function pointers */
904 in->stream.common.get_sample_rate = in_get_sample_rate;
905 in->stream.common.set_sample_rate = in_set_sample_rate;
906 in->stream.common.get_buffer_size = in_get_buffer_size;
907 in->stream.common.get_channels = in_get_channels;
908 in->stream.common.get_format = in_get_format;
909 in->stream.common.set_format = in_set_format;
910 in->stream.common.standby = in_standby;
911 in->stream.common.dump = in_dump;
912 in->stream.common.set_parameters = in_set_parameters;
913 in->stream.common.get_parameters = in_get_parameters;
914 in->stream.common.add_audio_effect = in_add_audio_effect;
915 in->stream.common.remove_audio_effect = in_remove_audio_effect;
917 in->stream.set_gain = in_set_gain;
918 in->stream.read = in_read;
919 in->stream.get_input_frames_lost = in_get_input_frames_lost;
921 in->dev = (struct audio_device *)dev;
923 in->profile = &in->dev->in_profile;
925 struct pcm_config proxy_config;
928 if (config->sample_rate == 0) {
929 proxy_config.rate = config->sample_rate = profile_get_default_sample_rate(in->profile);
930 } else if (profile_is_sample_rate_valid(in->profile, config->sample_rate)) {
931 proxy_config.rate = config->sample_rate;
933 proxy_config.rate = config->sample_rate = profile_get_default_sample_rate(in->profile);
938 /* until the framework supports format conversion, just take what it asks for
939 * i.e. AUDIO_FORMAT_PCM_16_BIT */
940 if (config->format == AUDIO_FORMAT_DEFAULT) {
941 /* just return AUDIO_FORMAT_PCM_16_BIT until the framework supports other input
943 config->format = AUDIO_FORMAT_PCM_16_BIT;
944 proxy_config.format = PCM_FORMAT_S16_LE;
945 } else if (config->format == AUDIO_FORMAT_PCM_16_BIT) {
946 /* Always accept AUDIO_FORMAT_PCM_16_BIT until the framework supports other input
948 proxy_config.format = PCM_FORMAT_S16_LE;
950 /* When the framework support other formats, validate here */
951 config->format = AUDIO_FORMAT_PCM_16_BIT;
952 proxy_config.format = PCM_FORMAT_S16_LE;
956 if (config->channel_mask == AUDIO_CHANNEL_NONE) {
957 /* just return AUDIO_CHANNEL_IN_STEREO until the framework supports other input
959 config->channel_mask = AUDIO_CHANNEL_IN_STEREO;
961 } else if (config->channel_mask != AUDIO_CHANNEL_IN_STEREO) {
962 /* allow only stereo capture for now */
963 config->channel_mask = AUDIO_CHANNEL_IN_STEREO;
966 // proxy_config.channels = 0; /* don't change */
967 proxy_config.channels = profile_get_default_channel_count(in->profile);
969 proxy_prepare(&in->proxy, in->profile, &proxy_config);
973 in->conversion_buffer = NULL;
974 in->conversion_buffer_size = 0;
976 *stream_in = &in->stream;
981 static void adev_close_input_stream(struct audio_hw_device *dev, struct audio_stream_in *stream)
983 struct stream_in *in = (struct stream_in *)stream;
985 /* Close the pcm device */
986 in_standby(&stream->common);
988 free(in->conversion_buffer);
996 static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs)
1001 static char * adev_get_parameters(const struct audio_hw_device *dev, const char *keys)
1006 static int adev_init_check(const struct audio_hw_device *dev)
1011 static int adev_set_voice_volume(struct audio_hw_device *dev, float volume)
1016 static int adev_set_master_volume(struct audio_hw_device *dev, float volume)
1021 static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode)
1026 static int adev_set_mic_mute(struct audio_hw_device *dev, bool state)
1031 static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state)
1036 static int adev_dump(const audio_hw_device_t *device, int fd)
1041 static int adev_close(hw_device_t *device)
1043 struct audio_device *adev = (struct audio_device *)device;
1049 static int adev_open(const hw_module_t* module, const char* name, hw_device_t** device)
1051 if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0)
1054 struct audio_device *adev = calloc(1, sizeof(struct audio_device));
1058 profile_init(&adev->out_profile, PCM_OUT);
1059 profile_init(&adev->in_profile, PCM_IN);
1061 adev->hw_device.common.tag = HARDWARE_DEVICE_TAG;
1062 adev->hw_device.common.version = AUDIO_DEVICE_API_VERSION_2_0;
1063 adev->hw_device.common.module = (struct hw_module_t *)module;
1064 adev->hw_device.common.close = adev_close;
1066 adev->hw_device.init_check = adev_init_check;
1067 adev->hw_device.set_voice_volume = adev_set_voice_volume;
1068 adev->hw_device.set_master_volume = adev_set_master_volume;
1069 adev->hw_device.set_mode = adev_set_mode;
1070 adev->hw_device.set_mic_mute = adev_set_mic_mute;
1071 adev->hw_device.get_mic_mute = adev_get_mic_mute;
1072 adev->hw_device.set_parameters = adev_set_parameters;
1073 adev->hw_device.get_parameters = adev_get_parameters;
1074 adev->hw_device.get_input_buffer_size = adev_get_input_buffer_size;
1075 adev->hw_device.open_output_stream = adev_open_output_stream;
1076 adev->hw_device.close_output_stream = adev_close_output_stream;
1077 adev->hw_device.open_input_stream = adev_open_input_stream;
1078 adev->hw_device.close_input_stream = adev_close_input_stream;
1079 adev->hw_device.dump = adev_dump;
1081 *device = &adev->hw_device.common;
1086 static struct hw_module_methods_t hal_module_methods = {
1090 struct audio_module HAL_MODULE_INFO_SYM = {
1092 .tag = HARDWARE_MODULE_TAG,
1093 .module_api_version = AUDIO_MODULE_API_VERSION_0_1,
1094 .hal_api_version = HARDWARE_HAL_API_VERSION,
1095 .id = AUDIO_HARDWARE_MODULE_ID,
1096 .name = "USB audio HW HAL",
1097 .author = "The Android Open Source Project",
1098 .methods = &hal_module_methods,