1 /* 2 * Copyright (C) 2013-2014 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/str_parms.h> 21 #include <cutils/list.h> 22 #include <hardware/audio.h> 23 24 #include <tinyalsa/asoundlib.h> 25 #include <tinycompress/tinycompress.h> 26 27 #include <audio_route/audio_route.h> 28 #include "voice.h" 29 30 #define VISUALIZER_LIBRARY_PATH "/system/lib/soundfx/libqcomvisualizer.so" 31 #define OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH "/system/lib/soundfx/libqcompostprocbundle.so" 32 33 /* Flags used to initialize acdb_settings variable that goes to ACDB library */ 34 #define DMIC_FLAG 0x00000002 35 #define TTY_MODE_OFF 0x00000010 36 #define TTY_MODE_FULL 0x00000020 37 #define TTY_MODE_VCO 0x00000040 38 #define TTY_MODE_HCO 0x00000080 39 #define TTY_MODE_CLEAR 0xFFFFFF0F 40 41 #define ACDB_DEV_TYPE_OUT 1 42 #define ACDB_DEV_TYPE_IN 2 43 44 #define MAX_SUPPORTED_CHANNEL_MASKS 2 45 #define DEFAULT_HDMI_OUT_CHANNELS 2 46 47 typedef int snd_device_t; 48 49 /* These are the supported use cases by the hardware. 50 * Each usecase is mapped to a specific PCM device. 51 * Refer to pcm_device_table[]. 52 */ 53 enum { 54 USECASE_INVALID = -1, 55 /* Playback usecases */ 56 USECASE_AUDIO_PLAYBACK_DEEP_BUFFER = 0, 57 USECASE_AUDIO_PLAYBACK_LOW_LATENCY, 58 USECASE_AUDIO_PLAYBACK_MULTI_CH, 59 USECASE_AUDIO_PLAYBACK_OFFLOAD, 60 61 /* HFP Use case*/ 62 USECASE_AUDIO_HFP_SCO, 63 USECASE_AUDIO_HFP_SCO_WB, 64 65 /* Capture usecases */ 66 USECASE_AUDIO_RECORD, 67 USECASE_AUDIO_RECORD_LOW_LATENCY, 68 69 USECASE_VOICE_CALL, 70 71 /* Voice extension usecases */ 72 USECASE_VOICE2_CALL, 73 USECASE_VOLTE_CALL, 74 USECASE_QCHAT_CALL, 75 USECASE_VOWLAN_CALL, 76 USECASE_INCALL_REC_UPLINK, 77 USECASE_INCALL_REC_DOWNLINK, 78 USECASE_INCALL_REC_UPLINK_AND_DOWNLINK, 79 80 USECASE_AUDIO_PLAYBACK_AFE_PROXY, 81 USECASE_AUDIO_RECORD_AFE_PROXY, 82 83 AUDIO_USECASE_MAX 84 }; 85 86 const char * const use_case_table[AUDIO_USECASE_MAX]; 87 88 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) 89 90 /* 91 * tinyAlsa library interprets period size as number of frames 92 * one frame = channel_count * sizeof (pcm sample) 93 * so if format = 16-bit PCM and channels = Stereo, frame size = 2 ch * 2 = 4 bytes 94 * DEEP_BUFFER_OUTPUT_PERIOD_SIZE = 1024 means 1024 * 4 = 4096 bytes 95 * We should take care of returning proper size when AudioFlinger queries for 96 * the buffer size of an input/output stream 97 */ 98 99 enum { 100 OFFLOAD_CMD_EXIT, /* exit compress offload thread loop*/ 101 OFFLOAD_CMD_DRAIN, /* send a full drain request to DSP */ 102 OFFLOAD_CMD_PARTIAL_DRAIN, /* send a partial drain request to DSP */ 103 OFFLOAD_CMD_WAIT_FOR_BUFFER, /* wait for buffer released by DSP */ 104 }; 105 106 enum { 107 OFFLOAD_STATE_IDLE, 108 OFFLOAD_STATE_PLAYING, 109 OFFLOAD_STATE_PAUSED, 110 }; 111 112 struct offload_cmd { 113 struct listnode node; 114 int cmd; 115 int data[]; 116 }; 117 118 struct stream_out { 119 struct audio_stream_out stream; 120 pthread_mutex_t lock; /* see note below on mutex acquisition order */ 121 pthread_cond_t cond; 122 struct pcm_config config; 123 struct compr_config compr_config; 124 struct pcm *pcm; 125 struct compress *compr; 126 int standby; 127 int pcm_device_id; 128 unsigned int sample_rate; 129 audio_channel_mask_t channel_mask; 130 audio_format_t format; 131 audio_devices_t devices; 132 audio_output_flags_t flags; 133 audio_usecase_t usecase; 134 /* Array of supported channel mask configurations. +1 so that the last entry is always 0 */ 135 audio_channel_mask_t supported_channel_masks[MAX_SUPPORTED_CHANNEL_MASKS + 1]; 136 bool muted; 137 uint64_t written; /* total frames written, not cleared when entering standby */ 138 audio_io_handle_t handle; 139 140 int non_blocking; 141 int playback_started; 142 int offload_state; 143 pthread_cond_t offload_cond; 144 pthread_t offload_thread; 145 struct listnode offload_cmd_list; 146 bool offload_thread_blocked; 147 148 stream_callback_t offload_callback; 149 void *offload_cookie; 150 struct compr_gapless_mdata gapless_mdata; 151 int send_new_metadata; 152 153 struct audio_device *dev; 154 }; 155 156 struct stream_in { 157 struct audio_stream_in stream; 158 pthread_mutex_t lock; /* see note below on mutex acquisition order */ 159 struct pcm_config config; 160 struct pcm *pcm; 161 int standby; 162 int source; 163 int pcm_device_id; 164 audio_devices_t device; 165 audio_channel_mask_t channel_mask; 166 audio_usecase_t usecase; 167 bool enable_aec; 168 bool enable_ns; 169 170 struct audio_device *dev; 171 }; 172 173 typedef enum { 174 PCM_PLAYBACK, 175 PCM_CAPTURE, 176 VOICE_CALL, 177 PCM_HFP_CALL 178 } usecase_type_t; 179 180 union stream_ptr { 181 struct stream_in *in; 182 struct stream_out *out; 183 }; 184 185 struct audio_usecase { 186 struct listnode list; 187 audio_usecase_t id; 188 usecase_type_t type; 189 audio_devices_t devices; 190 snd_device_t out_snd_device; 191 snd_device_t in_snd_device; 192 union stream_ptr stream; 193 }; 194 195 struct audio_device { 196 struct audio_hw_device device; 197 pthread_mutex_t lock; /* see note below on mutex acquisition order */ 198 struct mixer *mixer; 199 audio_mode_t mode; 200 struct stream_in *active_input; 201 struct stream_out *primary_output; 202 struct stream_out *voice_tx_output; 203 struct stream_out *current_call_output; 204 bool bluetooth_nrec; 205 bool screen_off; 206 int *snd_dev_ref_cnt; 207 struct listnode usecase_list; 208 struct audio_route *audio_route; 209 int acdb_settings; 210 bool speaker_lr_swap; 211 struct voice voice; 212 unsigned int cur_hdmi_channels; 213 bool bt_wb_speech_enabled; 214 bool mic_muted; 215 bool enable_voicerx; 216 217 int snd_card; 218 void *platform; 219 void *extspk; 220 221 void *visualizer_lib; 222 int (*visualizer_start_output)(audio_io_handle_t, int); 223 int (*visualizer_stop_output)(audio_io_handle_t, int); 224 225 /* The pcm_params use_case_table is loaded by adev_verify_devices() upon 226 * calling adev_open(). 227 * 228 * If an entry is not NULL, it can be used to determine if extended precision 229 * or other capabilities are present for the device corresponding to that usecase. 230 */ 231 struct pcm_params *use_case_table[AUDIO_USECASE_MAX]; 232 void *offload_effects_lib; 233 int (*offload_effects_start_output)(audio_io_handle_t, int); 234 int (*offload_effects_stop_output)(audio_io_handle_t, int); 235 }; 236 237 int pcm_ioctl(void *pcm, int request, ...); 238 239 int select_devices(struct audio_device *adev, 240 audio_usecase_t uc_id); 241 242 int disable_audio_route(struct audio_device *adev, 243 struct audio_usecase *usecase); 244 245 int disable_snd_device(struct audio_device *adev, 246 snd_device_t snd_device); 247 248 int enable_snd_device(struct audio_device *adev, 249 snd_device_t snd_device); 250 251 int enable_audio_route(struct audio_device *adev, 252 struct audio_usecase *usecase); 253 254 struct audio_usecase *get_usecase_from_list(struct audio_device *adev, 255 audio_usecase_t uc_id); 256 257 #define LITERAL_TO_STRING(x) #x 258 #define CHECK(condition) LOG_ALWAYS_FATAL_IF(!(condition), "%s",\ 259 __FILE__ ":" LITERAL_TO_STRING(__LINE__)\ 260 " ASSERT_FATAL(" #condition ") failed.") 261 262 /* 263 * NOTE: when multiple mutexes have to be acquired, always take the 264 * stream_in or stream_out mutex first, followed by the audio_device mutex. 265 */ 266 267 #endif // QCOM_AUDIO_HW_H 268