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

Commit 7f6a6b04 authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 7584587 from a1e8ed37 to sc-v2-release 

Change-Id: Ie2c6a4bcbc87f8d62a115b09ca2d4669db914734
parents 95fa27dc a1e8ed37

media/libaudioclient/IAudioFlinger.cpp

+7 −2
Original line number Diff line number Diff line
@@ -665,7 +665,11 @@ status_t AudioFlingerClientAdapter::getAudioPort(struct audio_port_v7* port) { 
status_t AudioFlingerClientAdapter::createAudioPatch(const struct audio_patch* patch,

                                                     audio_patch_handle_t* handle) {

    media::AudioPatch patchAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_patch_AudioPatch(*patch));

    int32_t aidlRet;

    int32_t aidlRet = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(

                    AUDIO_PATCH_HANDLE_NONE));

    if (handle != nullptr) {

        aidlRet = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(*handle));

    }

    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(

            mDelegate->createAudioPatch(patchAidl, &aidlRet)));

    if (handle != nullptr) {
@@ -1144,7 +1148,8 @@ Status AudioFlingerServerAdapter::getAudioPort(const media::AudioPort& port, 
Status AudioFlingerServerAdapter::createAudioPatch(const media::AudioPatch& patch,

                                                   int32_t* _aidl_return) {

    audio_patch patchLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_AudioPatch_audio_patch(patch));

    audio_patch_handle_t handleLegacy;

    audio_patch_handle_t handleLegacy = VALUE_OR_RETURN_BINDER(

            aidl2legacy_int32_t_audio_patch_handle_t(*_aidl_return));

    RETURN_BINDER_IF_ERROR(mDelegate->createAudioPatch(&patchLegacy, &handleLegacy));

    *_aidl_return = VALUE_OR_RETURN_BINDER(legacy2aidl_audio_patch_handle_t_int32_t(handleLegacy));

    return Status::ok();

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));

media/libaudioclient/include/media/AudioCommonTypes.h

+36 −0
Original line number Diff line number Diff line
@@ -41,6 +41,42 @@ constexpr bool operator!=(const audio_attributes_t &lhs, const audio_attributes_ 
    return !(lhs==rhs);

}



constexpr bool operator==(const audio_offload_info_t &lhs, const audio_offload_info_t &rhs)

{

    return lhs.version == rhs.version && lhs.size == rhs.size &&

           lhs.sample_rate == rhs.sample_rate && lhs.channel_mask == rhs.channel_mask &&

           lhs.format == rhs.format && lhs.stream_type == rhs.stream_type &&

           lhs.bit_rate == rhs.bit_rate && lhs.duration_us == rhs.duration_us &&

           lhs.has_video == rhs.has_video && lhs.is_streaming == rhs.is_streaming &&

           lhs.bit_width == rhs.bit_width && lhs.offload_buffer_size == rhs.offload_buffer_size &&

           lhs.usage == rhs.usage && lhs.encapsulation_mode == rhs.encapsulation_mode &&

           lhs.content_id == rhs.content_id && lhs.sync_id == rhs.sync_id;

}

constexpr bool operator!=(const audio_offload_info_t &lhs, const audio_offload_info_t &rhs)

{

    return !(lhs==rhs);

}



constexpr bool operator==(const audio_config_t &lhs, const audio_config_t &rhs)

{

    return lhs.sample_rate == rhs.sample_rate && lhs.channel_mask == rhs.channel_mask &&

           lhs.format == rhs.format && lhs.offload_info == rhs.offload_info;

}

constexpr bool operator!=(const audio_config_t &lhs, const audio_config_t &rhs)

{

    return !(lhs==rhs);

}



constexpr bool operator==(const audio_config_base_t &lhs, const audio_config_base_t &rhs)

{

    return lhs.sample_rate == rhs.sample_rate && lhs.channel_mask == rhs.channel_mask &&

           lhs.format == rhs.format;

}

constexpr bool operator!=(const audio_config_base_t &lhs, const audio_config_base_t &rhs)

{

    return !(lhs==rhs);

}



enum volume_group_t : uint32_t;

static const volume_group_t VOLUME_GROUP_NONE = static_cast<volume_group_t>(-1);

services/audioflinger/AudioFlinger.cpp

+33 −20
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;
@@ -2568,13 +2569,20 @@ sp<AudioFlinger::ThreadBase> AudioFlinger::openOutput_l(audio_module_handle_t mo 
            return thread;

        } else {

            sp<PlaybackThread> thread;

            if (flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {

            //TODO: b/193496180 use virtualizer stage flag at audio HAL when available

            if (flags == (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_FAST

                                                    | AUDIO_OUTPUT_FLAG_DEEP_BUFFER)) {

                thread = new VirtualizerStageThread(this, outputStream, *output,

                                                    mSystemReady, mixerConfig);

                ALOGD("openOutput_l() created virtualizer output: ID %d thread %p",

                      *output, thread.get());

            } else if (flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {

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

                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 +2609,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 +2625,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 +2639,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 +2665,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));
@@ -3801,7 +3813,8 @@ status_t AudioFlinger::createEffect(const media::CreateEffectRequest& request, 
                io = mPlaybackThreads.keyAt(0);

            }

            ALOGV("createEffect() got io %d for effect %s", io, descOut.name);

        } else if (checkPlaybackThread_l(io) != nullptr) {

        } else if (checkPlaybackThread_l(io) != nullptr

                        && sessionId != AUDIO_SESSION_OUTPUT_STAGE) {

            // allow only one effect chain per sessionId on mPlaybackThreads.

            for (size_t i = 0; i < mPlaybackThreads.size(); i++) {

                const audio_io_handle_t checkIo = mPlaybackThreads.keyAt(i);