Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d71829cb authored by Sharad Sangle's avatar Sharad Sangle Committed by Fred Oh
Browse files

policy-hal: add custom audio policy 

- this change contains all the fixes went in
  audio policy made by QTI as below.

 audio_policyhal: SSR support for compress offload
 Change-Id: Idc8f6690d7c06883dbfcf55b073d4456a8c27e5c

 audio: Fix playback of AAC clips in offload mode instead of deep buffer
 Change-Id: Ib946830bc2f6b9cec33c8f0943910e3aeeb6fa6e

 audio: primary desc check for sonification_respectful
 Change-Id: I5d7aef3b29791823c277452e71e0cd43f91b2ddd

 audio_policy: Fix for mute count mismatch for sonification strategy
 Change-Id: Id4f328e2f9fc6820cecfbd73df11c871f8587aad

 audio: execute setVoiceVolume for USB device during inCall usecase
 Change-Id: Ia4917807103d1cf406a03e1d6d3dada470401737

 audio_policy: handle in call sonification for attached outputs of duplicating output
 Change-Id: I91968b33c4d93b13aae421654b2740c46269d55e

 audio: Fix for Sound from handset leaks to speaker
 Change-Id: Id2fd20de7a279f74e38a9aefe91e17b36cc9da6f

 audio: Fix media server crash at the start of voice call
 Change-Id: Ibe2d19acbed2ca44ab193ae0b613fae899f02ebb

 audio_policy: handle incall sound notifications on non primary outputs
 Change-Id: I2eec3872a2dcd10750ac20f69791a5bb51b37d8b

 Audiopolicymanager: handle incall sonification without checking output refCount
 Change-Id: I0eab939b32fe47388e2515ab56154d540e9df55c

 audio: use FLAG_FAST for non-music stream on WFD
 Change-Id: Id2f5965c8f5623646b2adb2aa892a9929f3bc5bb

 audiopolicy: optimize voice call start latency
 Chnage-Id: I77cb2ddb5a9154ffd2ac1620351992686e580f8a

Change-Id: I8a5991f09063f8e00b9a1308c3307c239f3ce487
parent 6d38a221

policy_hal/Android.mk

+12 −64
Original line number Diff line number Diff line
@@ -5,82 +5,30 @@ include $(CLEAR_VARS) 


LOCAL_SRC_FILES := AudioPolicyManager.cpp



LOCAL_C_INCLUDES := $(TOPDIR)frameworks/av/services

LOCAL_C_INCLUDES := $(TOPDIR)frameworks/av/services \

                    $(TOPDIR)frameworks/av/services/audioflinger \

                    $(call include-path-for, audio-effects) \

                    $(call include-path-for, audio-utils) \

                    $(TOPDIR)frameworks/av/services/audiopolicy/common/include \

                    $(TOPDIR)frameworks/av/services/audiopolicy/engine/interface \

                    $(TOPDIR)frameworks/av/services/audiopolicy \

                    $(TOPDIR)frameworks/av/services/audiopolicy/common/managerdefinitions/include \

                    $(call include-path-for, avextension)





LOCAL_SHARED_LIBRARIES := \

    libcutils \

    libutils \

    liblog \

    libsoundtrigger \

    libaudiopolicymanagerdefault

    libaudiopolicymanagerdefault \

    libserviceutility



LOCAL_STATIC_LIBRARIES := \

    libmedia_helper \

    libserviceutility



LOCAL_MODULE := libaudiopolicymanager



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_COMPRESS_VOIP)),true)

LOCAL_CFLAGS += -DAUDIO_EXTN_COMPRESS_VOIP_ENABLED

endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_EXTN_FORMATS)),true)

LOCAL_CFLAGS += -DAUDIO_EXTN_FORMATS_ENABLED

endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_FM)),true)

LOCAL_CFLAGS += -DAUDIO_EXTN_FM_ENABLED

endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_HDMI_SPK)),true)

LOCAL_CFLAGS += -DAUDIO_EXTN_HDMI_SPK_ENABLED

endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_INCALL_MUSIC)),true)

LOCAL_CFLAGS += -DAUDIO_EXTN_INCALL_MUSIC_ENABLED

endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_MULTIPLE_TUNNEL)), true)

LOCAL_CFLAGS += -DMULTIPLE_OFFLOAD_ENABLED

endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_PCM_OFFLOAD)),true)

    LOCAL_CFLAGS += -DPCM_OFFLOAD_ENABLED

endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_PROXY_DEVICE)),true)

LOCAL_CFLAGS += -DAUDIO_EXTN_AFE_PROXY_ENABLED

endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_SSR)),true)

LOCAL_CFLAGS += -DAUDIO_EXTN_SSR_ENABLED

endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_VOICE_CONCURRENCY)),true)

LOCAL_CFLAGS += -DVOICE_CONCURRENCY

endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_WFD_CONCURRENCY)),true)

LOCAL_CFLAGS += -DWFD_CONCURRENCY

endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_RECORD_PLAY_CONCURRENCY)),true)

LOCAL_CFLAGS += -DRECORD_PLAY_CONCURRENCY

endif



ifeq ($(strip $(DOLBY_UDC)),true)

  LOCAL_CFLAGS += -DDOLBY_UDC

endif #DOLBY_UDC

ifeq ($(strip $(DOLBY_DDP)),true)

  LOCAL_CFLAGS += -DDOLBY_DDP

endif #DOLBY_DDP

ifeq ($(strip $(DOLBY_DAP)),true)

    ifdef DOLBY_DAP_OPENSLES

        LOCAL_CFLAGS += -DDOLBY_DAP_OPENSLES

    endif

endif #DOLBY_END





include $(BUILD_SHARED_LIBRARY)



endif

policy_hal/AudioPolicyManager.cpp

+613 −1891

File changed.

Preview size limit exceeded, changes collapsed.

policy_hal/AudioPolicyManager.h

+64 −69
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.

 * Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.

 * Not a contribution.

 *

 * Copyright (C) 2009 The Android Open Source Project
@@ -18,13 +18,32 @@ 
 */





#include <audiopolicy/AudioPolicyManager.h>

#include <audiopolicy/audio_policy_conf.h>



#include <audiopolicy/managerdefault/AudioPolicyManager.h>

#include <audio_policy_conf.h>

#include <Volume.h>





namespace android {

#ifndef FLAC_OFFLOAD_ENABLED

#define AUDIO_FORMAT_FLAC 0x1D000000UL

#endif



#ifndef WMA_OFFLOAD_ENABLED

#define AUDIO_FORMAT_WMA 0x13000000UL

#define AUDIO_FORMAT_WMA_PRO 0x14000000UL

#endif



#ifndef ALAC_OFFLOAD_ENABLED

#define AUDIO_FORMAT_ALAC 0x1F000000UL

#endif



#ifndef APE_OFFLOAD_ENABLED

#define AUDIO_FORMAT_APE 0x20000000UL

#endif



#ifndef AFE_PROXY_ENABLED

#define AUDIO_DEVICE_OUT_PROXY 0x40000

#endif

// ----------------------------------------------------------------------------



class AudioPolicyManagerCustom: public AudioPolicyManager
@@ -38,71 +57,51 @@ public: 


        virtual ~AudioPolicyManagerCustom() {}



        virtual status_t setDeviceConnectionState(audio_devices_t device,

        status_t setDeviceConnectionStateInt(audio_devices_t device,

                                          audio_policy_dev_state_t state,

                                                          const char *device_address);

        virtual audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device,

                                                                              const char *device_address);

                                          const char *device_address,

                                          const char *device_name);

        virtual void setPhoneState(audio_mode_t state);

        virtual void setForceUse(audio_policy_force_use_t usage,

                                 audio_policy_forced_cfg_t config);

        virtual status_t stopOutput(audio_io_handle_t output,

                                    audio_stream_type_t stream,

                                    int session = 0);

        virtual audio_io_handle_t getInput(audio_source_t inputSource,

                                            uint32_t samplingRate,

                                            audio_format_t format,

                                            audio_channel_mask_t channelMask,

                                            audio_session_t session,

                                            audio_input_flags_t flags);



        // indicates to the audio policy manager that the input starts being used.

        virtual status_t startInput(audio_io_handle_t input,

                                    audio_session_t session);



        // indicates to the audio policy manager that the input stops being used.

        virtual status_t stopInput(audio_io_handle_t input,

                                   audio_session_t session);

        virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,

                                              int index,

                                              audio_devices_t device);

        virtual bool isOffloadSupported(const audio_offload_info_t& offloadInfo);



        // true if given state represents a device in a telephony or VoIP call

        virtual bool isStateInCall(int state);

protected:

        // return the strategy corresponding to a given stream type

        static routing_strategy getStrategy(audio_stream_type_t stream);



        // return appropriate device for streams handled by the specified strategy according to current

        // phone state, connected devices...

        // if fromCache is true, the device is returned from mDeviceForStrategy[],

        // otherwise it is determine by current state

        // (device connected,phone state, force use, a2dp output...)

        // This allows to:

        //  1 speed up process when the state is stable (when starting or stopping an output)

        //  2 access to either current device selection (fromCache == true) or

        // "future" device selection (fromCache == false) when called from a context

        //  where conditions are changing (setDeviceConnectionState(), setPhoneState()...) AND

        //  before updateDevicesAndOutputs() is called.

        virtual audio_devices_t getDeviceForStrategy(routing_strategy strategy,

                                                     bool fromCache);

        // select input device corresponding to requested audio source

        virtual audio_devices_t getDeviceForInputSource(audio_source_t inputSource);



        // compute the actual volume for a given stream according to the requested index and a particular

        // device

        virtual float computeVolume(audio_stream_type_t stream, int index,

                                    audio_io_handle_t output, audio_devices_t device);



        // check that volume change is permitted, compute and send new volume to audio hardware

        status_t checkAndSetVolume(audio_stream_type_t stream, int index, audio_io_handle_t output,

                                   audio_devices_t device, int delayMs = 0, bool force = false);



        // returns the category the device belongs to with regard to volume curve management

        static device_category getDeviceCategory(audio_devices_t device);

         status_t checkAndSetVolume(audio_stream_type_t stream,

                                                   int index,

                                                   const sp<SwAudioOutputDescriptor>& outputDesc,

                                                   audio_devices_t device,

                                                   int delayMs = 0, bool force = false);



        // selects the most appropriate device on output for current state

        // must be called every time a condition that affects the device choice for a given output is

        // changed: connected device, phone state, force use, output start, output stop..

        // see getDeviceForStrategy() for the use of fromCache parameter

        audio_devices_t getNewOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,

                                           bool fromCache);

        // returns true if given output is direct output

        bool isDirectOutput(audio_io_handle_t output);



        // if argument "device" is different from AUDIO_DEVICE_NONE,  startSource() will force

        // the re-evaluation of the output device.

        status_t startSource(sp<SwAudioOutputDescriptor> outputDesc,

                             audio_stream_type_t stream,

                             audio_devices_t device,

                             uint32_t *delayMs);

         status_t stopSource(sp<SwAudioOutputDescriptor> outputDesc,

                            audio_stream_type_t stream,

                            bool forceDeviceUpdate);

        // event is one of STARTING_OUTPUT, STARTING_BEACON, STOPPING_OUTPUT, STOPPING_BEACON   313

        // returns 0 if no mute/unmute event happened, the largest latency of the device where   314

        //   the mute/unmute happened 315

        uint32_t handleEventForBeacon(int){return 0;}

        uint32_t setBeaconMute(bool){return 0;}



        // handle special cases for sonification strategy while in call: mute streams or replace by

        // a special tone in the device used for communication

        void handleIncallSonification(audio_stream_type_t stream, bool starting, bool stateChange, audio_io_handle_t output);

        //parameter indicates of HDMI speakers disabled

        bool mHdmiAudioDisabled;

        //parameter indicates if HDMI plug in/out detected
@@ -119,20 +118,16 @@ private: 
        // internal method to return the output handle for the given device and format

        audio_io_handle_t getOutputForDevice(

                audio_devices_t device,

                audio_session_t session,

                audio_stream_type_t stream,

                uint32_t samplingRate,

                audio_format_t format,

                audio_channel_mask_t channelMask,

                audio_output_flags_t flags,

                const audio_offload_info_t *offloadInfo);



        // Used for voip + voice concurrency usecase

        int mPrevPhoneState;

        int mvoice_call_state;

#ifdef RECORD_PLAY_CONCURRENCY

        // Used for record + playback concurrency

        bool mIsInputRequestOnProgress;

#endif



};