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

Commit f1f22e77 authored by Eric Laurent's avatar Eric Laurent
Browse files

audio flinger: pass mixer configuration when opening an audio output 

Add the possibility for audio policy manager to indicate a mixer
audio configuration (channel mask, format, sampling rate)
different from the audio HAL stream configuration when opening an
output stream with IAudioflinger::openOutput().

Bug: 188502620
Test: atest audiopolicy_tests

Change-Id: I0b4eaa9cd3e5574b75e3b914c854f97c104ca07e
parent dd297848

media/libaudioclient/aidl/android/media/OpenOutputRequest.aidl

+3 −1
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
package android.media;



import android.media.AudioConfig;

import android.media.AudioConfigBase;

import android.media.AudioPort;



/**
@@ -25,7 +26,8 @@ import android.media.AudioPort; 
parcelable OpenOutputRequest {

    /** Interpreted as audio_module_handle_t. */

    int module;

    AudioConfig config;

    AudioConfig halConfig;

    AudioConfigBase mixerConfig;

    /** Type must be DEVICE. */

    AudioPort device;

    /** Bitmask, indexed by AudioOutputFlag. */

media/libaudioclient/fuzzer/audioflinger_fuzzer.cpp

+5 −1
Original line number Diff line number Diff line
@@ -648,11 +648,15 @@ status_t AudioFlingerFuzzer::invokeAudioOutputDevice() { 
    sp<DeviceDescriptorBase> device = new DeviceDescriptorBase(getValue(&mFdp, kDevices));

    audio_output_flags_t flags = getValue(&mFdp, kOutputFlags);



    audio_config_base_t mixerConfig = AUDIO_CONFIG_BASE_INITIALIZER;



    media::OpenOutputRequest request{};

    media::OpenOutputResponse response{};



    request.module = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_module_handle_t_int32_t(module));

    request.config = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_config_t_AudioConfig(config));

    request.halConfig = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_config_t_AudioConfig(config));

    request.mixerConfig =

            VALUE_OR_RETURN_STATUS(legacy2aidl_audio_config_base_t_AudioConfigBase(mixerConfig));

    request.device = VALUE_OR_RETURN_STATUS(legacy2aidl_DeviceDescriptorBase(device));

    request.flags = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_output_flags_t_int32_t_mask(flags));

services/audioflinger/AudioFlinger.cpp

+23 −18
Original line number Diff line number Diff line
@@ -2505,7 +2505,8 @@ void AudioFlinger::setAudioHwSyncForSession_l(PlaybackThread *thread, audio_sess 


sp<AudioFlinger::ThreadBase> AudioFlinger::openOutput_l(audio_module_handle_t module,

                                                        audio_io_handle_t *output,

                                                        audio_config_t *config,

                                                        audio_config_t *halConfig,

                                                        audio_config_base_t *mixerConfig __unused,

                                                        audio_devices_t deviceType,

                                                        const String8& address,

                                                        audio_output_flags_t flags)
@@ -2533,16 +2534,16 @@ sp<AudioFlinger::ThreadBase> AudioFlinger::openOutput_l(audio_module_handle_t mo 
        // Check only for Normal Mixing mode

        if (kEnableExtendedPrecision) {

            // Specify format (uncomment one below to choose)

            //config->format = AUDIO_FORMAT_PCM_FLOAT;

            //config->format = AUDIO_FORMAT_PCM_24_BIT_PACKED;

            //config->format = AUDIO_FORMAT_PCM_32_BIT;

            //config->format = AUDIO_FORMAT_PCM_8_24_BIT;

            // ALOGV("openOutput_l() upgrading format to %#08x", config->format);

            //halConfig->format = AUDIO_FORMAT_PCM_FLOAT;

            //halConfig->format = AUDIO_FORMAT_PCM_24_BIT_PACKED;

            //halConfig->format = AUDIO_FORMAT_PCM_32_BIT;

            //halConfig->format = AUDIO_FORMAT_PCM_8_24_BIT;

            // ALOGV("openOutput_l() upgrading format to %#08x", halConfig->format);

        }

        if (kEnableExtendedChannels) {

            // Specify channel mask (uncomment one below to choose)

            //config->channel_mask = audio_channel_out_mask_from_count(4);  // for USB 4ch

            //config->channel_mask = audio_channel_mask_from_representation_and_bits(

            //halConfig->channel_mask = audio_channel_out_mask_from_count(4);  // for USB 4ch

            //halConfig->channel_mask = audio_channel_mask_from_representation_and_bits(

            //        AUDIO_CHANNEL_REPRESENTATION_INDEX, (1 << 4) - 1);  // another 4ch example

        }

    }
@@ -2553,7 +2554,7 @@ sp<AudioFlinger::ThreadBase> AudioFlinger::openOutput_l(audio_module_handle_t mo 
            *output,

            deviceType,

            flags,

            config,

            halConfig,

            address.string());



    mHardwareStatus = AUDIO_HW_IDLE;
@@ -2573,8 +2574,8 @@ sp<AudioFlinger::ThreadBase> AudioFlinger::openOutput_l(audio_module_handle_t mo 
                ALOGV("openOutput_l() created offload output: ID %d thread %p",

                      *output, thread.get());

            } else if ((flags & AUDIO_OUTPUT_FLAG_DIRECT)

                    || !isValidPcmSinkFormat(config->format)

                    || !isValidPcmSinkChannelMask(config->channel_mask)) {

                    || !isValidPcmSinkFormat(halConfig->format)

                    || !isValidPcmSinkChannelMask(halConfig->channel_mask)) {

                thread = new DirectOutputThread(this, outputStream, *output, mSystemReady);

                ALOGV("openOutput_l() created direct output: ID %d thread %p",

                      *output, thread.get());
@@ -2601,8 +2602,10 @@ status_t AudioFlinger::openOutput(const media::OpenOutputRequest& request, 
{

    audio_module_handle_t module = VALUE_OR_RETURN_STATUS(

            aidl2legacy_int32_t_audio_module_handle_t(request.module));

    audio_config_t config = VALUE_OR_RETURN_STATUS(

            aidl2legacy_AudioConfig_audio_config_t(request.config));

    audio_config_t halConfig = VALUE_OR_RETURN_STATUS(

            aidl2legacy_AudioConfig_audio_config_t(request.halConfig));

    audio_config_base_t mixerConfig = VALUE_OR_RETURN_STATUS(

            aidl2legacy_AudioConfigBase_audio_config_base_t(request.mixerConfig));

    sp<DeviceDescriptorBase> device = VALUE_OR_RETURN_STATUS(

            aidl2legacy_DeviceDescriptorBase(request.device));

    audio_output_flags_t flags = VALUE_OR_RETURN_STATUS(
@@ -2615,9 +2618,9 @@ status_t AudioFlinger::openOutput(const media::OpenOutputRequest& request, 
              "Channels %#x, flags %#x",

              this, module,

              device->toString().c_str(),

              config.sample_rate,

              config.format,

              config.channel_mask,

              halConfig.sample_rate,

              halConfig.format,

              halConfig.channel_mask,

              flags);



    audio_devices_t deviceType = device->type();
@@ -2629,7 +2632,8 @@ status_t AudioFlinger::openOutput(const media::OpenOutputRequest& request, 


    Mutex::Autolock _l(mLock);



    sp<ThreadBase> thread = openOutput_l(module, &output, &config, deviceType, address, flags);

    sp<ThreadBase> thread = openOutput_l(module, &output, &halConfig,

            &mixerConfig, deviceType, address, flags);

    if (thread != 0) {

        if ((flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) == 0) {

            PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
@@ -2654,7 +2658,8 @@ status_t AudioFlinger::openOutput(const media::OpenOutputRequest& request, 
            mmapThread->ioConfigChanged(AUDIO_OUTPUT_OPENED);

        }

        response->output = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));

        response->config = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_config_t_AudioConfig(config));

        response->config =

                VALUE_OR_RETURN_STATUS(legacy2aidl_audio_config_t_AudioConfig(halConfig));

        response->latencyMs = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(latencyMs));

        response->flags = VALUE_OR_RETURN_STATUS(

                legacy2aidl_audio_output_flags_t_int32_t_mask(flags));

services/audioflinger/AudioFlinger.h

+2 −1
Original line number Diff line number Diff line
@@ -738,7 +738,8 @@ using effect_buffer_t = int16_t; 
                                           const String8& outputDeviceAddress);

              sp<ThreadBase> openOutput_l(audio_module_handle_t module,

                                          audio_io_handle_t *output,

                                          audio_config_t *config,

                                          audio_config_t *halConfig,

                                          audio_config_base_t *mixerConfig,

                                          audio_devices_t deviceType,

                                          const String8& address,

                                          audio_output_flags_t flags);

services/audioflinger/DeviceEffectManager.h

+7 −2
Original line number Diff line number Diff line
@@ -163,8 +163,13 @@ public: 
    bool isOffloadOrMmap() const override { return false; }



    uint32_t  sampleRate() const override { return 0; }

    audio_channel_mask_t channelMask() const override { return AUDIO_CHANNEL_NONE; }

    uint32_t channelCount() const override { return 0; }

    audio_channel_mask_t inChannelMask(int id __unused) const override {

        return AUDIO_CHANNEL_NONE;

    }

    uint32_t inChannelCount(int id __unused) const override { return 0; }

    audio_channel_mask_t outChannelMask() const override { return AUDIO_CHANNEL_NONE; }

    uint32_t outChannelCount() const override { return 0; }



    audio_channel_mask_t hapticChannelMask() const override { return AUDIO_CHANNEL_NONE; }

    size_t    frameCount() const override  { return 0; }

    uint32_t  latency() const override  { return 0; }