Install-Package NAudio.Vorbis　　

using UnityEngine;
using System.IO;
using System;
using NAudio;
using NAudio.Wave;

public static class NAudioPlayer
{
    static NVorbis.VorbisReader vorbis;
    public static AudioClip FromOggData(byte[] data)
    {
        // Load the data into a stream
        MemoryStream oggstream = new MemoryStream(data);

        vorbis = new NVorbis.VorbisReader(oggstream, false);

        int samplecount = (int)(vorbis.SampleRate * vorbis.TotalTime.TotalSeconds);

        //  AudioClip audioClip = AudioClip.Create("clip", samplecount, vorbis.Channels, vorbis.SampleRate, false, true, OnAudioRead, OnAudioSetPosition);
        AudioClip audioClip = AudioClip.Create("ogg clip", samplecount, vorbis.Channels, vorbis.SampleRate, false, OnAudioRead);
        // Return the clip
        return audioClip;
    }
    static void OnAudioRead(float[] data)
    {
        var f = new float[data.Length];
        vorbis.ReadSamples(f, , data.Length);
        ; i < data.Length; i++)
        {
            data[i] = f[i];
        }
    }
    static void OnAudioSetPosition(int newPosition)
    {
        vorbis.DecodedTime = new TimeSpan(newPosition); //Only used to rewind the stream, we won't be seeking
    }
    public static AudioClip FromWavData(byte[] data)
    {
        WAV wav = new WAV(data);
        AudioClip audioClip = AudioClip.Create(, wav.Frequency, false);
        audioClip.SetData(wav.LeftChannel, );
        return audioClip;
    }
    public static AudioClip FromMp3Data(byte[] data)
    {
        // Load the data into a stream
        MemoryStream mp3stream = new MemoryStream(data);
        // Convert the data in the stream to WAV format
        Mp3FileReader mp3audio = new Mp3FileReader(mp3stream);
        WaveStream waveStream = WaveFormatConversionStream.CreatePcmStream(mp3audio);
        // Convert to WAV data
        WAV wav = new WAV(AudioMemStream(waveStream).ToArray());
        Debug.Log(wav);
        AudioClip audioClip = AudioClip.Create(, wav.Frequency, false);
        audioClip.SetData(wav.LeftChannel, );
        // Return the clip
        return audioClip;
    }

    private static MemoryStream AudioMemStream(WaveStream waveStream)
    {
        MemoryStream outputStream = new MemoryStream();
        using (WaveFileWriter waveFileWriter = new WaveFileWriter(outputStream, waveStream.WaveFormat))
        {
            byte[] bytes = new byte[waveStream.Length];
            waveStream.Position = ;
            waveStream.Read(bytes, , Convert.ToInt32(waveStream.Length));
            waveFileWriter.Write(bytes, , bytes.Length);
            waveFileWriter.Flush();
        }
        return outputStream;
    }
}

/* From http://answers.unity3d.com/questions/737002/wav-byte-to-audioclip.html */
public class WAV
{

    // convert two bytes to one float in the range -1 to 1
    static float bytesToFloat(byte firstByte, byte secondByte)
    {
        // convert two bytes to one short (little endian)
        ) | firstByte);
        // convert to range from -1 to (just below) 1
        return s / 32768.0F;
    }

    )
    {
        ;
        ; i < ; i++)
        {
            value |= (();
        }
        return value;
    }
    // properties
    public float[] LeftChannel { get; internal set; }
    public float[] RightChannel { get; internal set; }
    public int ChannelCount { get; internal set; }
    public int SampleCount { get; internal set; }
    public int Frequency { get; internal set; }

    public WAV(byte[] wav)
    {

        // Determine if mono or stereo
        ChannelCount = wav[];     // Forget byte 23 as 99.999% of WAVs are 1 or 2 channels

        // Get the frequency
        Frequency = bytesToInt(wav, );

        // Get past all the other sub chunks to get to the data subchunk:
        ;   // First Subchunk ID from 12 to 16

        // Keep iterating until we find the data chunk (i.e. 64 61 74 61 ...... (i.e. 100 97 116 97 in decimal))
         && wav[pos + ] ==  && wav[pos + ] ==  && wav[pos + ] == ))
        {
            pos += ;
            ] *  + wav[pos + ] *  + wav[pos + ] * ;
            pos +=  + chunkSize;
        }
        pos += ;

        // Pos is now positioned to start of actual sound data.
        SampleCount = (wav.Length - pos) / ;     // 2 bytes per sample (16 bit sound mono)
        ) SampleCount /= ;        // 4 bytes per sample (16 bit stereo)

        // Allocate memory (right will be null if only mono sound)
        LeftChannel = new float[SampleCount];
        ) RightChannel = new float[SampleCount];
        else RightChannel = null;

        // Write to double array/s:
        ;
         : );
        // while (pos < wav.Length)
        while ((i < SampleCount) && (pos < maxInput))
        {
            LeftChannel[i] = bytesToFloat(wav[pos], wav[pos + ]);
            pos += ;
            )
            {
                RightChannel[i] = bytesToFloat(wav[pos], wav[pos + ]);
                pos += ;
            }
            i++;
        }
    }

    public override string ToString()
    {
        return string.Format("[WAV: LeftChannel={0}, RightChannel={1}, ChannelCount={2}, SampleCount={3}, Frequency={4}]", LeftChannel,
    RightChannel, ChannelCount, SampleCount, Frequency);
    }
}

void PlayOGG()
{
    string path = Application.dataPath + "/../Audio/Music/a.ogg";
    byte[] data = File.ReadAllBytes(path);
    audioSource.clip = NAudioPlayer.FromOggData(data);
    audioSource.Play();
}
void PlayMP3()
{
    string path = Application.dataPath + "/../Audio/Music/a.mp3";
    byte[] data = File.ReadAllBytes(path);
    audioSource.clip = NAudioPlayer.FromMp3Data(data);
    audioSource.Play();
}
void PlayWAV()
{
    string path = Application.dataPath + "/../Audio/Music/a.wav";
    byte[] data = File.ReadAllBytes(path);
    audioSource.clip = NAudioPlayer.FromWavData(data);
    audioSource.Play();
}