3095实现Broadcast广播，并输入源分别支持I2S\SDPIF\AUXIN\BT\USB audio

最新推荐文章于 2026-07-03 16:53:44 发布

原创

最新推荐文章于 2026-07-03 16:53:44 发布 · 934 阅读

3095实现Broadcast广播，并输入源分别支持I2S\SDPIF\AUXIN\BT\USB audio，可以用按键切换或者串口命令切换输入源

/**

\file

\ingroup sink_app

\brief

This file handles all Synchronous connection messages

/****************************************************************************

Header files

#include "sink_private_data.h"

#include "sink_audio.h"

#include "sink_statemanager.h"

#include "sink_pio.h"

#include "sink_tones.h"

#include "sink_volume.h"

#include "sink_speech_recognition.h"

#include "sink_wired.h"

#include "sink_dut.h"

#include "sink_display.h"

#include "sink_audio_routing.h"

#include "sink_devicemanager.h"

#include "sink_debug.h"

#include "sink_partymode.h"

#include "sink_anc.h"

#include "sink_fm.h"

#include "sink_config.h"

#include "sink_hfp_data.h"

#include "sink_usb.h"

#include "sink_peer.h"

#include "sink_callmanager.h"

#include "sink_ba_receiver.h"

#include "sink_swat.h"

#include "sink_avrcp.h"

#include "sink_ba.h"

#include "sink_powermanager.h"

#include "sink_va.h"

#include <connection.h>

#include <a2dp.h>

#include <hfp.h>

#include <stdlib.h>

#include <audio.h>

#include <audio_plugin_if.h>

#include <audio_config.h>

#include <sink.h>

#include <bdaddr.h>

#include <vm.h>

#include <config_store.h>

#include <byte_utils.h>

#include <broadcast_context.h>

#include <swat.h>

#ifdef DEBUG_AUDIO

#define AUD_DEBUG(x) DEBUG(x)

#else

#define AUD_DEBUG(x)

#endif

/* Byte offsets of the User EQ bank - Pre Gain field*/

#define PRE_GAIN_LO_OFFSET 0

#define PRE_GAIN_HI_OFFSET 1

#define SINK_AUDIO_ROUTING_DELAY_MS (500)

/*Byte offsets used in mapping the parameters defined in the user_eq_band_t structure

* into a uint8 array.

typedef enum

{

BAND_FILTER_OFFSET,

BAND_FREQ_LO_OFFSET,

BAND_FREQ_HI_OFFSET,

BAND_GAIN_LO_OFFSET,

BAND_GAIN_HI_OFFSET,

BAND_Q_LO_OFFSET,

BAND_Q_HI_OFFSET

}user_eq_band_param_offset_t;

/* User defined EQ bank settings */

typedef enum{

BYPASS,

FIRST_ORDER_LOW_PASS,

FIRST_ORDER_HIGH_PASS,

FIRST_ORDER_ALL_PASS,

FIRST_ORDER_LOW_SHELF,

FIRST_ORDER_HIGH_SHELF,

FIRST_ORDER_TILT,

SECOND_ORDER_LOW_PASS,

SECOND_ORDER_HIGH_PASS,

SECOND_ORDER_ALL_PASS,

SECOND_ORDER_LOW_SHELF,

SECOND_ORDER_HIGH_SHELF,

SECOND_ORDER_TILT,

PARAMETRIC_EQ,

FORCE_ENUM_TO_MIN_16BIT(eq_filter)

}user_eq_filter_type_t;

/* Sink Audio global data */

typedef struct __sink_audio_global_data_t

{

sink_audio_writeable_config_def_t audio_session_data;

audio_instance_t routed_audio_instance;

audio_instance_t routed_voice_instance;

audio_sources routed_audio_source; /* Currently routed audio source */

voice_mic_params_t voice_mic_params;

analogue_input_params analogue_input_params;

a2dp_link_priority a2dp_priority_override;

unsigned :6;

unsigned gated_audio:8; /* Bitmask indicating which audio sources are prevented from being routed */

unsigned audioAmpReady:1; /* bit to indicate readiness of audio amplifier */

unsigned silence_detected:1; /* Flag to indicates whether silence detected while streaming media.*/

}sink_audio_global_data_t;

static sink_audio_global_data_t gAudioData;

#define AUDIO_GDATA gAudioData

/* Sink Audio writeable/session config data */

typedef struct __sink_audio_writeable_configdata_t

{

user_eq_bank_t *PEQ;

/* runtime data for the currently routed audio source */

audio_sources requested_audio_source;

}sink_audio_writeable_configdata_t;

static audio_sources audioGetHighestPriorityAudioSourceAvailable(void);

static bool audioRouteScoOutsideOfCallIfAvailable(void);

static bool audioRouteFMIfAvailable(void);

static bool audioRouteActiveCallScoIfAvailable(void);

static bool audioRouteA2dpStreamIfAvailable(a2dp_link_priority priority);

static bool audioRouteSource(audio_sources source);

static bool audioRouteAnalogIfAvailable(void);

static bool audioRouteSpdifIfAvailable(void);

static bool audioRouteI2SIfAvailable(void);

static bool audioRouteUsbIfAvailable(void);

static bool audioRouteBaIfAvailable(void);

static audio_sources getNextSourceInSequence(audio_sources source);

static audio_sources getAudioSourceFromEventUsrSelectAudioSource(const MessageId EventUsrSelectAudioSource);

static bool audioIsAudioSourceRoutable(audio_sources source);

static bool audioIsA2dpAudioRoutable(a2dp_link_priority priority);

static audio_sources audioGetAudioSourceToRoute(void);

static bool audioIsAudioSourceEnabledByUser(audio_sources source);

static audio_sources getNextRoutableSource(audio_sources current_source);

static bool audioRouteScoSink(Sink sco_sink_to_route);

static int16 audioGetVolumeForSink(Sink sink);

static void audioRouteVoiceSource(void);

static bool isAudioSourceA2dp(audio_sources source);

static bool audioIsCallWithoutSco(void);

static void sinkAudioSetRequestedAudioSource(audio_sources source);

static void sinkAudioReadMicParams(audio_mic_params *global, audio_mic_params_t *config);

static void sinkAudioReadAnalogueInputParams(analogue_input_params *global, analogue_input_params_t *config);

static void sinkAudioSetRoutedVoiceInstance(audio_instance_t instance);

static void updateVolumeBasedOnRoutedSources(void);

static a2dp_link_priority invertA2dpPriority(a2dp_link_priority priority);

static a2dp_link_priority getA2dpPriorityIndexFromAudioSource(audio_sources a2dp_source);

static void setA2dpOverridePriority(audio_sources a2dp_source);

static a2dp_link_priority getA2dpPriority(void);

static a2dp_link_priority getA2dpPriorityOverride(void);

static void sinkAudioConfigurePcmInputs(sink_audio_readonly_config_def_t *config);

static void adjustVolumeIfBatteryLowLimitationInplace(volume_info *volume);

static bool handleAudioActiveDelayRequest(void);

/*************************************************************************

NAME

isAudioGated

DESCRIPTION

Determines whether we should block the given source because either the

input is gated for all states or the current state does not allow playing

from this source.

The state test is necessary for directly attached audio inputs because we

have the option of whether to play them while in limbo.

INPUTS

audio_gated_mask

RETURNS

TRUE if the source should be gated

FALSE otherwise

bool isAudioGated (audio_gating audio_gated_mask)

{

bool gated_in_all_states = !!(AUDIO_GDATA.gated_audio & audio_gated_mask);

bool is_direct_connection = (audio_gated_mask & (audio_gate_usb | audio_gate_wired));

bool in_limbo = (stateManagerGetState() == deviceLimbo);

bool gated;

AUD_DEBUG(("isAudioGated(0x%X) 0x%X\n",audio_gated_mask,AUDIO_GDATA.gated_audio));

/* For audio sources which are capable of playing in Limbo we must first check

the current status of VM.*/

if((audio_gate_wired == audio_gated_mask) || (audio_gate_usb == audio_gated_mask))

{

if (gated_in_all_states)

{

gated = TRUE;

}

else if (is_direct_connection)

{

gated = (in_limbo && (!SinkWiredPlayUsbAndWiredInLimbo()));

}

else

{

* As far as routing logic is concerned, source can be played.

* (Note that whether or not the source is available is a separate

* question - e.g. remote sources will not be connected in limbo)

gated = FALSE;

}

return gated;

}

else

return gated_in_all_states;

}

audio_gating audioGateAudio (uint16 audio_gated_mask)

{

AUDIO_GDATA.gated_audio |= audio_gated_mask;

AUD_DEBUG(("audioGateAudio(0x%X) 0x%X\n",audio_gated_mask,AUDIO_GDATA.gated_audio));

return AUDIO_GDATA.gated_audio;

}

audio_gating audioUngateAudio (uint16 audio_ungated_mask)

{

AUDIO_GDATA.gated_audio &= ~audio_ungated_mask;

AUD_DEBUG(("audioUngateAudio(0x%X) 0x%X\n",audio_ungated_mask, AUDIO_GDATA.gated_audio));

return AUDIO_GDATA.gated_audio;

}

/****************************************************************************

NAME

audioRouteIsAutoSuspendOnCallEnabled

DESCRIPTION

Returns the status of auto suspend on call feature bit

RETURNS

TRUE if auto suspend is enabled, FALSE otherwise

static bool audioRouteIsAutoSuspendOnCallEnabled(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

bool auto_suspend_enabled = FALSE;

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

auto_suspend_enabled = read_data->AssumeAutoSuspendOnCall;

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return auto_suspend_enabled;

}

/****************************************************************************

NAME

sinkAudioSetRequestedAudioSource

DESCRIPTION

Updates the requested Audio source.

RETURNS

None

static void sinkAudioSetRequestedAudioSource(audio_sources source)

{

AUDIO_GDATA.audio_session_data.requested_audio_source = source;

}

/****************************************************************************

NAME

sinkAudioInit

DESCRIPTION

Reads the PSKEY containing the audio routing information

RETURNS

void

void sinkAudioInit( void )

{

sink_audio_readonly_config_def_t *read_data = NULL;

/* Initialise global data to 0 */

memset(&AUDIO_GDATA, 0, ( sizeof(sink_audio_global_data_t)));

/* Initialize the mic and line params global data from config */

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

/* A working copy of the voice_mic_params_t is needed because other parts

of the sink app / audio plugins use a pointer to the voice_mic_params_t

inside sink_audio_routing instead of copying it by value. */

sinkAudioReadMicParams(&AUDIO_GDATA.voice_mic_params.mic_a, &read_data->common_mic_params.mic_1a);

sinkAudioReadMicParams(&AUDIO_GDATA.voice_mic_params.mic_b, &read_data->common_mic_params.mic_1b);

sinkAudioReadAnalogueInputParams(&AUDIO_GDATA.analogue_input_params, &read_data->analogue_input);

sinkAudioConfigurePcmInputs(read_data);

AudioConfigSetQuality(audio_stream_voice, read_data->audio_quality.voice_quality);

AudioConfigSetQuality(audio_stream_music, read_data->audio_quality.music_quality);

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

/****************************************************************************

NAME

sinkAudioGetPluginFeatures

DESCRIPTION

Returns the audio plugin features.

RETURNS

Plugin features

AudioPluginFeatures sinkAudioGetPluginFeatures(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

AudioPluginFeatures audio_plugin_features;

memset(&audio_plugin_features, 0, sizeof (audio_plugin_features));

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

audio_plugin_features.manual_source_selection = read_data->PluginFeatures.manual_source_selection;

audio_plugin_features.audio_input_routing = read_data->PluginFeatures.audio_input_routing;

audio_plugin_features.spdif_supported_data_types = read_data->PluginFeatures.spdif_supported_data_types;

audio_plugin_features.dut_input = read_data->PluginFeatures.dut_input;

audio_plugin_features.force_resampling_of_tones = read_data->PluginFeatures.force_resampling_of_tones;

audio_plugin_features.use_one_mic_back_channel = read_data->PluginFeatures.use_one_mic_back_channel;

audio_plugin_features.use_two_mic_back_channel = read_data->PluginFeatures.use_two_mic_back_channel;

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

audio_plugin_features.stereo = TRUE;

}

audio_plugin_features.force_resampling_of_tones |= sinkAncIsEnabled();

return audio_plugin_features;

}

/****************************************************************************

NAME

sinkAudioIsManualSrcSelectionEnabled

DESCRIPTION

Returns the status of manual source selection feature bit.

RETURNS

TRUE If manual source selection is enabled, FALSE otherwise

bool sinkAudioIsManualSrcSelectionEnabled(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

bool manual_source_selection_enabled = FALSE;

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

manual_source_selection_enabled = read_data->PluginFeatures.manual_source_selection;

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return manual_source_selection_enabled;

}

/****************************************************************************

NAME

sinkAudioGetAudioInputRoute

DESCRIPTION

Audio input interface to use as source.

RETURNS

Input audio source

AUDIO_ROUTE_T sinkAudioGetAudioInputRoute(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

AUDIO_ROUTE_T audio_route = AUDIO_ROUTE_INTERNAL;

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

audio_route = read_data->PluginFeatures.audio_input_routing;

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return audio_route;

}

/****************************************************************************

NAME

sinkAudioGetSilenceThreshold

DESCRIPTION

Returns the configured silence detection threshold

RETURNS

threshold

uint16 sinkAudioGetSilenceThreshold(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

uint16 silence_threshold = 0x0; /* By default silence detection is set to disabled */

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

silence_threshold = read_data->SilenceDetSettings.threshold;

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return silence_threshold;

}

/****************************************************************************

NAME

sinkAudioGetSilenceTriggerTime

DESCRIPTION

Returns the silence detection trigger time

RETURNS

trigger time in seconds (16 bit)

uint16 sinkAudioGetSilenceTriggerTime(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

uint16 silence_trigger_time = 0x0;

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

silence_trigger_time = read_data->SilenceDetSettings.trigger_time;

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return silence_trigger_time;

}

/****************************************************************************

NAME

sinkAudioAmpPowerUpTime

DESCRIPTION

Return the configured time to power up amp before unmuting (milliseconds)

RETURNS

Amp power up time before unmute in seconds (16 bit)

uint16 sinkAudioAmpPowerUpTime(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

uint16 amp_unmute_time = 0x0;

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

amp_unmute_time = read_data->AudioAmpUnmuteTime_ms;

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return amp_unmute_time;

}

bool sinkAudioSetAmpPowerUpTime(uint16 time)

{

sink_audio_readonly_config_def_t *read_data = NULL;

if (configManagerGetWriteableConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (void **)&read_data, 0))

{

read_data->AudioAmpUnmuteTime_ms = time;

configManagerUpdateWriteableConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

return TRUE;

}

return FALSE;

}

/****************************************************************************

NAME

sinkAudioSourceDisconnectDelay

DESCRIPTION

Return the audio routing delay after source disconnection

RETURNS

Audio routing delay after input source disconnection

uint16 sinkAudioSourceDisconnectDelay(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

uint16 delay = 0x0;

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

delay = read_data->audio_switch_delay_after_disconn;

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return delay;

}

/****************************************************************************

NAME

sinkTwsAudioActiveDelay

DESCRIPTION

Return the TWS audio active delay in milliseconds after TWS audio is routed.

RETURNS

TWS Audio active delay after TWS audio is routed.

uint16 sinkTwsAudioActiveDelay(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

uint16 delay = 0x0;

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

delay = read_data->TwsAudioActiveDelay_ms;

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return delay;

}

/****************************************************************************

NAME

sinkAudioAmpPowerDownTime

DESCRIPTION

Return the configured time to mute before powering down amp(milliseconds)

RETURNS

Time to mute amp before power down (16 bit)

uint16 sinkAudioAmpPowerDownTime(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

uint16 amp_mute_time = 0x0;

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

amp_mute_time = read_data->AudioAmpMuteTime_ms;

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return amp_mute_time;

}

bool sinkAudioSetAmpPowerDownTime(uint16 time)

{

sink_audio_readonly_config_def_t *read_data = NULL;

if (configManagerGetWriteableConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (void **)&read_data, 0))

{

read_data->AudioAmpMuteTime_ms = time;

configManagerUpdateWriteableConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

return TRUE;

}

return FALSE;

}

/****************************************************************************

NAME

sinkAudioGetMic1AParams

DESCRIPTION

Return the configured mic 1 channel a settings

RETURNS

Mic a settings

audio_mic_params sinkAudioGetMic1AParams(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

audio_mic_params mic_params;

memset(&mic_params, 0, sizeof (mic_params));

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

sinkAudioReadMicParams(&mic_params, &read_data->common_mic_params.mic_1a);

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return mic_params;

}

/****************************************************************************

NAME

sinkAudioGetMic1BParams

DESCRIPTION

Return the configured mic 1 channel b settings

RETURNS

Mic b settings

audio_mic_params sinkAudioGetMic1BParams(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

audio_mic_params mic_params;

memset(&mic_params, 0, sizeof (mic_params));

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

sinkAudioReadMicParams(&mic_params, &read_data->common_mic_params.mic_1b);

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return mic_params;

}

/****************************************************************************

NAME

sinkAudioGetMic2AParams

DESCRIPTION

Return the configured mic 2 channel a settings

RETURNS

Mic c settings

audio_mic_params sinkAudioGetMic2AParams(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

audio_mic_params mic_params;

memset(&mic_params, 0, sizeof (mic_params));

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

sinkAudioReadMicParams(&mic_params, &read_data->common_mic_params.mic_2a);

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return mic_params;

}

/****************************************************************************

NAME

sinkAudioGetMic2BParams

DESCRIPTION

Return the configured mic 2 channel b settings

RETURNS

Mic d settings

audio_mic_params sinkAudioGetMic2BParams(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

audio_mic_params mic_params;

memset(&mic_params, 0, sizeof (mic_params));

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

sinkAudioReadMicParams(&mic_params, &read_data->common_mic_params.mic_2b);

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return mic_params;

}

/****************************************************************************

NAME

sinkAudioMicAPreAmpEnabled

DESCRIPTION

Determines if pre amp is enabled or mic a (analogue only)

RETURNS

TRUE if mic a pre amp is enabled, FALSE otherwise

bool sinkAudioMicAPreAmpEnabled(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

bool mic_a_pre_amp = FALSE;

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

mic_a_pre_amp = read_data->common_mic_params.mic_1a.pre_amp;

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return mic_a_pre_amp;

}

/****************************************************************************

NAME

sinkAudioMicBPreAmpEnabled

DESCRIPTION

Determines if pre amp is enabled or mic b (analogue only)

RETURNS

TRUE if mic b pre amp is enabled, FALSE otherwise

bool sinkAudioMicBPreAmpEnabled(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

bool mic_b_pre_amp = FALSE;

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

mic_b_pre_amp = read_data->common_mic_params.mic_1b.pre_amp;

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return mic_b_pre_amp;

}

/****************************************************************************

NAME

sinkAudioGetAudioActivePio

DESCRIPTION

Returns the configured PIO for Audio Active.

RETURNS

Audio active pio

uint8 sinkAudioGetAudioActivePio(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

uint8 audio_active_pio = 0x0;

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

audio_active_pio = read_data->AudioActivePIO;

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return audio_active_pio;

}

/****************************************************************************

NAME

sinkAudioGetAudioActivePio

DESCRIPTION

Returns the configured PIO for Aux out detect.

RETURNS

Aux out detect pio

uint8 sinkAudioGetAuxOutDetectPio(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

uint8 aux_out_detect_pio = 0x0;

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

aux_out_detect_pio = read_data->aux_out_detect;

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return aux_out_detect_pio;

}

/****************************************************************************

NAME

sinkAudioGetPowerOnPio

DESCRIPTION

Returns the configured PIO for Power on.

RETURNS

Power on pio

uint8 sinkAudioGetPowerOnPio(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

uint8 power_on_pio = 0x0;

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

power_on_pio = read_data->PowerOnPIO;

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return power_on_pio;

}

/****************************************************************************

NAME

sinkAudioGetAudioMutePio

DESCRIPTION

Returns the configured PIO for Audio mute.

RETURNS

Audio mute pio

uint8 sinkAudioGetAudioMutePio(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

uint8 audio_mute_pio = 0x0;

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

audio_mute_pio = read_data->AudioMutePIO;

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return audio_mute_pio;

}

/****************************************************************************

NAME

sinkAudioGetAudioSourcePriority1

DESCRIPTION

Returns the configured priority 1 source

RETURNS

priority 1 source

uint8 sinkAudioGetAudioSourcePriority1(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

uint8 source_pri = 0x0;

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

source_pri = read_data->seqSourcePriority1;

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return source_pri;

}

/****************************************************************************

NAME

sinkAudioGetDefaultAudioSource

DESCRIPTION

Returns the default audio source set in configuration

RETURNS

default source

uint8 sinkAudioGetDefaultAudioSource(void)

{

sink_audio_readonly_config_def_t *read_data = NULL;

uint8 default_source = 0x0;

if (configManagerGetReadOnlyConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID, (const void **)&read_data))

{

default_source = read_data->defaultSource;

configManagerReleaseConfig(SINK_AUDIO_READONLY_CONFIG_BLK_ID);

}

return default_source;

}

/****************************************************************************

NAME

sinkAudioRoutingGetSessionData

DESCRIPTION

Sets Audio related data using stored session data values.

RETURNS

None

void sinkAudioRoutingGetSessionData(void)

{

sink_audio_writeable_config_def_t *session_data = NULL;

uint16 size = 0;

size = configManagerGetReadOnlyConfig(SINK_AUDIO_WRITEABLE_CONFIG_BLK_ID, (const void **)&session_data);

if (size)

{

AUDIO_GDATA.audio_session_data = *session_data;

configManagerReleaseConfig(SINK_AUDIO_WRITEABLE_CONFIG_BLK_ID);

}

else

{

AUD_DEBUG(("AUDIO:sinkAudioGetWriteableConfig(): Error In reading Config , Block ID: SINK_AUDIO_WRITEABLE_CONFIG_BLK_ID"));

}

/****************************************************************************

NAME

sinkAudioRoutingSetSessionData

DESCRIPTION

Sets Audio related session data using using current data values.

RETURNS

None

void sinkAudioRoutingSetSessionData(void)

{

sink_audio_writeable_config_def_t *write_data = NULL;

if (configManagerGetWriteableConfig(SINK_AUDIO_WRITEABLE_CONFIG_BLK_ID, (void **)&write_data, 0))

{

*write_data = AUDIO_GDATA.audio_session_data;

configManagerUpdateWriteableConfig(SINK_AUDIO_WRITEABLE_CONFIG_BLK_ID);

}

/****************************************************************************

NAME

sinkAudioGetRequestedAudioSource

DESCRIPTION

Get the requested Audio source.

RETURNS

Requested audio source

audio_sources sinkAudioGetRequestedAudioSource(void)

{

return AUDIO_GDATA.audio_session_data.requested_audio_source;

}

/****************************************************************************

NAME

sinkAudioGetRoutedAudioSource

DESCRIPTION

Get the currently routed Audio source.

RETURNS

routed audio source

audio_sources sinkAudioGetRoutedAudioSource(void)

{

return AUDIO_GDATA.routed_audio_source;

}

/****************************************************************************

NAME

sinkAudioSetRoutedAudioSource

DESCRIPTION

Updates the currently routed Audio source.

RETURNS

None

void sinkAudioSetRoutedAudioSource(audio_sources source)

{

AUDIO_GDATA.routed_audio_source= source;

if(audio_source_a2dp_1 == source ||

audio_source_a2dp_2 == source)

{

setA2dpOverridePriority(source);

AUD_DEBUG(("AUD: Set A2DP OVERRIDE priority to %d\n", getA2dpPriorityOverride()));

}

/****************************************************************************

NAME

sinkAudioGetPEQ

DESCRIPTION

Returns the user eq bank settings

RETURNS

user_eq_bank_t

user_eq_bank_t *sinkAudioGetPEQ(void)

{

return &AUDIO_GDATA.audio_session_data.PEQ;

}

/****************************************************************************

NAME

sinkAudioPeerGetPEQ

DESCRIPTION

Return the PEQ settings to be sent to currently connected Peer.

RETURNS

None

bool sinkAudioPeerGetPEQ(uint8 *user_eq_params)

{

user_eq_bank_t *PEQ = NULL;

bool status = FALSE;

uint16 i;

PEQ = sinkAudioGetPEQ();

if((user_eq_params != NULL) && (PEQ != NULL))

{

/*Store the data into the uint8 array */

user_eq_params[PRE_GAIN_LO_OFFSET] = LOBYTE(PEQ->preGain);

user_eq_params[PRE_GAIN_HI_OFFSET] = HIBYTE(PEQ->preGain);

/*Increment the data pointer with the no. of bytes required to store the Pre-gain value */

user_eq_params += USER_EQ_PARAM_PRE_GAIN_SIZE ;

for(i=0; i<NUM_USER_EQ_BANDS ; i++)

{

user_eq_params[BAND_FILTER_OFFSET]= (uint8)PEQ->bands[i].filter;

user_eq_params[BAND_FREQ_LO_OFFSET]= LOBYTE(PEQ->bands[i].freq);

user_eq_params[BAND_FREQ_HI_OFFSET]= HIBYTE(PEQ->bands[i].freq);

user_eq_params[BAND_GAIN_LO_OFFSET]= LOBYTE(PEQ->bands[i].gain);

user_eq_params[BAND_GAIN_HI_OFFSET]= HIBYTE(PEQ->bands[i].gain);

user_eq_params[BAND_Q_LO_OFFSET]= LOBYTE(PEQ->bands[i].Q);

user_eq_params[BAND_Q_HI_OFFSET]= HIBYTE(PEQ->bands[i].Q);

/*Increment the data pointer with the no. of bytes required to store all the band parameters */

user_eq_params += USER_EQ_BAND_PARAMS_SIZE ;

}

status = TRUE;

}

return status;

}

/****************************************************************************

NAME

sinkAudioPeerUpdatePEQ

DESCRIPTION

Update the PEQ settings as received from the connected Peer.

RETURNS

None

void sinkAudioPeerUpdatePEQ(uint8* peer_updated_eq)

{

user_eq_bank_t *PEQ = NULL;

uint16 i;

PEQ = sinkAudioGetPEQ();

PEQ->preGain = MAKEWORD(peer_updated_eq[PRE_GAIN_LO_OFFSET] , peer_updated_eq[PRE_GAIN_HI_OFFSET]);

/*Increment the data pointer with the no. of bytes required to store the Pre-gain value */

peer_updated_eq += USER_EQ_PARAM_PRE_GAIN_SIZE;

for(i=0; i<NUM_USER_EQ_BANDS; i++)

{

PEQ->bands[i].filter = peer_updated_eq[BAND_FILTER_OFFSET];

PEQ->bands[i].freq = MAKEWORD(peer_updated_eq[BAND_FREQ_LO_OFFSET], peer_updated_eq[BAND_FREQ_HI_OFFSET]);

PEQ->bands[i].gain = MAKEWORD(peer_updated_eq[BAND_GAIN_LO_OFFSET], peer_updated_eq[BAND_GAIN_HI_OFFSET]);

PEQ->bands[i].Q = MAKEWORD(peer_updated_eq[BAND_Q_LO_OFFSET], peer_updated_eq[BAND_Q_HI_OFFSET]);

/*Increment the data pointer with the no. of bytes required to store all the band parameters */

peer_updated_eq += USER_EQ_BAND_PARAMS_SIZE ;

}

/****************************************************************************

NAME

sinkAudioGetRoutedAudioInstance

DESCRIPTION

Returns the currently routed audio instance.

RETURNS

Currently routed instance

static audio_instance_t sinkAudioGetRoutedAudioInstance(void)

{

return AUDIO_GDATA.routed_audio_instance;

}

bool sinkAudioIsAudioRouted(void)

{

return (sinkAudioGetRoutedAudioInstance() ? TRUE : FALSE);

}

/****************************************************************************

NAME

sinkAudioGetRoutedAudioSink

DESCRIPTION

Returns the currently routed audio sink.

RETURNS

Currently routed sink

Sink sinkAudioGetRoutedAudioSink(void)

{

Sink routed_sink = (Sink)NULL;

if(sinkAudioIsAudioRouted())

{

routed_sink = AudioInstanceGetSink(sinkAudioGetRoutedAudioInstance());

}

return routed_sink;

}

/****************************************************************************

NAME

sinkAudioGetRoutedAudioTask

DESCRIPTION

Returns the currently routed audio task.

RETURNS

Currently routed task

Task sinkAudioGetRoutedAudioTask(void)

{

Task routed_task = (Task)NULL;

if(sinkAudioIsAudioRouted())

{

routed_task = AudioInstanceGetPluginTask(sinkAudioGetRoutedAudioInstance());

}

return routed_task;

}

/****************************************************************************

NAME

sinkAudioGetRoutedVoiceInstance

DESCRIPTION

Returns the currently routed voice instance.

RETURNS

Currently routed instance

static audio_instance_t sinkAudioGetRoutedVoiceInstance(void)

{

return AUDIO_GDATA.routed_voice_instance;

}

bool sinkAudioIsVoiceRouted(void)

{

return (sinkAudioGetRoutedVoiceInstance() ? TRUE : FALSE);

}

/****************************************************************************

NAME

sinkAudioGetRoutedVoiceSink

DESCRIPTION

Returns the currently routed voice sink.

RETURNS

Currently routed sink

Sink sinkAudioGetRoutedVoiceSink(void)

{

Sink routed_sink = (Sink)NULL;

if(sinkAudioIsVoiceRouted())

{

routed_sink = AudioInstanceGetSink(sinkAudioGetRoutedVoiceInstance());

}

return routed_sink;

}

/****************************************************************************

NAME

sinkAudioGetRoutedVoiceTask

DESCRIPTION

Returns the currently routed voice task.

RETURNS

Currently routed task

Task sinkAudioGetRoutedVoiceTask(void)

{

Task routed_task = (Task)NULL;

if(sinkAudioIsVoiceRouted())

{

routed_task = AudioInstanceGetPluginTask(sinkAudioGetRoutedVoiceInstance());

}

return routed_task;

}

/****************************************************************************

NAME

sinkAudioSetRoutedAudioInstance

DESCRIPTION

Updates the currently routed audio instance.

RETURNS

None

void sinkAudioSetRoutedAudioInstance(audio_instance_t instance)

{

AUDIO_GDATA.routed_audio_instance = instance;

}

/****************************************************************************

NAME

sinkAudioSetRoutedVoiceInstance

DESCRIPTION

Updates the currently routed voice instance.

RETURNS

None

static void sinkAudioSetRoutedVoiceInstance(audio_instance_t instance)

{

AUDIO_GDATA.routed_voice_instance = instance;

}

/****************************************************************************

NAME

sinkAudioReSetGatedAudio

DESCRIPTION

Resets the gated audio flag.

RETURNS

None

void sinkAudioReSetGatedAudio(void)

{

AUDIO_GDATA.gated_audio = 0;

}

/****************************************************************************

NAME

sinkAudioIsAmpReady

DESCRIPTION

Returns the status of amplifier ready flag.

RETURNS

TRUE: if audio amplifier is ready, FALSE otherwise

bool sinkAudioIsAmpReady(void)

{

return AUDIO_GDATA.audioAmpReady;

}

/****************************************************************************

NAME

sinkAudioSetAmpReady

DESCRIPTION

Updates the status of amplifier ready flag.

RETURNS

None

void sinkAudioSetAmpReady(bool amp_ready)

{

AUDIO_GDATA.audioAmpReady = amp_ready;

}

/****************************************************************************

NAME

sinkAudioIsSilenceDetected

DESCRIPTION

Returns the status of Silence detection flag.

RETURNS

TRUE: If silence detected, FALSE otherwise

bool sinkAudioIsSilenceDetected(void)

{

return AUDIO_GDATA.silence_detected;

}

/****************************************************************************

NAME

sinkAudioSetSilence

DESCRIPTION

Updates the status of silence detection flag.

RETURNS

None

void sinkAudioSetSilence(bool silence)

{

AUDIO_GDATA.silence_detected= silence;

}

/****************************************************************************

NAME

sinkAudioReadMicParams

DESCRIPTION

Helper function to populate global mic params from the config read params

RETURNS

None

static void sinkAudioReadMicParams(audio_mic_params *global, audio_mic_params_t *config)

{

global->bias_config = config->bias_config;

global->is_digital = config->is_digital;

global->pre_amp = config->pre_amp;

global->pio = config->pio;

global->instance = config->instance;

global->gain = config->gain;

}

/****************************************************************************

NAME

sinkAudioReadAnalogueInputParams

DESCRIPTION

Helper function to populate global analogue input params from the config read params

RETURNS

None

static void sinkAudioReadAnalogueInputParams(analogue_input_params *global, analogue_input_params_t *config)

{

global->pre_amp = config->pre_amp;

global->instance = config->instance;

global->gain = config->gain;

global->enable_24_bit_resolution = config->enable_24_bit_resolution;

}

/****************************************************************************

NAME

sinkAudioGetCommonMicParams

DESCRIPTION

Retrieve the common mic params

RETURNS

None

void sinkAudioGetCommonMicParams(const voice_mic_params_t ** mic_params)

{

/* Return the read mic params from global audio data */

*mic_params = &AUDIO_GDATA.voice_mic_params;

}

/****************************************************************************

NAME

sinkAudioGetCo

标签

#QCC #QCC30XX #算法 #高通 #高通QCC

最低0.47元/天解锁文章