1 /* 2 * Copyright (C) 2013 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 #ifndef QCOM_AUDIO_HW_H 18 #define QCOM_AUDIO_HW_H 19 20 #include <cutils/list.h> 21 #include <hardware/audio.h> 22 23 #include <tinyalsa/asoundlib.h> 24 #include <tinycompress/tinycompress.h> 25 26 #include <audio_route/audio_route.h> 27 28 #define VISUALIZER_LIBRARY_PATH "/system/lib/soundfx/libqcomvisualizer.so" 29 30 /* Flags used to initialize acdb_settings variable that goes to ACDB library */ 31 #define DMIC_FLAG 0x00000002 32 #define TTY_MODE_OFF 0x00000010 33 #define TTY_MODE_FULL 0x00000020 34 #define TTY_MODE_VCO 0x00000040 35 #define TTY_MODE_HCO 0x00000080 36 #define TTY_MODE_CLEAR 0xFFFFFF0F 37 38 #define ACDB_DEV_TYPE_OUT 1 39 #define ACDB_DEV_TYPE_IN 2 40 41 #define MAX_SUPPORTED_CHANNEL_MASKS 2 42 #define DEFAULT_HDMI_OUT_CHANNELS 2 43 44 typedef int snd_device_t; 45 46 /* These are the supported use cases by the hardware. 47 * Each usecase is mapped to a specific PCM device. 48 * Refer to pcm_device_table[]. 49 */ 50 typedef enum { 51 USECASE_INVALID = -1, 52 /* Playback usecases */ 53 USECASE_AUDIO_PLAYBACK_DEEP_BUFFER = 0, 54 USECASE_AUDIO_PLAYBACK_LOW_LATENCY, 55 USECASE_AUDIO_PLAYBACK_MULTI_CH, 56 USECASE_AUDIO_PLAYBACK_OFFLOAD, 57 58 /* Capture usecases */ 59 USECASE_AUDIO_RECORD, 60 USECASE_AUDIO_RECORD_LOW_LATENCY, 61 62 USECASE_VOICE_CALL, 63 AUDIO_USECASE_MAX 64 } audio_usecase_t; 65 66 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) 67 68 /* 69 * tinyAlsa library interprets period size as number of frames 70 * one frame = channel_count * sizeof (pcm sample) 71 * so if format = 16-bit PCM and channels = Stereo, frame size = 2 ch * 2 = 4 bytes 72 * DEEP_BUFFER_OUTPUT_PERIOD_SIZE = 1024 means 1024 * 4 = 4096 bytes 73 * We should take care of returning proper size when AudioFlinger queries for 74 * the buffer size of an input/output stream 75 */ 76 77 enum { 78 OFFLOAD_CMD_EXIT, /* exit compress offload thread loop*/ 79 OFFLOAD_CMD_DRAIN, /* send a full drain request to DSP */ 80 OFFLOAD_CMD_PARTIAL_DRAIN, /* send a partial drain request to DSP */ 81 OFFLOAD_CMD_WAIT_FOR_BUFFER, /* wait for buffer released by DSP */ 82 }; 83 84 enum { 85 OFFLOAD_STATE_IDLE, 86 OFFLOAD_STATE_PLAYING, 87 OFFLOAD_STATE_PAUSED, 88 }; 89 90 struct offload_cmd { 91 struct listnode node; 92 int cmd; 93 int data[]; 94 }; 95 96 struct stream_out { 97 struct audio_stream_out stream; 98 pthread_mutex_t lock; /* see note below on mutex acquisition order */ 99 pthread_cond_t cond; 100 struct pcm_config config; 101 struct compr_config compr_config; 102 struct pcm *pcm; 103 struct compress *compr; 104 int standby; 105 int pcm_device_id; 106 unsigned int sample_rate; 107 audio_channel_mask_t channel_mask; 108 audio_format_t format; 109 audio_devices_t devices; 110 audio_output_flags_t flags; 111 audio_usecase_t usecase; 112 /* Array of supported channel mask configurations. +1 so that the last entry is always 0 */ 113 audio_channel_mask_t supported_channel_masks[MAX_SUPPORTED_CHANNEL_MASKS + 1]; 114 bool muted; 115 uint64_t written; /* total frames written, not cleared when entering standby */ 116 audio_io_handle_t handle; 117 118 int non_blocking; 119 int playback_started; 120 int offload_state; 121 pthread_cond_t offload_cond; 122 pthread_t offload_thread; 123 struct listnode offload_cmd_list; 124 bool offload_thread_blocked; 125 126 stream_callback_t offload_callback; 127 void *offload_cookie; 128 struct compr_gapless_mdata gapless_mdata; 129 int send_new_metadata; 130 131 struct audio_device *dev; 132 }; 133 134 struct stream_in { 135 struct audio_stream_in stream; 136 pthread_mutex_t lock; /* see note below on mutex acquisition order */ 137 struct pcm_config config; 138 struct pcm *pcm; 139 int standby; 140 int source; 141 int pcm_device_id; 142 int device; 143 audio_channel_mask_t channel_mask; 144 audio_usecase_t usecase; 145 bool enable_aec; 146 147 struct audio_device *dev; 148 }; 149 150 typedef enum { 151 PCM_PLAYBACK, 152 PCM_CAPTURE, 153 VOICE_CALL 154 } usecase_type_t; 155 156 union stream_ptr { 157 struct stream_in *in; 158 struct stream_out *out; 159 }; 160 161 struct audio_usecase { 162 struct listnode list; 163 audio_usecase_t id; 164 usecase_type_t type; 165 audio_devices_t devices; 166 snd_device_t out_snd_device; 167 snd_device_t in_snd_device; 168 union stream_ptr stream; 169 }; 170 171 struct audio_device { 172 struct audio_hw_device device; 173 pthread_mutex_t lock; /* see note below on mutex acquisition order */ 174 struct mixer *mixer; 175 audio_mode_t mode; 176 audio_devices_t out_device; 177 struct stream_in *active_input; 178 struct stream_out *primary_output; 179 int in_call; 180 float voice_volume; 181 bool mic_mute; 182 int tty_mode; 183 bool bluetooth_nrec; 184 bool screen_off; 185 struct pcm *voice_call_rx; 186 struct pcm *voice_call_tx; 187 int *snd_dev_ref_cnt; 188 struct listnode usecase_list; 189 struct audio_route *audio_route; 190 int acdb_settings; 191 bool speaker_lr_swap; 192 unsigned int cur_hdmi_channels; 193 194 void *platform; 195 196 void *visualizer_lib; 197 int (*visualizer_start_output)(audio_io_handle_t); 198 int (*visualizer_stop_output)(audio_io_handle_t); 199 }; 200 201 /* 202 * NOTE: when multiple mutexes have to be acquired, always take the 203 * stream_in or stream_out mutex first, followed by the audio_device mutex. 204 */ 205 206 #endif // QCOM_AUDIO_HW_H 207