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

Commit 270b7762 authored by jasmine cha's avatar jasmine cha Committed by Jasmine Cha
Browse files

audio: porting MAXXAUDIO 

  - use effect module to monitor stream's volume
  - the control(maxxaudio) monitors active device and
    changed volume from HAL, and send audio calibration
    to acdb via acdb_loader.
  - support specific USB headset

  Enabled function:
  - LR channels swap
  - load external tuning table for volume preset feature

Bug: 74360112
Test: manual effect test, usb headset test
Change-Id: I9b35436d6abebcfa250beb4857dfa0be9248f2b5
parent c89321b3

hal/Android.mk

+6 −0
Original line number Diff line number Diff line
@@ -183,10 +183,16 @@ ifeq ($(strip $(AUDIO_FEATURE_ENABLED_SND_MONITOR)), true) 
    LOCAL_SRC_FILES += audio_extn/sndmonitor.c

endif





ifeq ($(strip $(AUDIO_FEATURE_ENABLED_USB_SERVICE_INTERVAL)), true)

    LOCAL_CFLAGS += -DUSB_SERVICE_INTERVAL_ENABLED

endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_MAXX_AUDIO)), true)

    LOCAL_CFLAGS += -DMAXXAUDIO_QDSP_ENABLED

    LOCAL_SRC_FILES += audio_extn/maxxaudio.c

endif



LOCAL_SHARED_LIBRARIES += libbase libhidlbase libhwbinder libutils android.hardware.power@1.2 liblog



LOCAL_SRC_FILES += audio_perf.cpp

hal/audio_extn/maxxaudio.c

0 → 100644
+627 −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.

 */



#define LOG_TAG "audio_hw_waves"

/*#define LOG_NDEBUG 0*/



#include <stdlib.h>

#include <dlfcn.h>

#include <pthread.h>

#include <unistd.h>

#include <cutils/str_parms.h>

#include <log/log.h>

#include <audio_hw.h>

#include <system/audio.h>

#include <platform_api.h>

#include <string.h>

#include <math.h>

#include "audio_extn.h"

#include "maxxaudio.h"



#define LIB_MA_PARAM "libmaqdspparams.so"

#define LIB_MA_PATH "vendor/lib/"

#define PRESET_PATH "/vendor/etc/default.mps"

#define USER_PRESET_PATH ""

#define CONFIG_PATH "/vendor/etc/maxx_conf.ini"

#define CAL_PRESIST_STR "cal_persist"

#define CAL_SAMPLERATE_STR "cal_samplerate"



#define MA_QDSP_PARAM_INIT "maxxaudio_qdsp_parameters_initialize"

#define MA_QDSP_PARAM_DEINIT "maxxaudio_qdsp_parameters_uninitialize"

#define MA_QDSP_SET_LR_SWAP "maxxaudio_qdsp_set_lr_swap"

#define MA_QDSP_SET_MODE "maxxaudio_qdsp_set_sound_mode"

#define MA_QDSP_SET_VOL "maxxaudio_qdsp_set_volume"

#define MA_QDSP_SET_VOLT "maxxaudio_qdsp_set_volume_table"



#define SUPPORT_DEV "Blackbird"

#define SUPPORTED_USB  0x01



struct ma_audio_cal_settings {

    void *platform;

    int app_type;

    audio_devices_t device;

};



struct ma_state {

    float vol;

    bool active;

};



typedef enum MA_STREAM_TYPE {

    STREAM_MIN_STREAM_TYPES,

    STREAM_VOICE = STREAM_MIN_STREAM_TYPES,

    STREAM_SYSTEM,

    STREAM_RING,

    STREAM_MUSIC,

    STREAM_ALARM,

    STREAM_NOTIFICATION ,

    STREAM_MAX_TYPES,

} ma_stream_type_t;



typedef enum MA_CMD {

    MA_CMD_VOL,

    MA_CMD_SWAP_ENABLE,

    MA_CMD_SWAP_DISABLE,

} ma_cmd_t;



typedef void *ma_audio_cal_handle_t;

typedef int (*set_audio_cal_t)(const struct ma_audio_cal_settings *, const char *);



typedef bool (*ma_param_init_t)(

                ma_audio_cal_handle_t *,

                void *, const char *, const char *,

                const char *, set_audio_cal_t);



typedef bool (*ma_param_deinit_t)(ma_audio_cal_handle_t);



typedef bool (*ma_set_lr_swap_t)(

                ma_audio_cal_handle_t,

                const struct ma_audio_cal_settings *, bool);



typedef bool (*ma_set_sound_mode_t)(

                ma_audio_cal_handle_t,

                const struct ma_audio_cal_settings *, unsigned int);



typedef bool (*ma_set_volume_t)(

                ma_audio_cal_handle_t,

                const struct ma_audio_cal_settings *, double);



typedef bool (*ma_set_volume_table_t)(

                ma_audio_cal_handle_t,

                const struct ma_audio_cal_settings *,

                size_t, struct ma_state *);



struct ma_platform_data {

    void *waves_handle;

    pthread_mutex_t lock;

    ma_param_init_t          ma_param_init;

    ma_param_deinit_t        ma_param_deinit;

    ma_set_lr_swap_t         ma_set_lr_swap;

    ma_set_sound_mode_t      ma_set_sound_mode;

    ma_set_volume_t          ma_set_volume;

    ma_set_volume_table_t    ma_set_volume_table;

};



ma_audio_cal_handle_t g_ma_audio_cal_handle = NULL;

static uint16_t g_supported_dev = 0;

static struct ma_state ma_cur_state_table[STREAM_MAX_TYPES];

static struct ma_platform_data *my_data = NULL;



static int set_audio_cal(

        const struct ma_audio_cal_settings *audio_cal_settings,

        const char *audio_cal)



{

    ALOGV("set_audio_cal: %s", audio_cal);



    return platform_set_parameters(audio_cal_settings->platform,

                                   str_parms_create_str(audio_cal));

}



static bool ma_set_lr_swap_l(

        const struct ma_audio_cal_settings *audio_cal_settings,

        bool swap)

{

    return my_data->ma_set_lr_swap(g_ma_audio_cal_handle, audio_cal_settings, swap);

}



static bool ma_set_sound_mode_l(

        const struct ma_audio_cal_settings *audio_cal_settings,

        int sound_mode)

{

    return my_data->ma_set_sound_mode(g_ma_audio_cal_handle,

                                        audio_cal_settings, sound_mode);

}



static bool ma_set_volume_l(

        const struct ma_audio_cal_settings *audio_cal_settings,

        double volume)

{

    return my_data->ma_set_volume(g_ma_audio_cal_handle, audio_cal_settings, volume);

}



static bool ma_set_volume_table_l(

        const struct ma_audio_cal_settings *audio_cal_settings,

        size_t num_streams, struct ma_state *volume_table)

{

    return my_data->ma_set_volume_table(

                     g_ma_audio_cal_handle,

                     audio_cal_settings,

                     num_streams,

                     volume_table);



}



static inline bool valid_usecase(struct audio_usecase *usecase)

{

    if ((usecase->type == PCM_PLAYBACK) &&

        /* supported usecases */

        ((usecase->id == USECASE_AUDIO_PLAYBACK_DEEP_BUFFER) ||

         (usecase->id == USECASE_AUDIO_PLAYBACK_LOW_LATENCY) ||

         (usecase->id == USECASE_AUDIO_PLAYBACK_OFFLOAD)) &&

        /* support devices */

        ((usecase->devices & AUDIO_DEVICE_OUT_SPEAKER) ||

         (usecase->devices & AUDIO_DEVICE_OUT_SPEAKER_SAFE) ||

         (usecase->devices & AUDIO_DEVICE_OUT_ALL_A2DP) ||

         (usecase->devices & AUDIO_DEVICE_OUT_ALL_USB)))



        return true;



    ALOGV("%s: not support type %d usecase %d device %d",

           __func__, usecase->type, usecase->id, usecase->devices);



    return false;

}



// already hold lock

static inline bool is_active()

{

    ma_stream_type_t i = 0;



    for (i = 0; i < STREAM_MAX_TYPES; i++)

        if (ma_cur_state_table[i].active &&

                (ma_cur_state_table[i].vol != 0))

            return true;



    return false;

}



static bool check_and_send_all_audio_cal(struct audio_device *adev, ma_cmd_t cmd)

{

    int i = 0;

    bool ret = false;

    float vol = 0;

    struct listnode *node;

    struct audio_usecase *usecase;

    struct ma_audio_cal_settings *ma_cal = NULL;



    // alloct

    ma_cal = (struct ma_audio_cal_settings *)malloc(sizeof(struct ma_audio_cal_settings));



    if (ma_cal == NULL) {

        ALOGE("%s: ma_cal alloct fail", __func__);

        return ret;

    }



    list_for_each(node, &adev->usecase_list) {

        usecase = node_to_item(node, struct audio_usecase, list);

        if (valid_usecase(usecase)) {

            ma_cal->platform = adev->platform;

            ma_cal->app_type = usecase->stream.out->app_type_cfg.app_type;

            ma_cal->device = usecase->stream.out->devices;

            ALOGV("%s: send usecase(%d) app_type(%d) device(%d)",

                      __func__, usecase->id, ma_cal->app_type, ma_cal->device);



            switch (cmd) {

                case MA_CMD_VOL:

                    ret = ma_set_volume_table_l(ma_cal, STREAM_MAX_TYPES,

                                                  ma_cur_state_table);

                    if (ret)

                        ALOGV("Waves: ma_set_volume_table_l success");

                    else

                        ALOGE("Waves: ma_set_volume_table_l %f returned with error.", vol);



                    ALOGV("%s: send volume table === Start", __func__);

                    for (i = 0; i < STREAM_MAX_TYPES; i++)

                        ALOGV("%s: stream(%d) volume(%f) active(%s)", __func__, i,

                            ma_cur_state_table[i].vol,

                            ma_cur_state_table[i].active ? "T" : "F");

                    ALOGV("%s: send volume table === End", __func__);

                    break;

                case MA_CMD_SWAP_ENABLE:

                    ret = ma_set_lr_swap_l(ma_cal, true);

                    if (ret)

                        ALOGV("Waves: ma_set_lr_swap_l enable returned with success.");

                    else

                        ALOGE("Waves: ma_set_lr_swap_l enable returned with error.");

                    break;

                case MA_CMD_SWAP_DISABLE:

                    ret = ma_set_lr_swap_l(ma_cal, false);

                    if (ret)

                        ALOGV("Waves: ma_set_lr_swap_l disable returned with success.");

                    else

                        ALOGE("Waves: ma_set_lr_swap_l disable returned with error.");

                    break;

                default:

                    ALOGE("%s: unsupported cmd %d", __func__, cmd);

            }



        }

    }

    free(ma_cal);



    return ret;

}



static bool find_sup_dev(char *name)

{

    char *token;

    const char s[2] = ",";

    bool ret = false;

    char sup_devs[128];



    // the rule of comforming suppored dev's name

    // 1. Both string len are equal

    // 2. Both string content are equal



    strncpy(sup_devs, SUPPORT_DEV, sizeof(sup_devs));

    token = strtok(sup_devs, s);

    while (token != NULL) {

        if (strncmp(token, name, strlen(token)) == 0 &&

            strlen(token) == strlen(name)) {

            ALOGD("%s: support dev %s", __func__, token);

            ret = true;

            break;

        }

        token = strtok(NULL, s);

    }



    return ret;

}



static void ma_set_swap_l(struct audio_device *adev, bool enable)

{

    if (!my_data) {

        ALOGE("%s: maxxaudio isn't initialized.", __func__);

        return;

    }

    if (enable)

        check_and_send_all_audio_cal(adev, MA_CMD_SWAP_ENABLE);

    else

        check_and_send_all_audio_cal(adev, MA_CMD_SWAP_DISABLE);

}



static void ma_support_usb(bool enable, int card)

{

    char path[128];

    char id[32];

    int ret = 0;

    int32_t fd = -1;

    char *idd;



    if (enable) {

        ret = snprintf(path, sizeof(path), "/proc/asound/card%u/id", card);

        if (ret < 0) {

            ALOGE("%s: failed on snprintf (%d) to path %s\n",

              __func__, ret, path);

            goto done;

        }

        fd = open(path, O_RDONLY);

        if (fd < 0) {

            ALOGE("%s: error failed to open id file %s error: %d\n",

                  __func__, path, errno);

            goto done;

        }

        if (read(fd, id, sizeof(id)) < 0) {

            ALOGE("%s: file read error", __func__);

            goto done;

        }

        //replace '\n' to '\0'

        idd = strtok(id, "\n");



        if (find_sup_dev(idd)) {

            ALOGV("%s: support device name is %s", __func__, id);

            g_supported_dev |= SUPPORTED_USB;

        } else

            ALOGV("%s: device %s isn't found from %s", __func__, id, SUPPORT_DEV);

    } else {

        g_supported_dev &= ~SUPPORTED_USB;

    }



done:

    if (fd >= 0) close(fd);

}



// adev_init lock held

void audio_extn_ma_init(void *platform)

{

    ma_stream_type_t i = 0;

    int ret = 0;

    char lib_path[256];



    if (platform == NULL) {

        ALOGE("%s: platform is NULL", __func__);

        goto error;

    }



    if (my_data) { free(my_data); }

    my_data = calloc(1, sizeof(struct ma_platform_data));

    if (my_data == NULL) {

        ALOGE("%s: ma_cal alloct fail", __func__);

        goto error;

    }



    pthread_mutex_init(&my_data->lock, NULL);



    ret = snprintf(lib_path, sizeof(lib_path), "%s/%s", LIB_MA_PATH, LIB_MA_PARAM);

    if (ret < 0) {

        ALOGE("%s: snprintf failed for lib %s, ret %d", __func__, LIB_MA_PARAM, ret);

        goto error;

    }



    my_data->waves_handle = dlopen(lib_path, RTLD_NOW);

    if (my_data->waves_handle == NULL) {

         ALOGE("%s: DLOPEN failed for %s", __func__, LIB_MA_PARAM);

         goto error;

    } else {

         ALOGV("%s: DLOPEN successful for %s", __func__, LIB_MA_PARAM);



         my_data->ma_param_init = (ma_param_init_t)dlsym(my_data->waves_handle,

                                     MA_QDSP_PARAM_INIT);

         if (!my_data->ma_param_init) {

             ALOGE("%s: dlsym error %s for ma_param_init", __func__, dlerror());

             goto error;

         }



         my_data->ma_param_deinit = (ma_param_deinit_t)dlsym(my_data->waves_handle,

                                       MA_QDSP_PARAM_DEINIT);

         if (!my_data->ma_param_deinit) {

             ALOGE("%s: dlsym error %s for ma_param_deinit", __func__, dlerror());

             goto error;

         }



         my_data->ma_set_lr_swap = (ma_set_lr_swap_t)dlsym(my_data->waves_handle,

                                      MA_QDSP_SET_LR_SWAP);

         if (!my_data->ma_set_lr_swap) {

             ALOGE("%s: dlsym error %s for ma_set_lr_swap", __func__, dlerror());

             goto error;

         }



         my_data->ma_set_sound_mode = (ma_set_sound_mode_t)dlsym(my_data->waves_handle,

                                         MA_QDSP_SET_MODE);

         if (!my_data->ma_set_sound_mode) {

             ALOGE("%s: dlsym error %s for ma_set_sound_mode", __func__, dlerror());

             goto error;

         }



         my_data->ma_set_volume = (ma_set_volume_t)dlsym(my_data->waves_handle,

                                     MA_QDSP_SET_VOL);

         if (!my_data->ma_set_volume) {

             ALOGE("%s: dlsym error %s for ma_set_volume", __func__, dlerror());

             goto error;

         }



         my_data->ma_set_volume_table = (ma_set_volume_table_t)dlsym(my_data->waves_handle,

                                           MA_QDSP_SET_VOLT);

         if (!my_data->ma_set_volume_table) {

             ALOGE("%s: dlsym error %s for ma_set_volume_table", __func__, dlerror());

             goto error;

         }

    }



    /* check file */

    if (access(PRESET_PATH, F_OK) < 0) {

        ALOGW("%s: file %s isn't existed.", __func__, PRESET_PATH);

        goto error;

    }

    /* TODO: check user preset table once the feature is enabled

    if (access(USER_PRESET_PATH, F_OK) < 0 ){

        ALOGW("%s: file %s isn't existed.", __func__, USER_PRESET_PATH);

        goto error;

    }

    */

    if (access(CONFIG_PATH, F_OK) < 0) {

        ALOGW("%s: file %s isn't existed.", __func__, CONFIG_PATH);

        goto error;

    }



    /* init ma parameter */

    if (my_data->ma_param_init(&g_ma_audio_cal_handle,

                                  platform, /* TODO: remove this on next version*/

                                  PRESET_PATH,

                                  USER_PRESET_PATH, /* useless */

                                  CONFIG_PATH,

                                  &set_audio_cal)) {

        if (!g_ma_audio_cal_handle) {

            ALOGE("%s: ma parameters initialize failed", __func__);

            my_data->ma_param_deinit(&g_ma_audio_cal_handle);

            goto error;

        }

        ALOGD("%s: ma parameters initialize successful", __func__);

    } else {

        ALOGE("%s: ma parameters initialize failed", __func__);

        goto error;

    }



    /* init volume table */

    for (i = 0; i < STREAM_MAX_TYPES; i++) {

        ma_cur_state_table[i].vol = 0.0;

        ma_cur_state_table[i].active = false;

    }



    return;



error:

    if (my_data) { free(my_data); }

    my_data = NULL;

}



//adev_init lock held

void audio_extn_ma_deinit()

{

    if (my_data) {

        /* deinit ma parameter */

        if (my_data->ma_param_deinit &&

            my_data->ma_param_deinit(&g_ma_audio_cal_handle))

            ALOGD("%s: ma parameters uninitialize successful", __func__);

        else

            ALOGD("%s: ma parameters uninitialize failed", __func__);



        pthread_mutex_destroy(&my_data->lock);

        free(my_data);

        my_data = NULL;

    }

}



// adev_init and adev lock held

bool audio_extn_ma_set_state(

        struct audio_device *adev, int stream_type, float vol, bool active)

{

    bool ret = false;

    ma_stream_type_t stype = (ma_stream_type_t)stream_type;



    ALOGV("%s: stream[%d] vol[%f] active[%s]",

          __func__, stream_type, vol, active ? "true" : "false");



    if (!my_data) {

        ALOGE("%s: maxxaudio isn't initialized.", __func__);

        return ret;

    }



    // update condition

    // 1. start track: active and volume isn't zero

    // 2. stop track: no tracks are active

    if ((active && vol != 0) ||

         (!active)) {

        pthread_mutex_lock(&my_data->lock);



        ma_cur_state_table[stype].vol = vol;

        ma_cur_state_table[stype].active = active;

        if (is_active())

            ret = check_and_send_all_audio_cal(adev, MA_CMD_VOL);



        pthread_mutex_unlock(&my_data->lock);

    }



    return ret;

}



void audio_extn_ma_set_device(struct audio_device *adev, struct audio_usecase *usecase)

{

    int i = 0;

    int u_index = -1;

    float vol = 0;

    struct ma_audio_cal_settings *ma_cal = NULL;



    if (!my_data) {

        ALOGV("%s: maxxaudio isn't initialized.", __func__);

        return;

    }



    if (!valid_usecase(usecase)) {

        ALOGV("%s: %d is not supported usecase", __func__, usecase->id);

        return;

    }



    ma_cal = (struct ma_audio_cal_settings *)malloc(sizeof(struct ma_audio_cal_settings));



    /* update audio_cal and send it */

    if (ma_cal != NULL){

        ma_cal->platform = adev->platform;

        ma_cal->app_type = usecase->stream.out->app_type_cfg.app_type;

        ma_cal->device = usecase->stream.out->devices;

        ALOGV("%s: send usecase(%d) app_type(%d) device(%d)",

                      __func__, usecase->id, ma_cal->app_type, ma_cal->device);



        pthread_mutex_lock(&my_data->lock);



        if (is_active()) {

            ALOGV("%s: send volume table === Start", __func__);

            for (i = 0; i < STREAM_MAX_TYPES; i++)

                ALOGV("%s: stream(%d) volume(%f) active(%s)", __func__, i,

                    ma_cur_state_table[i].vol,

                    ma_cur_state_table[i].active ? "T" : "F");

            ALOGV("%s: send volume table === End", __func__);



            if (!ma_set_volume_table_l(ma_cal,

                                         STREAM_MAX_TYPES,

                                         ma_cur_state_table))

                ALOGE("Waves: ma_set_volume_table_l %f returned with error.", vol);

            else

                ALOGV("Waves: ma_set_volume_table_l success");



        }

        pthread_mutex_unlock(&my_data->lock);

        free(ma_cal);

    } else {

        ALOGE("%s: ma_cal alloct fail", __func__);

    }

}



void audio_extn_ma_set_parameters(struct audio_device *adev, struct str_parms *parms)

{

    int ret;

    bool ret_b;

    int val;

    char value[128];



    // do LR swap and usb recognition

    ret = str_parms_get_int(parms, "rotation", &val);

    if (ret >= 0) {

        switch (val) {

        case 270:

            ma_set_swap_l(adev, true);

            break;

        case 0:

        case 90:

        case 180:

            ma_set_swap_l(adev, false);

            break;

        }

    }



    // check connect status

    ret = str_parms_get_str(parms, AUDIO_PARAMETER_DEVICE_CONNECT, value, sizeof(value));

    if (ret >= 0) {

        audio_devices_t device = (audio_devices_t)strtoul(value, NULL, 10);

        if (audio_is_usb_out_device(device)) {

            ret = str_parms_get_str(parms, "card", value, sizeof(value));

            if (ret >= 0) {

                const int card = atoi(value);

                ma_support_usb(true, card);

            }

        }

    }



    // check disconnect status

    ret = str_parms_get_str(parms, AUDIO_PARAMETER_DEVICE_DISCONNECT, value, sizeof(value));

    if (ret >= 0) {

        audio_devices_t device = (audio_devices_t)strtoul(value, NULL, 10);

        if (audio_is_usb_out_device(device)) {

            ret = str_parms_get_str(parms, "card", value, sizeof(value));

            if (ret >= 0) {

                const int card = atoi(value);

                ma_support_usb(false, card /*useless*/);

            }

        }

    }

}



bool audio_extn_ma_supported_usb()

{

    ALOGV("%s: current support 0x%x", __func__, g_supported_dev);

    return (g_supported_dev & SUPPORTED_USB) ? true : false;

}

hal/audio_extn/maxxaudio.h

0 → 100644
+37 −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.

 */



#ifndef MAXXAUDIO_H_

#define MAXXAUDIO_H_



#ifndef MAXXAUDIO_QDSP_ENABLED

#define audio_extn_ma_init(platform)                                      (0)

#define audio_extn_ma_deinit()                                            (0)

#define audio_extn_ma_set_state(adev, type, vol, active)                  (false)

#define audio_extn_ma_set_device(adev, usecase)                           (0)

#define audio_extn_ma_set_parameters(adev, param)                         (0)

#define audio_extn_ma_supported_usb()                                     (false)

#else

void audio_extn_ma_init(void *platform);

void audio_extn_ma_deinit();

bool audio_extn_ma_set_state(struct audio_device *adev, int stream_type, float vol, bool active);

void audio_extn_ma_set_device(struct audio_device *adev, struct audio_usecase *usecase);

void audio_extn_ma_set_parameters(struct audio_device *adev, struct str_parms *parms);

bool audio_extn_ma_supported_usb();

#endif /* MAXXAUDIO_QDSP_ENABLED */



#endif /* MAXXAUDIO_H_ */