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

Commit b7de4f18 authored by Ashish Jain's avatar Ashish Jain Committed by Gerrit - the friendly Code Review server
Browse files

policy_hal: Enable Direct PCM for 24 bit PCM playback 

-Pass correct bit width when creating a direct pcm output.
-Control 16 bit and 24 bit PCM offload request based on
properties

Change-Id: I1d1c038acb6fd97a228df098383710eb4d27794d
parent 235d9108

policy_hal/AudioPolicyManager.cpp

+57 −66
Original line number Diff line number Diff line
@@ -487,42 +487,13 @@ bool AudioPolicyManagerCustom::isOffloadSupported(const audio_offload_info_t& of 
        return false;

    }



    char propValue[PROPERTY_VALUE_MAX];

    bool pcmOffload = false;

#ifdef PCM_OFFLOAD_ENABLED

    if ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_PCM_OFFLOAD) {

        bool prop_enabled = false;

        if ((AUDIO_FORMAT_PCM_16_BIT_OFFLOAD == offloadInfo.format) &&

               property_get("audio.offload.pcm.16bit.enable", propValue, NULL)) {

            prop_enabled = atoi(propValue) || !strncmp("true", propValue, 4);

        }



#ifdef PCM_OFFLOAD_ENABLED_24

        if ((AUDIO_FORMAT_PCM_24_BIT_OFFLOAD == offloadInfo.format) &&

               property_get("audio.offload.pcm.24bit.enable", propValue, NULL)) {

            prop_enabled = atoi(propValue) || !strncmp("true", propValue, 4);

        }

#endif



        if (prop_enabled) {

            ALOGI("PCM offload property is enabled");

            pcmOffload = true;

        }



        if (!pcmOffload) {

            ALOGD("system property not enabled for PCM offload format[%x]",offloadInfo.format);

            return false;

        }

    }

#endif

    if (!pcmOffload) {

    // Check if offload has been disabled

        if (property_get("audio.offload.disable", propValue, "0")) {

            if (atoi(propValue) != 0) {

                ALOGV("offload disabled by audio.offload.disable=%s", propValue );

    bool offloadDisabled = property_get_bool("audio.offload.disable", false);

    if (offloadDisabled) {

        ALOGI("offload disabled by audio.offload.disable=%d", offloadDisabled);

        return false;

    }

        }



    //check if it's multi-channel AAC (includes sub formats) and FLAC format

    if ((popcount(offloadInfo.channel_mask) > 2) &&

        (((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_AAC) ||
@@ -553,13 +524,12 @@ bool AudioPolicyManagerCustom::isOffloadSupported(const audio_offload_info_t& of 
    const bool allowOffloadStreamingWithVideo = property_get_bool("av.streaming.offload.enable",

                                                               false /*default value*/);

    if (offloadInfo.has_video && offloadInfo.is_streaming && !allowOffloadStreamingWithVideo) {

            ALOGW("offload disabled by av.streaming.offload.enable = %s ", propValue );

        ALOGW("offload disabled by av.streaming.offload.enable %d",allowOffloadStreamingWithVideo);

        return false;

    }



    }



    //If duration is less than minimum value defined in property, return false

    char propValue[PROPERTY_VALUE_MAX];

    if (property_get("audio.offload.min.duration.secs", propValue, NULL)) {

        if (offloadInfo.duration_us < (atoi(propValue) * 1000000 )) {

            ALOGV("Offload denied by duration < audio.offload.min.duration.secs(=%s)", propValue);
@@ -571,17 +541,17 @@ bool AudioPolicyManagerCustom::isOffloadSupported(const audio_offload_info_t& of 
        //do not check duration for other audio formats, e.g. dolby AAC/AC3 and amrwb+ formats

        if ((offloadInfo.format == AUDIO_FORMAT_MP3) ||

            ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_AAC) ||

            ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_VORBIS) ||

#ifdef AUDIO_EXTN_FORMATS_ENABLED

            ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_FLAC) ||

            ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_WMA) ||

            ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_VORBIS))

            return false;



#ifdef AUDIO_EXTN_FORMATS_ENABLED

        if (((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_WMA) ||

            ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_WMA_PRO) ||

            ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_ALAC) ||

            ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_APE) ||

#endif

            pcmOffload)

            ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_APE))

            return false;



#endif

    }



    // Do not allow offloading if one non offloadable effect is enabled. This prevents from
@@ -1326,6 +1296,19 @@ bool AudioPolicyManagerCustom::isDirectOutput(audio_io_handle_t output) { 
    return false;

}



bool static isDirectPCMEnabled(int bitWidth)

{

    bool directPCMEnabled = false;

    if (bitWidth == 24 || bitWidth == 32)

        directPCMEnabled =

             property_get_bool("audio.offload.pcm.24bit.enable", false);

    else

        directPCMEnabled =

             property_get_bool("audio.offload.pcm.16bit.enable", false);



    return directPCMEnabled;

}



status_t AudioPolicyManagerCustom::getOutputForAttr(const audio_attributes_t *attr,

                                              audio_io_handle_t *output,

                                              audio_session_t session,
@@ -1340,14 +1323,22 @@ status_t AudioPolicyManagerCustom::getOutputForAttr(const audio_attributes_t *at 
{

    audio_offload_info_t tOffloadInfo = AUDIO_INFO_INITIALIZER;



    bool pcmOffloadEnabled = property_get_bool("audio.offload.track.enable", false);

    bool offloadDisabled = property_get_bool("audio.offload.disable", false);

    uint32_t bitWidth = (audio_bytes_per_sample(format) * 8);



    if (offloadDisabled) {

        ALOGI("offload disabled by audio.offload.disable=%d", offloadDisabled);

    }



    if (!offloadDisabled && (offloadInfo == NULL) &&

        isDirectPCMEnabled(bitWidth) &&

        (flags == AUDIO_OUTPUT_FLAG_NONE)) {



    if (offloadInfo == NULL && pcmOffloadEnabled) {

        tOffloadInfo.sample_rate  = samplingRate;

        tOffloadInfo.channel_mask = channelMask;

        tOffloadInfo.format = format;

        tOffloadInfo.stream_type = *stream;

        tOffloadInfo.bit_width = 16;    //hard coded for PCM_16

        tOffloadInfo.bit_width = bitWidth;

        if (attr != NULL) {

            ALOGV("found attribute .. setting usage %d ", attr->usage);

            tOffloadInfo.usage = attr->usage;