xref: /aosp_15_r20/cts/tests/tests/nativemedia/aaudio/jni/utils.h (revision b7c941bb3fa97aba169d73cee0bed2de8ac964bf)

/*
 * Copyright 2017 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.
 */
#ifndef CTS_MEDIA_TEST_AAUDIO_UTILS_H
#define CTS_MEDIA_TEST_AAUDIO_UTILS_H

#include <dlfcn.h>
#include <atomic>
#include <map>
#include <unordered_set>
#include <gtest/gtest.h>
#include <sys/system_properties.h>

#include <android/binder_auto_utils.h>
#include <android/binder_ibinder.h>

#include <aaudio/AAudio.h>
#include <system/audio.h> /* FCC_LIMIT */

#include "test_aaudio.h"    // NANOS_PER_MILLISECOND

int64_t getNanoseconds(clockid_t clockId = CLOCK_MONOTONIC);
const char* performanceModeToString(aaudio_performance_mode_t mode);
const char* sharingModeToString(aaudio_sharing_mode_t mode);

static constexpr const char* FEATURE_PLAYBACK = "android.hardware.audio.output";
static constexpr const char* FEATURE_RECORDING = "android.hardware.microphone";
static constexpr const char* FEATURE_LOW_LATENCY = "android.hardware.audio.low_latency";
bool deviceSupportsFeature(const char* feature);

class StreamBuilderHelper {
  public:
    struct Parameters {
        int32_t sampleRate;
        int32_t channelCount;
        aaudio_format_t dataFormat;
        aaudio_sharing_mode_t sharingMode;
        aaudio_performance_mode_t perfMode;
    };

    void initBuilder();
    void createAndVerifyStream(bool *success);
    void close();

    void startStream() {
        streamCommand(&AAudioStream_requestStart,
                AAUDIO_STREAM_STATE_STARTING, AAUDIO_STREAM_STATE_STARTED);
    }
    void pauseStream() {
        streamCommand(&AAudioStream_requestPause,
                AAUDIO_STREAM_STATE_PAUSING, AAUDIO_STREAM_STATE_PAUSED);
    }
    void stopStream() {
        streamCommand(&AAudioStream_requestStop,
                AAUDIO_STREAM_STATE_STOPPING, AAUDIO_STREAM_STATE_STOPPED);
    }

    void waitForState(aaudio_stream_state_t targetState) {
        aaudio_stream_state_t state = AAUDIO_STREAM_STATE_UNKNOWN;
        const int kNumTries = 4; // max number of states we expect to transition through
        for (int i = 0; ((i < kNumTries) && (state != targetState)); i++) {
            EXPECT_EQ(AAUDIO_OK, AAudioStream_waitForStateChange(stream(),
                                                                 state,
                                                                 &state,
                                                                 DEFAULT_STATE_TIMEOUT));
        }
    }

    void flushStream() {
        streamCommand(&AAudioStream_requestFlush,
                AAUDIO_STREAM_STATE_FLUSHING, AAUDIO_STREAM_STATE_FLUSHED);
    }

    AAudioStreamBuilder* builder() const { return mBuilder; }
    AAudioStream* stream() const { return mStream; }
    const Parameters& actual() const { return mActual; }
    int32_t framesPerBurst() const { return mFramesPerBurst; }

  protected:
    StreamBuilderHelper(aaudio_direction_t direction, int32_t sampleRate,
            int32_t channelCount, aaudio_format_t dataFormat,
            aaudio_sharing_mode_t sharingMode, aaudio_performance_mode_t perfMode);
    ~StreamBuilderHelper();

    typedef aaudio_result_t (StreamCommand)(AAudioStream*);
    void streamCommand(
            StreamCommand cmd, aaudio_stream_state_t fromState, aaudio_stream_state_t toState);

    static const std::map<aaudio_performance_mode_t, int64_t> sMaxFramesPerBurstMs;
    static const std::unordered_set<aaudio_format_t> sValidStreamFormats;
    const aaudio_direction_t mDirection;
    const Parameters mRequested;
    Parameters mActual;
    int32_t mFramesPerBurst;
    AAudioStreamBuilder *mBuilder;
    AAudioStream *mStream;

  private:
    const int32_t kMinValidSampleRate = 8000; // 8 kHz
    const int32_t kMaxValidSampleRate = 2000000; // 2 MHz
    const int32_t kMinValidChannelCount = 1;
    const int32_t kMaxValidChannelCount = FCC_LIMIT;
};

class InputStreamBuilderHelper : public StreamBuilderHelper {
  public:
    InputStreamBuilderHelper(
            aaudio_sharing_mode_t requestedSharingMode,
            aaudio_performance_mode_t requestedPerfMode,
            aaudio_format_t requestedFormat = AAUDIO_FORMAT_PCM_FLOAT,
            int32_t requestedSampleRate = 48000);
};

class OutputStreamBuilderHelper : public StreamBuilderHelper {
  public:
    OutputStreamBuilderHelper(
            aaudio_sharing_mode_t requestedSharingMode,
            aaudio_performance_mode_t requestedPerfMode,
            aaudio_format_t requestedFormat = AAUDIO_FORMAT_PCM_I16,
            int32_t requestSampleRate = 48000);
    void initBuilder();

  private:
    const int32_t kBufferCapacityFrames = 2000;
};

class AAudioExtensions {
public:
    AAudioExtensions();

    static bool isPolicyEnabled(int32_t policy) {
        return (policy == AAUDIO_POLICY_AUTO || policy == AAUDIO_POLICY_ALWAYS);
    }

    static AAudioExtensions &getInstance() {
        static AAudioExtensions instance;
        return instance;
    }

    static int getMMapPolicyProperty() {
        return getIntegerProperty("aaudio.mmap_policy", AAUDIO_UNSPECIFIED);
    }

    aaudio_policy_t getMMapPolicy() { return AAudio_getMMapPolicy(); }

    int32_t setMMapPolicy(aaudio_policy_t policy) { return AAudio_setMMapPolicy(policy); }

    bool isMMapUsed(AAudioStream* aaudioStream) { return AAudioStream_isMMapUsed(aaudioStream); }

    int32_t setMMapEnabled(bool enabled) {
        return setMMapPolicy(enabled ? AAUDIO_POLICY_AUTO : AAUDIO_POLICY_NEVER);
    }

    bool isMMapEnabled() { return isPolicyEnabled(AAudio_getMMapPolicy()); }

    bool isMMapSupported() const {
        return mMMapSupported;
    }

    bool isMMapExclusiveSupported() const {
        return mMMapExclusiveSupported;
    }

    aaudio_policy_t getPlatformMMapPolicy(AAudio_DeviceType device,
                                          aaudio_direction_t direction) const {
        return AAudio_getPlatformMMapPolicy(device, direction);
    }

    aaudio_policy_t getPlatformMMapExclusivePolicy(AAudio_DeviceType device,
                                                   aaudio_direction_t direction) const {
        return AAudio_getPlatformMMapExclusivePolicy(device, direction);
    }

private:

    static int getIntegerProperty(const char *name, int defaultValue);

    const bool   mMMapSupported;
    const bool   mMMapExclusiveSupported;
};

class AudioServerCrashMonitor {
public:
    static AudioServerCrashMonitor& getInstance() {
        static AudioServerCrashMonitor instance;
        return instance;
    }
    ~AudioServerCrashMonitor();

    void linkToDeath();

    bool isDeathRecipientLinked() const { return mDeathRecipientLinked; }
    void onAudioServerCrash();

private:
    AudioServerCrashMonitor();

    ::ndk::SpAIBinder getAudioFlinger();

    ::ndk::SpAIBinder mAudioFlinger;
    ::ndk::ScopedAIBinder_DeathRecipient mDeathRecipient;
    bool mDeathRecipientLinked = false;
};

class AAudioCtsBase : public ::testing::Test {
protected:
    void SetUp() override;
    void TearDown() override;

private:
    void checkIfAudioServerCrash();
};

bool isIEC61937Supported();

bool isEchoReferenceSupported();

void enableAudioOutputPermission();

void enableAudioHotwordPermission();

void disablePermissions();

bool isCompressedFormat(aaudio_format_t format);

#endif  // CTS_MEDIA_TEST_AAUDIO_UTILS_H