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

Commit ac9858be authored by Mikhail Naganov's avatar Mikhail Naganov
Browse files

Use and test patch utilities from system/audio.h 

Use `audio_patch_is_valid` function.

Add basic tests for the following functions:
  audio_patch_is_valid
  audio_port_config_has_hw_av_sync
  audio_patches_are_equal

Bug: 63901775
Test: systemaudio_tests
Change-Id: I378ab544e4148fda0dd7b9520d6fd57ff01cb34b
parent 908c7d77

services/audioflinger/PatchPanel.cpp

+1 −3
Original line number Diff line number Diff line
@@ -110,9 +110,7 @@ status_t AudioFlinger::PatchPanel::createAudioPatch(const struct audio_patch *pa 
    status_t status = NO_ERROR;

    audio_patch_handle_t halHandle = AUDIO_PATCH_HANDLE_NONE;



    if (patch->num_sources == 0 || patch->num_sources > AUDIO_PATCH_PORTS_MAX ||

            (patch->num_sinks == 0 && patch->num_sources != 2) ||

            patch->num_sinks > AUDIO_PATCH_PORTS_MAX) {

    if (!audio_patch_is_valid(patch) || (patch->num_sinks == 0 && patch->num_sources != 2)) {

        return BAD_VALUE;

    }

    // limit number of sources to 1 for now or 2 sources for special cross hw module case.

services/audiopolicy/managerdefault/AudioPolicyManager.cpp

+1 −2
Original line number Diff line number Diff line
@@ -2834,8 +2834,7 @@ status_t AudioPolicyManager::createAudioPatch(const struct audio_patch *patch, 
    }

    ALOGV("createAudioPatch() num sources %d num sinks %d", patch->num_sources, patch->num_sinks);



    if (patch->num_sources == 0 || patch->num_sources > AUDIO_PATCH_PORTS_MAX ||

            patch->num_sinks == 0 || patch->num_sinks > AUDIO_PATCH_PORTS_MAX) {

    if (!audio_patch_is_valid(patch)) {

        return BAD_VALUE;

    }

    // only one source per audio patch supported for now

services/audiopolicy/tests/Android.mk

+23 −0
Original line number Diff line number Diff line
@@ -29,3 +29,26 @@ LOCAL_CFLAGS := -Werror -Wall 
LOCAL_MULTILIB := $(AUDIOSERVER_MULTILIB)



include $(BUILD_NATIVE_TEST)



# system/audio.h utilities test



include $(CLEAR_VARS)



LOCAL_SHARED_LIBRARIES := \

  libbase \

  liblog \

  libmedia_helper \

  libutils



LOCAL_SRC_FILES := \

  systemaudio_tests.cpp \



LOCAL_MODULE := systemaudio_tests



LOCAL_MODULE_TAGS := tests



LOCAL_CFLAGS := -Werror -Wall



LOCAL_MULTILIB := $(AUDIOSERVER_MULTILIB)



include $(BUILD_NATIVE_TEST)

services/audiopolicy/tests/systemaudio_tests.cpp

0 → 100644
+117 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2018 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <gtest/gtest.h>



#define LOG_TAG "SysAudio_Test"

#include <log/log.h>

#include <media/PatchBuilder.h>

#include <system/audio.h>



using namespace android;



TEST(SystemAudioTest, PatchInvalid) {

    audio_patch patch{};

    ASSERT_FALSE(audio_patch_is_valid(&patch));

    patch.num_sources = AUDIO_PATCH_PORTS_MAX + 1;

    patch.num_sinks = 1;

    ASSERT_FALSE(audio_patch_is_valid(&patch));

    patch.num_sources = 1;

    patch.num_sinks = AUDIO_PATCH_PORTS_MAX + 1;

    ASSERT_FALSE(audio_patch_is_valid(&patch));

    patch.num_sources = 0;

    patch.num_sinks = 1;

    ASSERT_FALSE(audio_patch_is_valid(&patch));

}



TEST(SystemAudioTest, PatchValid) {

    const audio_port_config src = {

        .id = 1, .role = AUDIO_PORT_ROLE_SOURCE, .type = AUDIO_PORT_TYPE_DEVICE };

    // It's OK not to have sinks.

    ASSERT_TRUE(audio_patch_is_valid((PatchBuilder{}).addSource(src).patch()));

    const audio_port_config sink = {

        .id = 2, .role = AUDIO_PORT_ROLE_SINK, .type = AUDIO_PORT_TYPE_DEVICE };

    ASSERT_TRUE(audio_patch_is_valid((PatchBuilder{}).addSource(src).addSink(sink).patch()));

    ASSERT_TRUE(audio_patch_is_valid(

                    (PatchBuilder{}).addSource(src).addSource(src).addSink(sink).patch()));

    ASSERT_TRUE(audio_patch_is_valid(

                    (PatchBuilder{}).addSource(src).addSink(sink).addSink(sink).patch()));

    ASSERT_TRUE(audio_patch_is_valid(

                    (PatchBuilder{}).addSource(src).addSource(src).

                    addSink(sink).addSink(sink).patch()));

}



TEST(SystemAudioTest, PatchHwAvSync) {

    audio_port_config device_src_cfg = {

        .id = 1, .role = AUDIO_PORT_ROLE_SOURCE, .type = AUDIO_PORT_TYPE_DEVICE };

    ASSERT_FALSE(audio_port_config_has_hw_av_sync(&device_src_cfg));

    device_src_cfg.config_mask |= AUDIO_PORT_CONFIG_FLAGS;

    ASSERT_FALSE(audio_port_config_has_hw_av_sync(&device_src_cfg));

    device_src_cfg.flags.input = AUDIO_INPUT_FLAG_HW_AV_SYNC;

    ASSERT_TRUE(audio_port_config_has_hw_av_sync(&device_src_cfg));



    audio_port_config device_sink_cfg = {

        .id = 1, .role = AUDIO_PORT_ROLE_SINK, .type = AUDIO_PORT_TYPE_DEVICE };

    ASSERT_FALSE(audio_port_config_has_hw_av_sync(&device_sink_cfg));

    device_sink_cfg.config_mask |= AUDIO_PORT_CONFIG_FLAGS;

    ASSERT_FALSE(audio_port_config_has_hw_av_sync(&device_sink_cfg));

    device_sink_cfg.flags.output = AUDIO_OUTPUT_FLAG_HW_AV_SYNC;

    ASSERT_TRUE(audio_port_config_has_hw_av_sync(&device_sink_cfg));



    audio_port_config mix_sink_cfg = {

        .id = 1, .role = AUDIO_PORT_ROLE_SINK, .type = AUDIO_PORT_TYPE_MIX };

    ASSERT_FALSE(audio_port_config_has_hw_av_sync(&mix_sink_cfg));

    mix_sink_cfg.config_mask |= AUDIO_PORT_CONFIG_FLAGS;

    ASSERT_FALSE(audio_port_config_has_hw_av_sync(&mix_sink_cfg));

    mix_sink_cfg.flags.input = AUDIO_INPUT_FLAG_HW_AV_SYNC;

    ASSERT_TRUE(audio_port_config_has_hw_av_sync(&mix_sink_cfg));



    audio_port_config mix_src_cfg = {

        .id = 1, .role = AUDIO_PORT_ROLE_SOURCE, .type = AUDIO_PORT_TYPE_MIX };

    ASSERT_FALSE(audio_port_config_has_hw_av_sync(&mix_src_cfg));

    mix_src_cfg.config_mask |= AUDIO_PORT_CONFIG_FLAGS;

    ASSERT_FALSE(audio_port_config_has_hw_av_sync(&mix_src_cfg));

    mix_src_cfg.flags.output = AUDIO_OUTPUT_FLAG_HW_AV_SYNC;

    ASSERT_TRUE(audio_port_config_has_hw_av_sync(&mix_src_cfg));

}



TEST(SystemAudioTest, PatchEqual) {

    const audio_patch patch1{}, patch2{};

    // Invalid patches are not equal.

    ASSERT_FALSE(audio_patches_are_equal(&patch1, &patch2));

    const audio_port_config src = {

        .id = 1, .role = AUDIO_PORT_ROLE_SOURCE, .type = AUDIO_PORT_TYPE_DEVICE };

    const audio_port_config sink = {

        .id = 2, .role = AUDIO_PORT_ROLE_SINK, .type = AUDIO_PORT_TYPE_DEVICE };

    ASSERT_FALSE(audio_patches_are_equal(

                    (PatchBuilder{}).addSource(src).patch(),

                    (PatchBuilder{}).addSource(src).addSink(sink).patch()));

    ASSERT_TRUE(audio_patches_are_equal(

                    (PatchBuilder{}).addSource(src).addSink(sink).patch(),

                    (PatchBuilder{}).addSource(src).addSink(sink).patch()));

    ASSERT_FALSE(audio_patches_are_equal(

                    (PatchBuilder{}).addSource(src).addSink(sink).patch(),

                    (PatchBuilder{}).addSource(src).addSource(src).addSink(sink).patch()));

    audio_port_config sink_hw_av_sync = sink;

    sink_hw_av_sync.config_mask |= AUDIO_PORT_CONFIG_FLAGS;

    sink_hw_av_sync.flags.output = AUDIO_OUTPUT_FLAG_HW_AV_SYNC;

    ASSERT_FALSE(audio_patches_are_equal(

                    (PatchBuilder{}).addSource(src).addSink(sink).patch(),

                    (PatchBuilder{}).addSource(src).addSink(sink_hw_av_sync).patch()));

    ASSERT_TRUE(audio_patches_are_equal(

                    (PatchBuilder{}).addSource(src).addSink(sink_hw_av_sync).patch(),

                    (PatchBuilder{}).addSource(src).addSink(sink_hw_av_sync).patch()));

}