public AudioClipInfo(AudioType type, string resourcename, string systemname, float initvolume, int maxSEcount = 16 )
 {
     ResourceName = resourcename;
     if (type == AudioType.SE)
     {
         ResourcePath = SEPath + resourcename;
     }
     else if (type == AudioType.BGM) {
         ResourcePath = BGMPath + resourcename;
     }
     SystemName = systemname;
     MaxSECount = maxSEcount;
     PlayingList = new List<SEInfo>(maxSEcount);
     StockList = new SortedList<int, SEInfo>(maxSEcount);
     InitVolume = initvolume;
     AttenuateRate = calcAttenuateRate();
     //Debug.Log("Att: " + AttenuateRate);
     for (int i = 0; i < MaxSECount; i++) {
         //Debug.LogFormat("InitVol:{0}",InitVolume);
         SEInfo seinfo = new SEInfo(i, 0f, InitVolume * Mathf.Pow(AttenuateRate, i));
         //SEInfo seinfo = new SEInfo(i, 0f, InitVolume);
         StockList.Add(seinfo.Index, seinfo);
         //Debug.Log("Vol: " + seinfo.Volume);
     }
     Loop = null;
 }

 public void PlayAudio(AudioType type)
 {
     foreach (var audio in AudioList.Where(audio => audio.type == type))
     {
         audio.Play();
     }
 }

 /**
 // \fn public Playlist(int id, string name, string filename, AudioType type)
 //
 // \brief Constructor.
 //
 // \author Simon Menetrey
 // \date 26.05.2014
 //
 // \param id       The identifier.
 // \param name     The name.
 // \param filename Filename of the file.
 // \param type     The type.
 **/
 public Playlist(int id, string name, string filename, AudioType type)
 {
     this.Id = id;
     this.Name = name;
     this.Filename = filename;
     this.Type = type;
     this.AudioFileList = new List<string>();
 }

 public void play(AudioSource source, AudioType type)
 {
     if (canPlay (type)) {
         source.PlayOneShot (source.clip);
         audiosPlaying [type] = audiosPlaying [type] + 1;
         StartCoroutine (decrementAudiosPlaying (type, source.clip.length));
     }
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="LocalSong"/> class.
 /// </summary>
 /// <param name="path">The path of the file.</param>
 /// <param name="audioType">The audio type.</param>
 /// <param name="duration">The duration of the song.</param>
 public LocalSong(string path, AudioType audioType, TimeSpan duration)
     : base(path, audioType, duration)
 {
     if (this.IsRemovable)
     {
         this.StreamingPath = this.OriginalPath;
     }
 }

 private VideoInfo(int formatCode, VideoType videoType, int resolution, bool is3D, AudioType audioType, int audioBitrate)
 {
     this.FormatCode = formatCode;
     this.VideoType = videoType;
     this.Resolution = resolution;
     this.Is3D = is3D;
     this.AudioType = audioType;
     this.AudioBitrate = audioBitrate;
 }

 public AudioBinary(byte[] audioBytes, AudioType audioType)
 {
     if (audioBytes == null || audioBytes.Length < 1)
     {
         throw new InvalidOperationException("AudioBytes must contain values.");
     }
     AudioBytes = audioBytes;
     AudioType = audioType;
 }

 public Audio(string name, string saveName, int matchScriptID)
 {
     Name = name;
     MatchScriptID = matchScriptID;
     SaveName = saveName;
     LengthMillis = AudioHelper.GetAudioLength(saveName);
     Length = AudioHelper.ConvertMillisToTime(LengthMillis);
     Type = AudioHelper.GetAudioType(saveName);
 }

 private VideoInfo(int formatCode, VideoType videoType, int resolution, bool is3D, AudioType audioType, int audioBitrate)
 {
     FormatCode = formatCode;
     VideoType = videoType;
     Resolution = resolution;
     Is3D = is3D;
     AudioType = audioType;
     AudioBitrate = audioBitrate;
 }

        protected override int AddNewData()
        {
            m_audioType = DataManager.Generate<AudioType>();
            m_audioType.Name = m_textBox_name.Text;

            DataManager.AudioTypes.Add(m_audioType);

            return m_audioType.Id;
        }

        public static Mock<Song> CreateSongMock(string name = "Song", bool callBase = false, AudioType audioType = AudioType.Mp3, TimeSpan? duration = null)
        {
            if (duration == null)
            {
                duration = TimeSpan.Zero;
            }

            return new Mock<Song>(name, audioType, duration) { CallBase = callBase };
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="YoutubeSong"/> class.
        /// </summary>
        /// <param name="path">The path of the song.</param>
        /// <param name="audioType">The audio type.</param>
        /// <param name="duration">The duration of the song.</param>
        /// <param name="isStreaming">if set to true, the song streams from YouTube, instead of downloading.</param>
        /// <exception cref="ArgumentNullException"><c>path</c> is null.</exception>
        public YoutubeSong(string path, AudioType audioType, TimeSpan duration, bool isStreaming)
            : base(path, audioType, duration)
        {
            this.IsStreaming = isStreaming;

            if (this.IsStreaming)
            {
                this.StreamingPath = this.OriginalPath;
            }
        }

    public static AudioSource GetLatestAudioSource( AudioType audioType )
    {
        GameObject audioLayer = GetAudioLayer( audioType );

        AudioSource[] audioSources = audioLayer.GetComponents<AudioSource>() as AudioSource[];

        if( audioSources.Length > 0 )
            return audioSources[ audioSources.Length - 1 ];

        return audioLayer.AddComponent("AudioSource") as AudioSource;
    }

 public static void Play( AudioClip clip, AudioType type )
 {
     if( type == AudioType.SFX ) {
         instance.audioSFX.PlayOneShot( clip, 1f);
     }
     else if( type == AudioType.Music && clip != instance.audioMusic.clip ) {
         instance.audioMusic.loop = true;
         instance.audioMusic.volume = 0.5f;
         instance.audioMusic.clip = clip;
         instance.audioMusic.Play();
     }
 }

	public static bool IsMuted (AudioType audioType) {
		switch (audioType) {
		case AudioType.FX:
			return SettingsUtil.FXMuted;
		case AudioType.Music:
			return SettingsUtil.MusicMuted;
		case AudioType.VO:
			return SettingsUtil.VOMuted;
		default:
			throw new System.Collections.Generic.KeyNotFoundException();
		}
	}

 /// <summary>
 /// Adds audio from local computer to collection.
 /// </summary>
 /// <param name="filename">File to add</param>
 /// <param name="artist, title">Tags for file</param>
 /// <param name="audioType">If atFile, copies audio to working directory, it's also default behavior.
 /// If atLink, saves filename and uses it to access file later.</param>
 /// <returns>Returns <c>mpAudio</c> instance that refers to the new element of collection.</returns>
 public mpAudio addAudio(string filename, string artist, string title, AudioType audioType = AudioType.atFile)
 {
     mpAudio audio;
     if (audioType == AudioType.atLink)
         audio = new mpLocalAudioLink(filename, artist, title);
     else
         audio = new mpLocalAudio(filename, artist, title);
     audio.Id = ++maxId;
     if (audio.Id == int.MaxValue)
         OptimizeIndex();
     return audio;
 }

    public static float GetAudioLayerVolume( AudioType audioType )
    {
        if( audioType == AudioType.Invalid )
            return -1f;

        if( !InternalAudioLayerVolumes.ContainsKey( audioType ) )
        {
            Debug.LogError( "Cannot find audio layer volume for " + audioType );
            return -1f;
        }

        return InternalAudioLayerVolumes[ audioType ];
    }

 /**
 // \fn public AudioFile(int id, string filename, string title, string artist, string album, int year, string label, TimeSpan duration, string gender, AudioType audiotype)
 //
 // \brief Constructor.
 //
 // \author Simon Menetrey
 // \date 26.05.2014
 //
 // \param id        The identifier.
 // \param filename  Filename of the audiofile.
 // \param title     The title.
 // \param artist    The artist.
 // \param album     The album.
 // \param year      The year.
 // \param label     The label.
 // \param duration  The duration.
 // \param gender    The gender.
 // \param audiotype The audiotype.
 **/
 public AudioFile(int id, string filename, string title, string artist, string album, int year, string label, TimeSpan duration, string gender, AudioType audiotype)
 {
     this.Id = id;
     this.Filename = filename;
     this.Title = title;
     this.Artist = artist;
     this.Album = album;
     this.Year = year;
     this.Label = label;
     this.Duration = duration;
     this.Gender = gender;
     this.Type = audiotype;
 }

 private void typeCombo_SelectedIndexChanged(object sender, EventArgs e)
 {
     if (typeCombo.SelectedIndex == 0)
     {
         type = AudioType.NSF;
         nsfPanel.Visible = true;
         wavPanel.Visible = false;
     }
     else
     {
         type = AudioType.Wav;
         nsfPanel.Visible = false;
         wavPanel.Visible = true;
     }
 }

 private int AudioTypePriority(AudioType audioType)
 {
     switch (audioType) {
         case AudioType.Mp3:
             return 4;
         case AudioType.Aac:
             return 3;
         case AudioType.Vorbis:
             return 2;
         default:    // anthing is better than unknown
             return 1;
         case AudioType.Unknown:
             return 0;
     }
 }