jenna
/
hardware_samsung
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
756 Commits
3 Branches
0 Tags
10 MiB
 
 
 
 
 
 
Tag: Branch: Tree: 1bc99f564c
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '1bc99f564c'
${ noResults }
hardware_samsung/audio/audio_hw.h

421 lines
14 KiB
Raw Blame History

/*
* Copyright (C) 2013 The Android Open Source Project
* Copyright (C) 2017 Christopher N. Hesse <raymanfx@gmail.com>
* Copyright (C) 2018 The LineageOS Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef SAMSUNG_AUDIO_HW_H
#define SAMSUNG_AUDIO_HW_H
#include <cutils/list.h>
#include <hardware/audio.h>
#include <hardware/audio_amplifier.h>
#include <tinyalsa/asoundlib.h>
#include <tinycompress/tinycompress.h>
/* TODO: remove resampler if possible when AudioFlinger supports downsampling from 48 to 8 */
#include <audio_utils/resampler.h>
#include <audio_route/audio_route.h>
/* Retry for delay in FW loading*/
#define RETRY_NUMBER 10
#define RETRY_US 500000
#ifdef __LP64__
#define OFFLOAD_FX_LIBRARY_PATH "/system/lib64/soundfx/libnvvisualizer.so"
#else
#define OFFLOAD_FX_LIBRARY_PATH "/system/lib/soundfx/libnvvisualizer.so"
#endif
#ifdef PREPROCESSING_ENABLED
#include <audio_utils/echo_reference.h>
#define MAX_PREPROCESSORS 3
struct effect_info_s {
effect_handle_t effect_itfe;
size_t num_channel_configs;
channel_config_t *channel_configs;
};
#endif
/* Sound devices specific to the platform
* The DEVICE_OUT_* and DEVICE_IN_* should be mapped to these sound
* devices to enable corresponding mixer paths
*/
enum {
SND_DEVICE_NONE = 0,
/* Playback devices */
SND_DEVICE_MIN,
SND_DEVICE_OUT_BEGIN = SND_DEVICE_MIN,
SND_DEVICE_OUT_EARPIECE = SND_DEVICE_OUT_BEGIN,
SND_DEVICE_OUT_SPEAKER,
SND_DEVICE_OUT_HEADPHONES,
SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES,
SND_DEVICE_OUT_VOICE_EARPIECE,
SND_DEVICE_OUT_VOICE_EARPIECE_WB,
SND_DEVICE_OUT_VOICE_SPEAKER,
SND_DEVICE_OUT_VOICE_SPEAKER_WB,
SND_DEVICE_OUT_VOICE_HEADPHONES,
SND_DEVICE_OUT_VOICE_HEADPHONES_WB,
SND_DEVICE_OUT_VOICE_BT_SCO,
SND_DEVICE_OUT_VOICE_BT_SCO_WB,
SND_DEVICE_OUT_HDMI,
SND_DEVICE_OUT_SPEAKER_AND_HDMI,
SND_DEVICE_OUT_BT_SCO,
SND_DEVICE_OUT_END,
/*
* Note: IN_BEGIN should be same as OUT_END because total number of devices
* SND_DEVICES_MAX should not exceed MAX_RX + MAX_TX devices.
*/
/* Capture devices */
SND_DEVICE_IN_BEGIN = SND_DEVICE_OUT_END,
SND_DEVICE_IN_EARPIECE_MIC = SND_DEVICE_IN_BEGIN,
SND_DEVICE_IN_SPEAKER_MIC,
SND_DEVICE_IN_HEADSET_MIC,
SND_DEVICE_IN_EARPIECE_MIC_AEC,
SND_DEVICE_IN_SPEAKER_MIC_AEC,
SND_DEVICE_IN_HEADSET_MIC_AEC,
SND_DEVICE_IN_VOICE_MIC,
SND_DEVICE_IN_VOICE_EARPIECE_MIC,
SND_DEVICE_IN_VOICE_EARPIECE_MIC_WB,
SND_DEVICE_IN_VOICE_SPEAKER_MIC,
SND_DEVICE_IN_VOICE_SPEAKER_MIC_WB,
SND_DEVICE_IN_VOICE_HEADSET_MIC,
SND_DEVICE_IN_VOICE_HEADSET_MIC_WB,
SND_DEVICE_IN_VOICE_BT_SCO_MIC,
SND_DEVICE_IN_VOICE_BT_SCO_MIC_WB,
SND_DEVICE_IN_HDMI_MIC,
SND_DEVICE_IN_BT_SCO_MIC,
SND_DEVICE_IN_CAMCORDER_MIC,
SND_DEVICE_IN_VOICE_REC_HEADSET_MIC,
SND_DEVICE_IN_VOICE_REC_MIC,
SND_DEVICE_IN_END,
SND_DEVICE_MAX = SND_DEVICE_IN_END,
};
/*
* tinyAlsa library interprets period size as number of frames
* one frame = channel_count * sizeof (pcm sample)
* so if format = 16-bit PCM and channels = Stereo, frame size = 2 ch * 2 = 4 bytes
* DEEP_BUFFER_OUTPUT_PERIOD_SIZE = 1024 means 1024 * 4 = 4096 bytes
* We should take care of returning proper size when AudioFlinger queries for
* the buffer size of an input/output stream
*/
#define PLAYBACK_PERIOD_SIZE 256
#define PLAYBACK_PERIOD_COUNT 2
#define PLAYBACK_DEFAULT_CHANNEL_COUNT 2
#define PLAYBACK_DEFAULT_SAMPLING_RATE 48000
#define PLAYBACK_START_THRESHOLD(size, count) (((size) * (count)) - 1)
#define PLAYBACK_STOP_THRESHOLD(size, count) ((size) * ((count) + 2))
#define PLAYBACK_AVAILABLE_MIN 1
#define SCO_PERIOD_SIZE 168
#define SCO_PERIOD_COUNT 2
#define SCO_DEFAULT_CHANNEL_COUNT 2
#define SCO_DEFAULT_SAMPLING_RATE 8000
#define SCO_WB_SAMPLING_RATE 16000
#define SCO_START_THRESHOLD 335
#define SCO_STOP_THRESHOLD 336
#define SCO_AVAILABLE_MIN 1
#define PLAYBACK_HDMI_MULTI_PERIOD_SIZE 1024
#define PLAYBACK_HDMI_MULTI_PERIOD_COUNT 4
#define PLAYBACK_HDMI_MULTI_DEFAULT_CHANNEL_COUNT 6
#define PLAYBACK_HDMI_MULTI_PERIOD_BYTES \
(PLAYBACK_HDMI_MULTI_PERIOD_SIZE * PLAYBACK_HDMI_MULTI_DEFAULT_CHANNEL_COUNT * 2)
#define PLAYBACK_HDMI_MULTI_START_THRESHOLD 4095
#define PLAYBACK_HDMI_MULTI_STOP_THRESHOLD 4096
#define PLAYBACK_HDMI_MULTI_AVAILABLE_MIN 1
#define PLAYBACK_HDMI_DEFAULT_CHANNEL_COUNT 2
#define CAPTURE_PERIOD_SIZE 1024
#define CAPTURE_PERIOD_SIZE_LOW_LATENCY 256
#define CAPTURE_PERIOD_COUNT 2
#define CAPTURE_PERIOD_COUNT_LOW_LATENCY 2
#define CAPTURE_DEFAULT_CHANNEL_COUNT 2
#define CAPTURE_DEFAULT_SAMPLING_RATE 48000
#define CAPTURE_START_THRESHOLD 1
#define COMPRESS_CARD 0
#define COMPRESS_DEVICE 5
#define COMPRESS_OFFLOAD_FRAGMENT_SIZE (32 * 1024)
#define COMPRESS_OFFLOAD_NUM_FRAGMENTS 4
/* ToDo: Check and update a proper value in msec */
#define COMPRESS_OFFLOAD_PLAYBACK_LATENCY 96
#define COMPRESS_PLAYBACK_VOLUME_MAX 0x10000 //NV suggested value
#define DEEP_BUFFER_OUTPUT_SAMPLING_RATE 48000
#define DEEP_BUFFER_OUTPUT_PERIOD_SIZE 480
#define DEEP_BUFFER_OUTPUT_PERIOD_COUNT 8
#define MAX_SUPPORTED_CHANNEL_MASKS 2
typedef int snd_device_t;
/* These are the supported use cases by the hardware.
* Each usecase is mapped to a specific PCM device.
* Refer to pcm_device_table[].
*/
typedef enum {
USECASE_INVALID = -1,
/* Playback usecases */
USECASE_AUDIO_PLAYBACK = 0,
USECASE_AUDIO_PLAYBACK_MULTI_CH,
USECASE_AUDIO_PLAYBACK_OFFLOAD,
USECASE_AUDIO_PLAYBACK_DEEP_BUFFER,
/* Capture usecases */
USECASE_AUDIO_CAPTURE,
USECASE_VOICE_CALL,
AUDIO_USECASE_MAX
} audio_usecase_t;
#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
/*
* tinyAlsa library interprets period size as number of frames
* one frame = channel_count * sizeof (pcm sample)
* so if format = 16-bit PCM and channels = Stereo, frame size = 2 ch * 2 = 4 bytes
* DEEP_BUFFER_OUTPUT_PERIOD_SIZE = 1024 means 1024 * 4 = 4096 bytes
* We should take care of returning proper size when AudioFlinger queries for
* the buffer size of an input/output stream
*/
enum {
OFFLOAD_CMD_EXIT, /* exit compress offload thread loop*/
OFFLOAD_CMD_DRAIN, /* send a full drain request to DSP */
OFFLOAD_CMD_PARTIAL_DRAIN, /* send a partial drain request to DSP */
OFFLOAD_CMD_WAIT_FOR_BUFFER, /* wait for buffer released by DSP */
};
enum {
OFFLOAD_STATE_IDLE,
OFFLOAD_STATE_PLAYING,
OFFLOAD_STATE_PAUSED,
OFFLOAD_STATE_PAUSED_FLUSHED,
};
typedef enum {
PCM_PLAYBACK = 0x1,
PCM_CAPTURE = 0x2,
VOICE_CALL = 0x4,
PCM_CAPTURE_LOW_LATENCY = 0x10,
} usecase_type_t;
struct offload_cmd {
struct listnode node;
int cmd;
int data[];
};
struct pcm_device_profile {
struct pcm_config config;
int card;
int id;
usecase_type_t type;
audio_devices_t devices;
};
struct pcm_device {
struct listnode stream_list_node;
struct pcm_device_profile* pcm_profile;
struct pcm* pcm;
int status;
};
struct stream_out {
struct audio_stream_out stream;
pthread_mutex_t lock; /* see note below on mutex acquisition order */
pthread_mutex_t pre_lock; /* acquire before lock to avoid DOS by playback thread */
pthread_cond_t cond;
struct pcm_config config;
struct listnode pcm_dev_list;
struct compr_config compr_config;
struct compress* compr;
int standby;
unsigned int sample_rate;
audio_channel_mask_t channel_mask;
audio_format_t format;
audio_devices_t devices;
audio_output_flags_t flags;
audio_usecase_t usecase;
/* Array of supported channel mask configurations. +1 so that the last entry is always 0 */
audio_channel_mask_t supported_channel_masks[MAX_SUPPORTED_CHANNEL_MASKS + 1];
bool muted;
/* total frames written, not cleared when entering standby */
uint64_t written;
audio_io_handle_t handle;
int non_blocking;
int offload_state;
pthread_cond_t offload_cond;
pthread_t offload_thread;
struct listnode offload_cmd_list;
bool offload_thread_blocked;
stream_callback_t offload_callback;
void* offload_cookie;
struct compr_gapless_mdata gapless_mdata;
int send_new_metadata;
struct audio_device* dev;
#ifdef PREPROCESSING_ENABLED
struct echo_reference_itfe *echo_reference;
// echo_reference_generation indicates if the echo reference used by the output stream is
// in sync with the one known by the audio_device. When different from the generation stored
// in the audio_device the output stream must release the echo reference.
// always modified with audio device and stream mutex locked.
int32_t echo_reference_generation;
#endif
bool is_fastmixer_affinity_set;
int64_t last_write_time_us;
};
struct stream_in {
struct audio_stream_in stream;
pthread_mutex_t lock; /* see note below on mutex acquisition order */
pthread_mutex_t pre_lock; /* acquire before lock to avoid DOS by
capture thread */
struct pcm_config config;
struct listnode pcm_dev_list;
int standby;
audio_source_t source;
audio_devices_t devices;
uint32_t main_channels;
audio_usecase_t usecase;
usecase_type_t usecase_type;
bool enable_aec;
audio_input_flags_t input_flags;
/* TODO: remove resampler if possible when AudioFlinger supports downsampling from 48 to 8 */
unsigned int requested_rate;
struct resampler_itfe* resampler;
struct resampler_buffer_provider buf_provider;
int read_status;
int16_t* read_buf;
size_t read_buf_size;
size_t read_buf_frames;
int16_t *proc_buf_in;
int16_t *proc_buf_out;
size_t proc_buf_size;
size_t proc_buf_frames;
#ifdef PREPROCESSING_ENABLED
struct echo_reference_itfe *echo_reference;
int16_t *ref_buf;
size_t ref_buf_size;
size_t ref_buf_frames;
int num_preprocessors;
struct effect_info_s preprocessors[MAX_PREPROCESSORS];
bool aux_channels_changed;
uint32_t aux_channels;
#endif
struct audio_device* dev;
bool is_fastcapture_affinity_set;
int64_t last_read_time_us;
int64_t frames_read; /* total frames read, not cleared when
entering standby */
};
struct mixer_card {
struct listnode adev_list_node;
struct listnode uc_list_node[AUDIO_USECASE_MAX];
int card;
struct mixer* mixer;
struct audio_route* audio_route;
struct timespec dsp_poweroff_time;
};
struct audio_usecase {
struct listnode adev_list_node;
audio_usecase_t id;
usecase_type_t type;
audio_devices_t devices;
snd_device_t out_snd_device;
snd_device_t in_snd_device;
struct audio_stream* stream;
struct listnode mixer_list;
};
struct voice_data {
bool in_call;
float volume;
bool bluetooth_nrec;
bool bluetooth_wb;
struct voice_session *session;
};
struct audio_device {
struct audio_hw_device device;
pthread_mutex_t lock; /* see note below on mutex acquisition order */
struct listnode mixer_list;
audio_mode_t mode;
struct stream_in* active_input;
struct stream_out* primary_output;
bool mic_mute;
bool screen_off;
bool bt_sco_active;
struct pcm *pcm_sco_rx;
struct pcm *pcm_sco_tx;
struct voice_data voice;
int* snd_dev_ref_cnt;
struct listnode usecase_list;
bool speaker_lr_swap;
unsigned int cur_hdmi_channels;
bool ns_in_voice_rec;
void* offload_fx_lib;
int (*offload_fx_start_output)(audio_io_handle_t);
int (*offload_fx_stop_output)(audio_io_handle_t);
#ifdef PREPROCESSING_ENABLED
struct echo_reference_itfe* echo_reference;
// echo_reference_generation indicates if the echo reference used by the output stream is
// in sync with the one known by the audio_device.
// incremented atomically with a memory barrier and audio device mutex locked but WITHOUT
// stream mutex locked: the stream will load it atomically with a barrier and re-read it
// with audio device mutex if needed
volatile int32_t echo_reference_generation;
#endif
pthread_mutex_t lock_inputs; /* see note below on mutex acquisition order */
amplifier_device_t *amp;
};
/*
* NOTE: when multiple mutexes have to be acquired, always take the
* lock_inputs, stream_in, stream_out, then audio_device mutex.
* stream_in mutex must always be before stream_out mutex
* lock_inputs must be held in order to either close the input stream, or prevent closure.
*/
#endif // SAMSUNG_AUDIO_HW_H