• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 NVIDIA_AUDIO_HW_H
18  #define NVIDIA_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  /* TODO: remove resampler if possible when AudioFlinger supports downsampling from 48 to 8 */
26  #include <audio_utils/resampler.h>
27  #include <audio_route/audio_route.h>
28  
29  /* Retry for delay in FW loading*/
30  #define RETRY_NUMBER 10
31  #define RETRY_US 500000
32  
33  #ifdef __LP64__
34  #define OFFLOAD_FX_LIBRARY_PATH "/system/lib64/soundfx/libnvvisualizer.so"
35  #else
36  #define OFFLOAD_FX_LIBRARY_PATH "/system/lib/soundfx/libnvvisualizer.so"
37  #endif
38  
39  #define HTC_ACOUSTIC_LIBRARY_PATH "/vendor/lib/libhtcacoustic.so"
40  
41  #ifdef PREPROCESSING_ENABLED
42  #include <audio_utils/echo_reference.h>
43  #define MAX_PREPROCESSORS 3
44  struct effect_info_s {
45      effect_handle_t effect_itfe;
46      size_t num_channel_configs;
47      channel_config_t *channel_configs;
48  };
49  #endif
50  
51  #ifdef __LP64__
52  #define SOUND_TRIGGER_HAL_LIBRARY_PATH "/system/lib64/hw/sound_trigger.primary.flounder.so"
53  #else
54  #define SOUND_TRIGGER_HAL_LIBRARY_PATH "/system/lib/hw/sound_trigger.primary.flounder.so"
55  #endif
56  
57  #define TTY_MODE_OFF    1
58  #define TTY_MODE_FULL   2
59  #define TTY_MODE_VCO    4
60  #define TTY_MODE_HCO    8
61  
62  #define DUALMIC_CONFIG_NONE 0
63  #define DUALMIC_CONFIG_1 1
64  
65  /* Sound devices specific to the platform
66   * The DEVICE_OUT_* and DEVICE_IN_* should be mapped to these sound
67   * devices to enable corresponding mixer paths
68   */
69  enum {
70      SND_DEVICE_NONE = 0,
71  
72      /* Playback devices */
73      SND_DEVICE_MIN,
74      SND_DEVICE_OUT_BEGIN = SND_DEVICE_MIN,
75      SND_DEVICE_OUT_HANDSET = SND_DEVICE_OUT_BEGIN,
76      SND_DEVICE_OUT_SPEAKER,
77      SND_DEVICE_OUT_HEADPHONES,
78      SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES,
79      SND_DEVICE_OUT_VOICE_HANDSET,
80      SND_DEVICE_OUT_VOICE_SPEAKER,
81      SND_DEVICE_OUT_VOICE_HEADPHONES,
82      SND_DEVICE_OUT_HDMI,
83      SND_DEVICE_OUT_SPEAKER_AND_HDMI,
84      SND_DEVICE_OUT_BT_SCO,
85      SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES,
86      SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES,
87      SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET,
88      SND_DEVICE_OUT_END,
89  
90      /*
91       * Note: IN_BEGIN should be same as OUT_END because total number of devices
92       * SND_DEVICES_MAX should not exceed MAX_RX + MAX_TX devices.
93       */
94      /* Capture devices */
95      SND_DEVICE_IN_BEGIN = SND_DEVICE_OUT_END,
96      SND_DEVICE_IN_HANDSET_MIC  = SND_DEVICE_IN_BEGIN,
97      SND_DEVICE_IN_SPEAKER_MIC,
98      SND_DEVICE_IN_HEADSET_MIC,
99      SND_DEVICE_IN_HANDSET_MIC_AEC,
100      SND_DEVICE_IN_SPEAKER_MIC_AEC,
101      SND_DEVICE_IN_HEADSET_MIC_AEC,
102      SND_DEVICE_IN_VOICE_SPEAKER_MIC,
103      SND_DEVICE_IN_VOICE_HEADSET_MIC,
104      SND_DEVICE_IN_HDMI_MIC,
105      SND_DEVICE_IN_BT_SCO_MIC,
106      SND_DEVICE_IN_CAMCORDER_MIC,
107      SND_DEVICE_IN_VOICE_DMIC_1,
108      SND_DEVICE_IN_VOICE_SPEAKER_DMIC_1,
109      SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC,
110      SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC,
111      SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC,
112      SND_DEVICE_IN_VOICE_REC_HEADSET_MIC,
113      SND_DEVICE_IN_VOICE_REC_MIC,
114      SND_DEVICE_IN_VOICE_REC_DMIC_1,
115      SND_DEVICE_IN_VOICE_REC_DMIC_NS_1,
116      SND_DEVICE_IN_LOOPBACK_AEC,
117      SND_DEVICE_IN_END,
118  
119      SND_DEVICE_MAX = SND_DEVICE_IN_END,
120  
121  };
122  
123  
124  #define MIXER_CARD 0
125  #define SOUND_CARD 0
126  
127  /*
128   * tinyAlsa library interprets period size as number of frames
129   * one frame = channel_count * sizeof (pcm sample)
130   * so if format = 16-bit PCM and channels = Stereo, frame size = 2 ch * 2 = 4 bytes
131   * DEEP_BUFFER_OUTPUT_PERIOD_SIZE = 1024 means 1024 * 4 = 4096 bytes
132   * We should take care of returning proper size when AudioFlinger queries for
133   * the buffer size of an input/output stream
134   */
135  #define PLAYBACK_PERIOD_SIZE 256
136  #define PLAYBACK_PERIOD_COUNT 2
137  #define PLAYBACK_DEFAULT_CHANNEL_COUNT 2
138  #define PLAYBACK_DEFAULT_SAMPLING_RATE 48000
139  #define PLAYBACK_START_THRESHOLD(size, count) (((size) * (count)) - 1)
140  #define PLAYBACK_STOP_THRESHOLD(size, count) ((size) * ((count) + 2))
141  #define PLAYBACK_AVAILABLE_MIN 1
142  
143  
144  #define SCO_PERIOD_SIZE 168
145  #define SCO_PERIOD_COUNT 2
146  #define SCO_DEFAULT_CHANNEL_COUNT 2
147  #define SCO_DEFAULT_SAMPLING_RATE 8000
148  #define SCO_START_THRESHOLD 335
149  #define SCO_STOP_THRESHOLD 336
150  #define SCO_AVAILABLE_MIN 1
151  
152  #define PLAYBACK_HDMI_MULTI_PERIOD_SIZE  1024
153  #define PLAYBACK_HDMI_MULTI_PERIOD_COUNT 4
154  #define PLAYBACK_HDMI_MULTI_DEFAULT_CHANNEL_COUNT 6
155  #define PLAYBACK_HDMI_MULTI_PERIOD_BYTES \
156      (PLAYBACK_HDMI_MULTI_PERIOD_SIZE * PLAYBACK_HDMI_MULTI_DEFAULT_CHANNEL_COUNT * 2)
157  #define PLAYBACK_HDMI_MULTI_START_THRESHOLD 4095
158  #define PLAYBACK_HDMI_MULTI_STOP_THRESHOLD 4096
159  #define PLAYBACK_HDMI_MULTI_AVAILABLE_MIN 1
160  
161  #define PLAYBACK_HDMI_DEFAULT_CHANNEL_COUNT   2
162  
163  #define CAPTURE_PERIOD_SIZE 1024
164  #define CAPTURE_PERIOD_SIZE_LOW_LATENCY 256
165  #define CAPTURE_PERIOD_COUNT 2
166  #define CAPTURE_PERIOD_COUNT_LOW_LATENCY 2
167  #define CAPTURE_DEFAULT_CHANNEL_COUNT 2
168  #define CAPTURE_DEFAULT_SAMPLING_RATE 48000
169  #define CAPTURE_START_THRESHOLD 1
170  
171  #define COMPRESS_CARD       0
172  #define COMPRESS_DEVICE     5
173  #define COMPRESS_OFFLOAD_FRAGMENT_SIZE (32 * 1024)
174  #define COMPRESS_OFFLOAD_NUM_FRAGMENTS 4
175  /* ToDo: Check and update a proper value in msec */
176  #define COMPRESS_OFFLOAD_PLAYBACK_LATENCY 96
177  #define COMPRESS_PLAYBACK_VOLUME_MAX 0x10000 //NV suggested value
178  
179  #define DEEP_BUFFER_OUTPUT_SAMPLING_RATE 48000
180  #define DEEP_BUFFER_OUTPUT_PERIOD_SIZE 480
181  #define DEEP_BUFFER_OUTPUT_PERIOD_COUNT 8
182  
183  #define MAX_SUPPORTED_CHANNEL_MASKS 2
184  
185  typedef int snd_device_t;
186  
187  /* These are the supported use cases by the hardware.
188   * Each usecase is mapped to a specific PCM device.
189   * Refer to pcm_device_table[].
190   */
191  typedef enum {
192      USECASE_INVALID = -1,
193      /* Playback usecases */
194      USECASE_AUDIO_PLAYBACK = 0,
195      USECASE_AUDIO_PLAYBACK_MULTI_CH,
196      USECASE_AUDIO_PLAYBACK_OFFLOAD,
197      USECASE_AUDIO_PLAYBACK_DEEP_BUFFER,
198  
199      /* Capture usecases */
200      USECASE_AUDIO_CAPTURE,
201      USECASE_AUDIO_CAPTURE_HOTWORD,
202  
203      USECASE_VOICE_CALL,
204      AUDIO_USECASE_MAX
205  } audio_usecase_t;
206  
207  #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
208  
209  /*
210   * tinyAlsa library interprets period size as number of frames
211   * one frame = channel_count * sizeof (pcm sample)
212   * so if format = 16-bit PCM and channels = Stereo, frame size = 2 ch * 2 = 4 bytes
213   * DEEP_BUFFER_OUTPUT_PERIOD_SIZE = 1024 means 1024 * 4 = 4096 bytes
214   * We should take care of returning proper size when AudioFlinger queries for
215   * the buffer size of an input/output stream
216   */
217  
218  enum {
219      OFFLOAD_CMD_EXIT,               /* exit compress offload thread loop*/
220      OFFLOAD_CMD_DRAIN,              /* send a full drain request to DSP */
221      OFFLOAD_CMD_PARTIAL_DRAIN,      /* send a partial drain request to DSP */
222      OFFLOAD_CMD_WAIT_FOR_BUFFER,    /* wait for buffer released by DSP */
223  };
224  
225  enum {
226      OFFLOAD_STATE_IDLE,
227      OFFLOAD_STATE_PLAYING,
228      OFFLOAD_STATE_PAUSED,
229      OFFLOAD_STATE_PAUSED_FLUSHED,
230  };
231  
232  typedef enum {
233      PCM_PLAYBACK = 0x1,
234      PCM_CAPTURE = 0x2,
235      VOICE_CALL = 0x4,
236      PCM_HOTWORD_STREAMING = 0x8,
237      PCM_CAPTURE_LOW_LATENCY = 0x10,
238  } usecase_type_t;
239  
240  struct offload_cmd {
241      struct listnode node;
242      int             cmd;
243      int             data[];
244  };
245  
246  struct pcm_device_profile {
247      struct pcm_config config;
248      int               card;
249      int               id;
250      usecase_type_t    type;
251      audio_devices_t   devices;
252  };
253  
254  struct pcm_device {
255      struct listnode            stream_list_node;
256      struct pcm_device_profile* pcm_profile;
257      struct pcm*                pcm;
258      int                        status;
259      /* TODO: remove resampler if possible when AudioFlinger supports downsampling from 48 to 8 */
260      struct resampler_itfe*     resampler;
261      int16_t*                   res_buffer;
262      size_t                     res_byte_count;
263      int                        sound_trigger_handle;
264  };
265  
266  struct stream_out {
267      struct audio_stream_out     stream;
268      pthread_mutex_t             lock; /* see note below on mutex acquisition order */
269      pthread_mutex_t             pre_lock; /* acquire before lock to avoid DOS by playback thread */
270      pthread_cond_t              cond;
271      struct pcm_config           config;
272      struct listnode             pcm_dev_list;
273      struct compr_config         compr_config;
274      struct compress*            compr;
275      int                         standby;
276      unsigned int                sample_rate;
277      audio_channel_mask_t        channel_mask;
278      audio_format_t              format;
279      audio_devices_t             devices;
280      audio_output_flags_t        flags;
281      audio_usecase_t             usecase;
282      /* Array of supported channel mask configurations. +1 so that the last entry is always 0 */
283      audio_channel_mask_t        supported_channel_masks[MAX_SUPPORTED_CHANNEL_MASKS + 1];
284      bool                        muted;
285      /* total frames written, not cleared when entering standby */
286      uint64_t                    written;
287      audio_io_handle_t           handle;
288  
289      int                         non_blocking;
290      int                         offload_state;
291      pthread_cond_t              offload_cond;
292      pthread_t                   offload_thread;
293      struct listnode             offload_cmd_list;
294      bool                        offload_thread_blocked;
295  
296      stream_callback_t           offload_callback;
297      void*                       offload_cookie;
298      struct compr_gapless_mdata  gapless_mdata;
299      int                         send_new_metadata;
300  
301      struct audio_device*        dev;
302  
303  #ifdef PREPROCESSING_ENABLED
304      struct echo_reference_itfe *echo_reference;
305      // echo_reference_generation indicates if the echo reference used by the output stream is
306      // in sync with the one known by the audio_device. When different from the generation stored
307      // in the audio_device the output stream must release the echo reference.
308      // always modified with audio device and stream mutex locked.
309      int32_t echo_reference_generation;
310  #endif
311  
312      bool                         is_fastmixer_affinity_set;
313  };
314  
315  struct stream_in {
316      struct audio_stream_in              stream;
317      pthread_mutex_t                     lock; /* see note below on mutex acquisition order */
318      pthread_mutex_t                     pre_lock; /* acquire before lock to avoid DOS by
319                                                       capture thread */
320      struct pcm_config                   config;
321      struct listnode                     pcm_dev_list;
322      int                                 standby;
323      audio_source_t                      source;
324      audio_devices_t                     devices;
325      uint32_t                            main_channels;
326      audio_usecase_t                     usecase;
327      usecase_type_t                      usecase_type;
328      bool                                enable_aec;
329      audio_input_flags_t                 input_flags;
330  
331      /* TODO: remove resampler if possible when AudioFlinger supports downsampling from 48 to 8 */
332      unsigned int                        requested_rate;
333      struct resampler_itfe*              resampler;
334      struct resampler_buffer_provider    buf_provider;
335      int                                 read_status;
336      int16_t*                            read_buf;
337      size_t                              read_buf_size;
338      size_t                              read_buf_frames;
339  
340      int16_t *proc_buf_in;
341      int16_t *proc_buf_out;
342      size_t proc_buf_size;
343      size_t proc_buf_frames;
344  
345  #ifdef PREPROCESSING_ENABLED
346      struct echo_reference_itfe *echo_reference;
347      int16_t *ref_buf;
348      size_t ref_buf_size;
349      size_t ref_buf_frames;
350  
351  #ifdef HW_AEC_LOOPBACK
352      bool hw_echo_reference;
353      int16_t* hw_ref_buf;
354      size_t hw_ref_buf_size;
355  #endif
356  
357      int num_preprocessors;
358      struct effect_info_s preprocessors[MAX_PREPROCESSORS];
359  
360      bool aux_channels_changed;
361      uint32_t aux_channels;
362  #endif
363  
364      struct audio_device*                dev;
365      bool                                is_fastcapture_affinity_set;
366  };
367  
368  struct mixer_card {
369      struct listnode     adev_list_node;
370      struct listnode     uc_list_node[AUDIO_USECASE_MAX];
371      int                 card;
372      struct mixer*       mixer;
373      struct audio_route* audio_route;
374  };
375  
376  struct audio_usecase {
377      struct listnode         adev_list_node;
378      audio_usecase_t         id;
379      usecase_type_t          type;
380      audio_devices_t         devices;
381      snd_device_t            out_snd_device;
382      snd_device_t            in_snd_device;
383      struct audio_stream*    stream;
384      struct listnode         mixer_list;
385  };
386  
387  
388  struct audio_device {
389      struct audio_hw_device  device;
390      pthread_mutex_t         lock; /* see note below on mutex acquisition order */
391      struct listnode         mixer_list;
392      audio_mode_t            mode;
393      struct stream_in*       active_input;
394      struct stream_out*      primary_output;
395      int                     in_call;
396      float                   voice_volume;
397      bool                    mic_mute;
398      int                     tty_mode;
399      bool                    bluetooth_nrec;
400      bool                    screen_off;
401      int*                    snd_dev_ref_cnt;
402      struct listnode         usecase_list;
403      bool                    speaker_lr_swap;
404      unsigned int            cur_hdmi_channels;
405      int                     dualmic_config;
406      bool                    ns_in_voice_rec;
407  
408      void*                   offload_fx_lib;
409      int                     (*offload_fx_start_output)(audio_io_handle_t);
410      int                     (*offload_fx_stop_output)(audio_io_handle_t);
411  
412  #ifdef PREPROCESSING_ENABLED
413      struct echo_reference_itfe* echo_reference;
414      // echo_reference_generation indicates if the echo reference used by the output stream is
415      // in sync with the one known by the audio_device.
416      // incremented atomically with a memory barrier and audio device mutex locked but WITHOUT
417      // stream mutex locked: the stream will load it atomically with a barrier and re-read it
418      // with audio device mutex if needed
419      volatile int32_t        echo_reference_generation;
420  #endif
421  
422      void*                   htc_acoustic_lib;
423      int                     (*htc_acoustic_init_rt5506)();
424      int                     (*htc_acoustic_set_rt5506_amp)(int, int);
425      int                     (*htc_acoustic_set_amp_mode)(int, int, int, int, bool);
426      int                     (*htc_acoustic_spk_reverse)(bool);
427  
428      void*                   sound_trigger_lib;
429      int                     (*sound_trigger_open_for_streaming)();
430      size_t                  (*sound_trigger_read_samples)(int, void*, size_t);
431      int                     (*sound_trigger_close_for_streaming)(int);
432  
433      int                     tfa9895_init;
434      int                     tfa9895_mode_change;
435      pthread_mutex_t         tfa9895_lock;
436  
437      int                     dummybuf_thread_timeout;
438      int                     dummybuf_thread_cancel;
439      int                     dummybuf_thread_active;
440      audio_devices_t         dummybuf_thread_devices;
441      pthread_mutex_t         dummybuf_thread_lock;
442      pthread_t               dummybuf_thread;
443  
444      pthread_mutex_t         lock_inputs; /* see note below on mutex acquisition order */
445  };
446  
447  /*
448   * NOTE: when multiple mutexes have to be acquired, always take the
449   * lock_inputs, stream_in, stream_out, audio_device, then tfa9895 mutex.
450   * stream_in mutex must always be before stream_out mutex
451   * if both have to be taken (see get_echo_reference(), put_echo_reference()...)
452   * dummybuf_thread mutex is not related to the other mutexes with respect to order.
453   * lock_inputs must be held in order to either close the input stream, or prevent closure.
454   */
455  
456  #endif // NVIDIA_AUDIO_HW_H
457