NLDClient-yudde/ProjectNLD/Assets/Code/Scripts/Framework/Audio/AudioCriwareMgr.cs

using PhxhSDK;
using System;
using Framework;
using System.Collections.Generic;
using cfg.AudioCfg;
using CriWare;
using CriWare.Assets;
using Cysharp.Threading.Tasks;
using UnityEngine;
using UnityEngine.SceneManagement;
using Object = UnityEngine.Object;
using Constants = Framework.Constants;

    public class AudioCriwareManager : Singlenton<AudioCriwareManager>, IStart, IInitable, IUpdatable, IAudioPlay
{
    public GameObject initGameObject;

    public ClipType curClipType;

    protected float vol = 1f;
    protected float musicVol = 1f;
    protected float soundsVol = 1f;

    protected Dictionary<int, Audio> musicAudio;
    protected Dictionary<int, Audio> soundsAudio;
    protected Dictionary<string, int> loadingAcb;

    protected static int SOUNDS_POOL_MAX_NUM = 999;
    protected static int MUSIC_POOL_MAX_NUM = 10;

    protected bool banMusic = false;
    protected bool banSound = false;

    protected bool initialized = false;

    protected List<int> _toBeRemoved = new List<int>();

    private bool _isOpenSpeakVoice = true;

    private GameObject _criError;
    private GameObject _criAtomGo;

    private static Queue<Audio> _freeMusicAudio;
    private static Queue<Audio> _freeSoundsAudio;

    private Dictionary<string, bool> _isAcbLoadedDic = new Dictionary<string, bool>();
    private Dictionary<string, CriAtomAcbAsset> _LoadedAcbAssetDic = new Dictionary<string, CriAtomAcbAsset>();

    public CriAtomExOutputAnalyzer analyzer=null;
    public bool IsAnalyzer = false;
    public void Start()
    {
        if (initGameObject == null)
        {
            // Need to create a new GameObject to attach the singleton to.
            curClipType = ClipType.CriwareClip;

            initGameObject = new GameObject();
            initGameObject.name = "Audio(Singleton)";
            //initGameObject.hideFlags = HideFlags.HideInHierarchy;
            // Make instance persistent.
            Object.DontDestroyOnLoad(initGameObject);
            Object.DontDestroyOnLoad(GameObject.Find("CriWareLibraryInitializer"));
//#if UNITY_EDITOR
            if (curClipType == ClipType.CriwareClip)
            {
                _criError = new GameObject();
                _criError.name = "CriwareError";
                _criError.AddComponent<CriWareErrorHandler>();
                Object.DontDestroyOnLoad(_criError);
            }
//#endif
        }
    }

    /// <summary>
    /// When set to true, new Audios that have the same audio clip as any other Audio, will be ignored
    /// </summary>
    public bool IgnoreDuplicateMusic { get; set; }

    /// <summary>
    /// When set to true, new Audios that have the same audio clip as any other Audio, will be ignored
    /// </summary>
    public bool IgnoreDuplicateSounds { get; set; }


    public float GlobalVolume
    {
        get { return vol; }
        set { vol = value; }
    }

    public float GlobalMusicVolume
    {
        get { return musicVol; }
        set { musicVol = value; }
    }

    public float GlobalSoundsVolume
    {
        get { return soundsVol; }
        set { soundsVol = value; }
    }

    public bool GlobalIsOpenSpeak
    {
        get { return _isOpenSpeakVoice; }
        set { _isOpenSpeakVoice = value; }
    }

    public void Init()
    {
        if (!initialized)
        {
            musicAudio = new Dictionary<int, Audio>();
            soundsAudio = new Dictionary<int, Audio>();
            loadingAcb = new Dictionary<string, int>();
            _freeMusicAudio = new Queue<Audio>();
            _freeSoundsAudio = new Queue<Audio>();

            IgnoreDuplicateMusic = false;
            IgnoreDuplicateSounds = false;

            initialized = true;
        }

        SceneManager.sceneLoaded += OnSceneLoaded;
    }

    public void Release()
    {
        SceneManager.sceneLoaded -= OnSceneLoaded;
        _LoadedAcbAssetDic.Clear();
        _isAcbLoadedDic.Clear();
    }

    public void RemoveAudio(GameObject go)
    {
        try
        {
            var source = go.GetComponent<CriAtomSourceForAsset>();
            if (source)
            {
                using var e = soundsAudio.GetEnumerator();
                while (e.MoveNext())
                {
                    var audio = e.Current.Value;
                    if (audio.audioSource == source)
                    {
                        audio.Stop();
                        _toBeRemoved.Add(e.Current.Key);
                    }
                }
            }
        }
        catch (Exception e)
        {
            DebugUtil.LogError($"RemoveAudio, {e}");
            throw;
        }
        
    }

    public void PauseAll()
    {
        PauseAllMusic();
        PauseAllSounds();
    }

    public void PauseAllMusic()
    {
        List<int> keys = new List<int>(musicAudio.Keys);
        foreach (int key in keys)
        {
            Audio audio = musicAudio[key];
            audio.Pause();
        }
    }

    public void PauseAllSounds()
    {
        List<int> keys = new List<int>(soundsAudio.Keys);
        foreach (int key in keys)
        {
            Audio audio = soundsAudio[key];
            audio.Pause();
        }
    }

    public void ResumeAll()
    {
        ResumeAllMusic();
        ResumeAllSounds();
    }

    public void ResumeAllMusic()
    {
        if (banMusic)
            return;

        List<int> keys = new List<int>(musicAudio.Keys);
        foreach (int key in keys)
        {
            Audio audio = musicAudio[key];
            audio.Resume();
        }
    }

    public void ResumeAllSounds()
    {
        List<int> keys = new List<int>(soundsAudio.Keys);
        foreach (int key in keys)
        {
            Audio audio = soundsAudio[key];
            audio.Resume();
        }
    }


    public void StopAll(float fadeOutSeconds = -1.0f)
    {
        StopAllMusic(fadeOutSeconds);
        StopAllSounds();
    }

    public void StopAllMusic(float fadeOutSeconds = -1.0f)
    {
        List<int> keys = new List<int>(musicAudio.Keys);
        foreach (int key in keys)
        {
            Audio audio = musicAudio[key];
            if (fadeOutSeconds > 0)
            {
                audio.fadeOutSeconds = fadeOutSeconds;
            }

            audio.Stop();
        }
    }

    public void StopAllSounds()
    {
        List<int> keys = new List<int>(soundsAudio.Keys);
        foreach (int key in keys)
        {
            Audio audio = soundsAudio[key];
            audio.Stop();
        }
    }


    public void StopSoundById(int soundId)
    {
        if (soundId >= 0)
        {
            List<int> keys = new List<int>(soundsAudio.Keys);
            foreach (int key in keys)
            {
                Audio audio = soundsAudio[key];
                if (audio.audioID == soundId)
                {
                    audio.Stop();
                }
            }
        }
    }

    public void StopMusicById(int soundId)
    {
        if (soundId >= 0)
        {
            List<int> keys = new List<int>(musicAudio.Keys);
            foreach (int key in keys)
            {
                Audio audio = musicAudio[key];
                if (audio.audioID == soundId)
                {
                    audio.Stop();
                }
            }
        }
    }

    public async UniTask<int> PlayMusicCommon(string musicName, string cueName = "", bool loop = true)
    {
        try
        {
            CriAtomAcbAsset au;
            if (!_isAcbLoadedDic.ContainsKey(musicName))
            {
                await CheckIsLoading(musicName);
            }
            //if (AssetManager.Instance.IsAssetPreLoaded(musicName + ".acb"))
            if (_isAcbLoadedDic.ContainsKey(musicName))
            {
                au =  LoadAudio(AudioType.MUSIC, musicName);
            }
            else
            {
                au = await LoadAudioAsync(AudioType.MUSIC, musicName);
            }
        

            if (au != null)
            {
                Audio.AudioInfo audioInfo = new Audio.AudioInfo()
                {
                    persist = true, 
                    volume = 1, 
                    fadeInValue = 0.3f, 
                    fadeOutValue = 0.3f,
                };
                return PlayMusic(au, loop, null, false, cueName, audioInfo);
            }

            return -1;
        }
        catch (Exception e)
        {
            DebugUtil.LogError($"playMusicCommon, {cueName}, {e}");
            throw;
        }
        
    }

    public void Update(float deltaTime)
    {
        using (var e = musicAudio.GetEnumerator())
        {
            while (e.MoveNext())
            {
                var music = e.Current.Value;
                music.Update();
                if (!music.audioSource)
                {
                    _toBeRemoved.Add(e.Current.Key);
                }
                if (!music.IsPlaying && !music.IsPaused && !music.IsLoading)
                {
                    _toBeRemoved.Add(e.Current.Key);
                }
            }

            if (_toBeRemoved.Count > 0)
            {
                for (int i = 0; i < _toBeRemoved.Count; i++)
                {
                    var audio = musicAudio[_toBeRemoved[i]];
                    if (!GetIsArrivePoolLimit(AudioType.MUSIC))
                    {
                        _freeMusicAudio.Enqueue(audio);
                    }
                    else
                    {
                        switch (curClipType)
                        {
                            case ClipType.AudioClip:
                            {
                                Object.Destroy(audio.audioSource);
                                break;
                            }
                            case ClipType.CriwareClip:
                            {
                                if (audio.RootGo && audio.RootGo != initGameObject)
                                {
                                    Object.Destroy(audio.RootGo);
                                }
                                Object.Destroy(audio.audioSource);
                                break;
                            }
                            default:
                                break;
                        }
                    }
                
                    musicAudio.Remove(_toBeRemoved[i]);
                }

                _toBeRemoved.Clear();
            }
        }


        using (var e1 = soundsAudio.GetEnumerator())
        {
            // Update sound fx            
            while (e1.MoveNext())
            {
                var sound = e1.Current.Value;
                sound.Update();
                if (!sound.audioSource)
                {
                    _toBeRemoved.Add(e1.Current.Key);
                }
                else if (!sound.IsPlaying && !sound.IsPaused && !sound.IsLoading)
                { 
                    _toBeRemoved.Add(e1.Current.Key);
                }
            }

            if (_toBeRemoved.Count > 0)
            {
                for (int i = 0; i < _toBeRemoved.Count; i++)
                {
                    var audio = soundsAudio[_toBeRemoved[i]];
                
                    if (!GetIsArrivePoolLimit(AudioType.SOUND))
                    {
                        _freeSoundsAudio.Enqueue(audio);
                    }
                    else
                    {
                        switch (curClipType)
                        {
                            case ClipType.AudioClip:
                            {
                                Object.Destroy(audio.audioSource);
                                break;
                            }
                            case ClipType.CriwareClip:
                            {
                                Object.Destroy(audio.audioSource);
                            
                                if (audio.RootGo && audio.RootGo != initGameObject) 
                                {
                                    Object.Destroy(audio.RootGo);
                                }
                                break;
                            }
                            default:
                                break;
                        }
                    }
                
                    soundsAudio.Remove(_toBeRemoved[i]);
                }

                _toBeRemoved.Clear();
            }
        }
        
    }

    private bool GetIsArrivePoolLimit(AudioType audioType)
    {
        if (audioType == AudioType.MUSIC)
        {
            return musicAudio.Count + _freeMusicAudio.Count >= MUSIC_POOL_MAX_NUM;
        }
        return soundsAudio.Count + _freeSoundsAudio.Count >= SOUNDS_POOL_MAX_NUM;
    }

    public async UniTask<int> PlaySoundCommon(string soundName, string cueName = "")
    {
        if (!_isAcbLoadedDic.ContainsKey(soundName))
        {
            await CheckIsLoading(soundName);
        }
        
        try
        {
            switch (curClipType)
            {
                case ClipType.AudioClip:
                {
                    break;
                }
                case ClipType.CriwareClip:
                {
                    CriAtomAcbAsset acb;
                    //if (AssetManager.Instance.IsAssetPreLoaded(soundName + ".acb"))
                    if (_isAcbLoadedDic.ContainsKey(soundName))
                    {
                        acb = LoadAudio(AudioType.SOUND, soundName);
                    }
                    else
                    {
                        acb = await LoadAudioAsync(AudioType.SOUND, soundName);
                    }
                    
                    if (acb != null)
                    {
                        return PlaySound(acb, GlobalVolume, false, null, false, cueName);
                    }
                    break;
                }
                default:
                    break;
            }

            DebugUtil.LogError("==== audio null!!! ====");
        }
        catch (Exception e)
        {
            DebugUtil.LogError("{0}.PlaySound:{1} error:{2}", GetType(), soundName, e.Message);
        }

        return -1;
    }

    public void SetMusicEnable(bool isEnable)
    {
        GlobalMusicVolume = isEnable ? 1 : 0;
    }

    public void SetSoundEnable(bool isEnable)
    {
        GlobalSoundsVolume = isEnable ? 1 : 0;
    }

    public async UniTask<int> PlayMusicCommon(string musicName,  Transform trans =null, string cueName = "", bool loop = true)
    {
        try
        {
            CriAtomAcbAsset au;
            if (!_isAcbLoadedDic.ContainsKey(musicName))
            {
                await CheckIsLoading(musicName);
            }
            //if (AssetManager.Instance.IsAssetPreLoaded(musicName + ".acb"))
            if (!_isAcbLoadedDic.ContainsKey(musicName))
            {
                au = await LoadAudioAsync(AudioType.MUSIC, musicName);
            }
            else
            {
                au = LoadAudio(AudioType.MUSIC, musicName);
            }

            if (au != null)
            {
                Audio.AudioInfo audioInfo = new Audio.AudioInfo()
                {
                    persist = true, 
                    volume = 1, 
                    fadeInValue = 0.3f, 
                    fadeOutValue = 0.3f,
                };
                return PlayMusic(au, loop, trans, true, cueName, audioInfo);
            }

            return -1;
        }
        catch (Exception e)
        {
            DebugUtil.LogError($"PlayMusicCommon, cueName = {cueName}, {e}");
            throw;
        }
        
    }

    public async UniTask<int> PlaySoundCommon(string soundName, Transform trans, string cueName, bool is3D = false, Vector3 pos = new Vector3())
    {
        if (!_isAcbLoadedDic.ContainsKey(soundName))
        {
            await CheckIsLoading(soundName);
        }
        
        try
        {
            switch (curClipType)
            {
                case ClipType.AudioClip:
                {
                    break;
                }
                case ClipType.CriwareClip:
                {
                    CriAtomAcbAsset acb;
                    
                    //if (AssetManager.Instance.IsAssetPreLoaded(soundName + ".acb"))
                    if (_isAcbLoadedDic.ContainsKey(soundName))
                    {
                        acb = LoadAudio(AudioType.SOUND, soundName);
                    }
                    else
                    {
                        acb = await LoadAudioAsync(AudioType.SOUND, soundName);
                    }
                    if (acb != null)
                    {
                        return PlaySound(acb, GlobalVolume, false, trans, is3D, cueName, pos);
                    }
                    
                    break;
                }
                default:
                    break;
            }

            DebugUtil.LogError("==== audio null!!! ====");
        }
        catch (Exception e)
        {
            DebugUtil.LogError("{0}.PlaySound:{1} error:{2}", GetType(), soundName, e.Message);
        }

        return -1;
    }

    private async UniTask CheckIsLoading(string audioName)
    {
        while (loadingAcb.ContainsKey(audioName))
        {
            await UniTask.NextFrame();
        }
    }

    private int PlaySoundCommonImmediately(string soundName, Transform trans, string cueName, bool is3D = false, 
        Vector3 pos = new Vector3())
    {
        if (!_isAcbLoadedDic.ContainsKey(soundName))
        {
            DebugUtil.LogError($"--- acb资源没有完成加载，请检查！！！ acbName: {soundName} ---");
            return -1;
        }

        try
        {
            var acb = LoadAudio(AudioType.SOUND, soundName);
            return PlaySound(acb, GlobalVolume, false, trans, is3D, cueName, pos);
        }
        catch (Exception e)
        {
            DebugUtil.LogError(e);
            throw;
        }
        
    }
    
    private int PlaySoundCommonImmediately(string soundName, string cueName)
    {
        if (!_isAcbLoadedDic.ContainsKey(soundName))
        {
            DebugUtil.LogError($"--- acb资源没有完成加载，请检查！！！ acbName: {soundName} ---");
            return -1;
        }

        try
        {
            var acb = LoadAudio(AudioType.SOUND, soundName);
            return PlaySound(acb, GlobalVolume, false, null, false, cueName);
        }
        catch (Exception e)
        {
            DebugUtil.LogError(e);
            throw;
        }
        
    }

    /// <summary>
    /// 播放音乐
    /// </summary>
    /// <param name="acbAsset"></param> acbAsset
    /// <param name="loop"></param> 是否循环
    /// <param name="sourceTransform"></param> 挂载的trans
    /// <param name="is3D"></param> 是否3D音效
    /// <param name="cueName"></param> 播放的Cue里面哪个音源
    /// <param name="audioInfo"></param> 结构体，包含淡入淡出的时间
    /// <returns></returns>
    private int PlayMusic(CriAtomAcbAsset acbAsset, bool loop, Transform sourceTransform, 
        bool is3D, string cueName, Audio.AudioInfo audioInfo)
    {
        if (acbAsset == null)
        {
            DebugUtil.LogError("Sound Manager: Audio clip is null, cannot play music", acbAsset);
        }

        try
        {
            if (IgnoreDuplicateMusic)
            {
                List<int> keys = new List<int>(musicAudio.Keys);
                foreach (int key in keys)
                {
                    if (musicAudio[key].audioSource.Cue.AcbAsset.name == acbAsset.name)
                    {
                        return musicAudio[key].audioID;
                    }
                }
            }
    
            // Stop all current music playing
            //StopAllMusic(audioInfo.fadeOutValue);
    
            // Create the audioSource
            Audio audio;
            if (_freeMusicAudio.Count > 0)
            {
                audio = _freeMusicAudio.Dequeue();
                audio.GenNewID();
                audio.Play(cueName, true);
            }
            else
            {
                audio = new Audio(Audio.AudioType.Music, acbAsset, loop, sourceTransform, is3D, cueName, audioInfo);
            }
    
            // Add it to music list
            musicAudio.Add(audio.audioID, audio);
    
            if (banMusic)
            {
                audio.Pause();
            }
    
            return audio.audioID;
        }
        catch (Exception e)
        {
            DebugUtil.LogError(e);
            throw;
        }
        
    }

    private int PlaySound(CriAtomAcbAsset acbAsset, float volume, bool loop, Transform sourceTransform, 
        bool is3D = false, string cueName = "", Vector3 pos = new Vector3(), float pitch = 1.0f)
    {
        if (acbAsset == null)
        {
            DebugUtil.LogError("Sound Manager: Audio clip is null, cannot play music");
        }

        try
        {
            if (banSound)
            {
                return -1;
            }

            if (IgnoreDuplicateSounds)
            {
                List<int> keys = new List<int>(soundsAudio.Keys);
                foreach (var key in keys)
                {
                    if (soundsAudio.ContainsKey(key) && soundsAudio[key].audioSource.Cue.AcbAsset.name.Equals(acbAsset.name) )
                        return soundsAudio[key].audioID;
                }
            }

#if UNITY_EDITOR || UNITY_IOS || UNITY_ANDROID
            // Create the audioSource
            Audio audio;
            Audio.AudioInfo audioInfo = new Audio.AudioInfo()
            {
                persist = false, 
                volume = volume, 
                fadeInValue = 0f, 
                fadeOutValue = 0f,
            };
        
            Vector3 newPos;
            if (!is3D)
            {
                newPos = initGameObject.transform.position;
            }
            else if (!sourceTransform)
            {
                newPos = pos;
            }
            else
            {
                newPos = sourceTransform.transform.position;
            }
        
        
            GameObject go;
            if (_freeSoundsAudio.Count > 0)
            {
                audio = _freeSoundsAudio.Dequeue();
                audio.GenNewID();   
                go = audio.RootGo;
                if (!go)
                {
                    DebugUtil.LogError("==== _freeSoundsAudio null!!! ====");
                }
                //audio.SetIs3D(is3D);
                audio.Play(cueName);
            }
            else
            {
                if (!is3D)
                {
                    go = initGameObject;
                }
                else
                {
                    go = new GameObject();
                    go.name = "Audio";
                    go.transform.SetParent(initGameObject.transform);
                }
                audio = new Audio(AudioBase.AudioType.Sound, acbAsset, loop,  go.transform, is3D, cueName, audioInfo);
#if UNITY_EDITOR
                //go.name += "_"+ audio.audioID;
#endif
            }

            if (go != initGameObject)
            {
                go.transform.position = newPos;
            }
            audio.SetPitch(pitch);
            // Add it to music list
            soundsAudio.Add(audio.audioID, audio);
            return audio.audioID;
        
#else
            return -1;
#endif
        }
        catch (Exception e)
        {
            DebugUtil.LogError($"PlaySound, cueName: {cueName}, {e}");
            throw;
        }
        
    }

    private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
    {
        try
        {
            List<int> keys;
            // Stop and remove all non-persistent music audio
            keys = new List<int>(musicAudio.Keys);

            switch (curClipType)
            {
                case ClipType.AudioClip:
                {
                    foreach (var key in keys)
                    {
                        if (musicAudio.ContainsKey(key))
                        {
                            var music = musicAudio[key];
                            if (!music.persist && music.activated)
                            {
                                Object.Destroy(music.audioSource);
                                musicAudio.Remove(key);
                            }
                        }
                    }

                    // Stop sound fx
                    keys = new List<int>(soundsAudio.Keys);
                    foreach (var key in keys)
                    {
                        if (soundsAudio.ContainsKey(key))
                        {
                            var sound = soundsAudio[key];
                            Object.Destroy(sound.audioSource);
                            soundsAudio.Remove(key);
                        }
                    }

                    break;
                }

                case ClipType.CriwareClip:
                {
                    foreach (var key in keys)
                    {
                        if (musicAudio.ContainsKey(key))
                        {
                            var music = musicAudio[key];
                            if (!music.persist && music.activated)
                            {
                                Object.Destroy(music.audioSource);
                                musicAudio.Remove(key);
                            }
                        }
                    }

                    // Stop sound fx
                    keys = new List<int>(soundsAudio.Keys);
                    foreach (var key in keys)
                    {
                        if (soundsAudio.ContainsKey(key))
                        {
                            var sound = soundsAudio[key];
                            Object.Destroy(sound.audioSource);
                            soundsAudio.Remove(key);
                        }
                    }
                    break;
                }

                default:
                    break;
            }
        }
        catch (Exception e)
        {
            DebugUtil.LogError(e);
            throw;
        }
        
    }
    
    //异步加载音频
    private async UniTask<CriAtomAcbAsset> LoadAudioAsync(AudioType type, string audioName, bool is3D = false)
    {
        try
        {
            loadingAcb.Add(audioName, 1);
        
            string acfName = audioName + ".acf";
            await LoadAcfAsync(type, acfName);

            string acbName = audioName + ".acb";
            CriAtomAcbAsset acbAsset = await AssetManager.Instance.LoadAssetAsync<CriAtomAcbAsset>(acbName);
            acbAsset.LoadImmediate();
            loadingAcb.Remove(audioName);

            _isAcbLoadedDic.TryAdd(audioName, true);
            _LoadedAcbAssetDic.TryAdd(audioName, acbAsset);
            return acbAsset;
        }
        catch (Exception e)
        {
            DebugUtil.LogError($"LoadAudioAsync failed!!!, audioName:{audioName}, {e}");
            throw;
        }
    }
    
    //同步加载音频，需要已预加载资源
    private CriAtomAcbAsset LoadAudio(AudioType type, string audioName, bool is3D = false)
    {
        // string acfName = audioName + ".acf";
        // LoadAcf(type, acfName);
        
        //string acbName = audioName + ".acb";
        //CriAtomAcbAsset acbAsset = AssetManager.Instance.LoadAsset<CriAtomAcbAsset>(acbName);
        if (_LoadedAcbAssetDic.TryGetValue(audioName, out var acbAsset))
        {
            return acbAsset;
        }
        return null;
    }

    private async UniTask<CriAtomAcfAsset> LoadAcfAsync(AudioType type, string audioName, bool is3D = false)
    {
        CriAtomAcfAsset acfAsset = await AssetManager.Instance.LoadAssetAsync<CriAtomAcfAsset>(audioName);
        acfAsset.Register();
        
        return acfAsset;
    }
    
    private CriAtomAcfAsset LoadAcf(AudioType type, string audioName, bool is3D = false)
    {
        CriAtomAcfAsset acfAsset = AssetManager.Instance.LoadAsset<CriAtomAcfAsset>(audioName);
        acfAsset.Register();
        
        return acfAsset;
    }

    private bool CheckIsLoadedAcb(string audioName)
    {
        return _LoadedAcbAssetDic.ContainsKey(audioName);
    }

    private bool CheckAudioIsPlayable(DataAudio audioData)
    {
        if (audioData == null)
        {
            return false;
        }

        if (audioData.IsSpeak)
        {
            return _isOpenSpeakVoice;
        }
        return true;
    }

    //外部接口
    public async UniTask<int> PlayAudio(string key, Transform trans = null)
    {
        
        //全局播放，挂到Audio物体上
        var audioData = TableManager.Instance.Tables.Audios.GetByKey(key);
        if (audioData == null)
        {
            DebugUtil.LogError("==== 播放的音频不存在！！！音频Key: {0}", key);
            return -1;
        }
        if (!CheckAudioIsPlayable(audioData))
        {
            return -1;
        }

        var audioName = audioData.Path;//Framework.Constants.AUDIO_MUSIC_PATH + audioData.Path;
    
        if (!trans)
        {
            int audioID;
            switch (audioData.Type)
            {
                case (cfg.AudioCfg.AudioType.Sound):
                {
                    if (CheckIsLoadedAcb(audioName))
                    {
                        audioID = PlaySoundCommonImmediately(audioName, audioData.CueName);
                    }
                    else
                    {
                        audioID = await PlaySoundCommon(audioName, audioData.CueName);
                    }
                    
                    return audioID;
                }
                case (cfg.AudioCfg.AudioType.Music):
                {
                    audioID = await PlayMusicCommon(audioName,  audioData.CueName);
                    return audioID;
                }
                default:
                    break;
            }
            return -1;
        }
    
        //定点播放
        switch (audioData.Type)
        {
            case (cfg.AudioCfg.AudioType.Sound):
            {
                int audioID = await PlaySoundCommon(audioName, trans, audioData.CueName);
                return audioID;
            }
            case (cfg.AudioCfg.AudioType.Music):
            {
                int audioID = await PlayMusicCommon(audioName,  trans, audioData.CueName);
                return audioID;
            }
            default:
                break;
        }

        return -1;
        
    }
    
    public async UniTask<int> PlayAudio(string key, Vector3 pos)
    {
        //全局播放，挂到Audio物体上
        var audioData = TableManager.Instance.Tables.Audios.GetByKey(key);
        if (audioData == null)
        {
            DebugUtil.LogError("==== 播放的音频不存在！！！音频Key: {0}", key);
            return -1;
        }
        if (!CheckAudioIsPlayable(audioData))
        {
            return -1;
        }

        var audioName = audioData.Path;
        
        //定点播放
        // var go = new GameObject();
        // go.transform.position = pos;
        switch (audioData.Type)
        {
            case (cfg.AudioCfg.AudioType.Sound):
            {
                int audioID;
                if (CheckIsLoadedAcb(audioName))
                {
                    audioID = PlaySoundCommonImmediately(audioName, null, audioData.CueName, true, pos);
                }
                else
                {
                    audioID = await PlaySoundCommon(audioName, null, audioData.CueName, true, pos);
                }

                return audioID;
            }
            case (cfg.AudioCfg.AudioType.Music):
            {
                int audioID = await PlayMusicCommon(audioName,  null, audioData.CueName, true);
                return audioID;
            }
            default:
                break;
        }

        return -1;
    }

    public async UniTask<int> PlayAudio(int ID, Vector3 pos)
    {
        //全局播放，挂到Audio物体上
        var audioData = TableManager.Instance.Tables.Audios.GetByID(ID);
        if (audioData == null)
        {
            DebugUtil.LogError("==== 播放的音频不存在！！！音频ID: {0}", ID);
            return -1;
        }
        if (!CheckAudioIsPlayable(audioData))
        {
            return -1;
        }


        var audioName = audioData.Path;//Framework.Constants.AUDIO_MUSIC_PATH;// + audioData.Path;
        
        //定点播放
        switch (audioData.Type)
        {
            case (cfg.AudioCfg.AudioType.Sound):
            {
                int audioID;
                if (CheckIsLoadedAcb(audioName))
                {
                    audioID = PlaySoundCommonImmediately(audioName, null, audioData.CueName, true, pos);
                }
                else
                {
                    audioID = await PlaySoundCommon(audioName, null, audioData.CueName, true, pos);
                }
                return audioID;
            }
            case (cfg.AudioCfg.AudioType.Music):
            {
                int audioID = await PlayMusicCommon(audioName,  null, audioData.CueName, true);
                return audioID;
            }
            default:
                break;
        }

        return -1;
        
    }
    
    public async UniTask<int> PlayAudio(int ID, Transform trans = null)
    {
        //全局播放，挂到Audio物体上
        var audioData = TableManager.Instance.Tables.Audios.GetByID(ID);
        if (audioData == null)
        {
            DebugUtil.LogError("==== 播放的音频不存在！！！音频Key: {0}", ID);
            return -1;
        }
        if (!CheckAudioIsPlayable(audioData))
        {
            return -1;
        }


        var audioName = audioData.Path;//Constants.AUDIO_MUSIC_PATH + audioData.Path;
        int audioID = -1;
        if (!trans)
        {
            switch (audioData.Type)
            {
                case (cfg.AudioCfg.AudioType.Sound):
                {
                    if (CheckIsLoadedAcb(audioName))
                    {
                        audioID = PlaySoundCommonImmediately(audioName, audioData.CueName);
                    }
                    else
                    {
                        audioID = await PlaySoundCommon(audioName, audioData.CueName);
                    }
                    break;
                }
                case (cfg.AudioCfg.AudioType.Music):
                {
                    audioID = await PlayMusicCommon(audioName, audioData.CueName);
                    break;
                }
                default:
                    break;
            }

            return audioID;
        }

        //定点播放
        var go = new GameObject();
        go.transform.position = trans.position;
        switch (audioData.Type)
        {
            case (cfg.AudioCfg.AudioType.Sound):
            {
                audioID = await PlaySoundCommon(audioName, trans, audioData.CueName);
                go.name = "Audio_" + audioID;
                break;
            }
            case (cfg.AudioCfg.AudioType.Music):
            {
                audioID = await PlayMusicCommon(audioName, trans, audioData.CueName);
                go.name = "Audio_" + audioID;
                break;
            }
        }

        go.transform.SetParent(initGameObject.transform);

        return audioID;
    }

    //在播放之前注册
    public void RegisterAnalyzer(CriAtomExOutputAnalyzer s)
    {
        IsAnalyzer = true;
        analyzer=s;
    }
    public void UnregisterAnalyzer(GameObject go, CriAtomExOutputAnalyzer s)
    {
        var source = go.GetComponent<CriAtomSourceForAsset>();
        source.DetachFromAnalyzer( s);
        IsAnalyzer = false;
        analyzer = null;

    }
}

public class Audio : AudioCriware
{
    public struct AudioInfo
    {
        public bool persist;
        public float volume;
        public float fadeInValue;
        public float fadeOutValue;
    }
    public Audio(AudioType audioType, CriAtomAcbAsset acb, bool loop, Transform sourceTransform, bool is3D, string cueName, AudioInfo audioInfo): 
        base(acb, loop, sourceTransform, is3D, cueName, audioInfo)
    {
    }
}