devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

unity3d下byte[]字节数组转AudioClip_unity byte转audioclip

作者：菜鸟追梦旅行 | 2024-02-18 13:54:03

赞

踩

unity byte转audioclip

最近在做语音合成，涉及到在unity3d下byte[]字节数组转AudioClip,在这里说一下大概的业务逻辑：

unity3d客户端发送文本数据到wcf服务端，wcf服务端利用微软的文字转语音技术(涉及到的dll为DotNetSpeech.dll)转换为wav格式的音频文件，再把音频文件转为byte[]字节数组返回给unity3d客户端，unity3d客户端接收到byte[]字节数组后转换成AudioClip，然后提供给AudioSource进行播放

 

在这里，我要讲的转换方法有两种，方法一效果很好(不但可以转wav格式的，还可以转mp3格式的byte)，方法二效果不好，播放时有杂音，下面进行一一介绍

 

方法一：

步骤如下：

1  下载NAudio.dll动态链接库

    下载地址1：https://github.com/naudio/NAudio/releases

    下载地址2：

     链接：https://pan.baidu.com/s/1ZfzQUwgh4gZXKJhmjZA9Rg 
     提取码：ss42

2  把下载的NAudio.dll放到Assets/Plugins目录下，文件夹Plugins需要自己新建，并把设置 unity3的API Compatiblity Level 为NET 2.0 (Edit->Project Settings->Player)

3  新建一个类，名为NAudioPlayer（注意，现在是转wav格式的，要转mp3的，需要把下面注释的代码开一下并做相应的修改)并编辑代码如下：

  1. using UnityEngine;
  2. using System.IO;
  3. using System;
  4. using NAudio;
  5. using NAudio.Wave;
  6.  
  7. public static class NAudioPlayer
  8. {
  9.     public static AudioClip FromWavData(byte[] buffer)
  10.     {
  11.         // 转换mp3格式的代码
  12.         //MemoryStream mp3stream = new MemoryStream(buffer);
  13.         // Convert the data in the stream to WAV format
  14.         //Mp3FileReader mp3audio = new Mp3FileReader(mp3stream);
  15.         
  16.         //转换wave格式的代码
  17.         MemoryStream wavstream = new MemoryStream(buffer);
  18.         WaveFileReader waveAudio = new WaveFileReader(wavstream);
  19.  
  20.  
  21.  
  22.         WaveStream waveStream = WaveFormatConversionStream.CreatePcmStream(waveAudio);
  23.        
  24.         // Convert to WAV data
  25.         WAV wav = new WAV(AudioMemStream(waveStream).ToArray());
  26.         Debug.Log(wav);
  27.         AudioClip audioClip = AudioClip.Create("testSound", wav.SampleCount, 1, wav.Frequency, false);
  28.         audioClip.SetData(wav.LeftChannel, 0);
  29.         // Return the clip
  30.         return audioClip;
  31.     }
  32.  
  33.     private static MemoryStream AudioMemStream(WaveStream waveStream)
  34.     {
  35.         MemoryStream outputStream = new MemoryStream();
  36.         using (WaveFileWriter waveFileWriter = new WaveFileWriter(outputStream, waveStream.WaveFormat))
  37.         {
  38.             byte[] bytes = new byte[waveStream.Length];
  39.             waveStream.Position = 0;
  40.             waveStream.Read(bytes, 0, Convert.ToInt32(waveStream.Length));
  41.             waveFileWriter.Write(bytes, 0, bytes.Length);
  42.             waveFileWriter.Flush();
  43.         }
  44.         return outputStream;
  45.     }
  46. }
  47.  
  48. public class WAV
  49. {
  50.  
  51.     // convert two bytes to one float in the range -1 to 1
  52.     static float bytesToFloat(byte firstByte, byte secondByte)
  53.     {
  54.         // convert two bytes to one short (little endian)
  55.         short s = (short)((secondByte << 8) | firstByte);
  56.         // convert to range from -1 to (just below) 1
  57.         return s / 32768.0F;
  58.     }
  59.  
  60.     static int bytesToInt(byte[] bytes, int offset = 0)
  61.     {
  62.         int value = 0;
  63.         for (int i = 0; i < 4; i++)
  64.         {
  65.             value |= ((int)bytes[offset + i]) << (i * 8);
  66.         }
  67.         return value;
  68.     }
  69.     // properties
  70.     public float[] LeftChannel { get; internal set; }
  71.     public float[] RightChannel { get; internal set; }
  72.     public int ChannelCount { get; internal set; }
  73.     public int SampleCount { get; internal set; }
  74.     public int Frequency { get; internal set; }
  75.  
  76.     public WAV(byte[] wav)
  77.     {
  78.  
  79.         // Determine if mono or stereo
  80.         ChannelCount = wav[22];     // Forget byte 23 as 99.999% of WAVs are 1 or 2 channels
  81.  
  82.         // Get the frequency
  83.         Frequency = bytesToInt(wav, 24);
  84.  
  85.         // Get past all the other sub chunks to get to the data subchunk:
  86.         int pos = 12;   // First Subchunk ID from 12 to 16
  87.  
  88.         // Keep iterating until we find the data chunk (i.e. 64 61 74 61 ...... (i.e. 100 97 116 97 in decimal))
  89.         while (!(wav[pos] == 100 && wav[pos + 1] == 97 && wav[pos + 2] == 116 && wav[pos + 3] == 97))
  90.         {
  91.             pos += 4;
  92.             int chunkSize = wav[pos] + wav[pos + 1] * 256 + wav[pos + 2] * 65536 + wav[pos + 3] * 16777216;
  93.             pos += 4 + chunkSize;
  94.         }
  95.         pos += 8;
  96.  
  97.         // Pos is now positioned to start of actual sound data.
  98.         SampleCount = (wav.Length - pos) / 2;     // 2 bytes per sample (16 bit sound mono)
  99.         if (ChannelCount == 2) SampleCount /= 2;        // 4 bytes per sample (16 bit stereo)
  100.  
  101.         // Allocate memory (right will be null if only mono sound)
  102.         LeftChannel = new float[SampleCount];
  103.         if (ChannelCount == 2) RightChannel = new float[SampleCount];
  104.         else RightChannel = null;
  105.  
  106.         // Write to double array/s:
  107.         int i = 0;
  108.         while (pos < wav.Length)
  109.         {
  110.             LeftChannel[i] = bytesToFloat(wav[pos], wav[pos + 1]);
  111.             pos += 2;
  112.             if (ChannelCount == 2)
  113.             {
  114.                 RightChannel[i] = bytesToFloat(wav[pos], wav[pos + 1]);
  115.                 pos += 2;
  116.             }
  117.             i++;
  118.         }
  119.     }
  120.  
  121.     public override string ToString()
  122.     {
  123.         return string.Format("[WAV: LeftChannel={0}, RightChannel={1}, ChannelCount={2}, SampleCount={3}, Frequency={4}]", LeftChannel, RightChannel, ChannelCount, SampleCount, Frequency);
  124.     }
  125. }

 

4   调用如下：

  1.     public AudioClip GetAudioClipByByte(byte[] buffer)
  2.     {
  3.         AudioClip audioClip = NAudioPlayer.FromWavData(buffer);
  4.         return audioClip;
  5.     }

 

 

方式二：

步骤如下：

1    设置unity3d的 API Compatiblity Level 为NET 2.0 (Edit->Project Settings->Player)

2   新建一个名为WavUtility的类，并编辑如下：

  1. using UnityEngine;
  2. using System.Text;
  3. using System.IO;
  4. using System;
  5.  
  6. /// <summary>
  7. /// WAV utility for recording and audio playback functions in Unity.
  8. /// Version: 1.0 alpha 1
  9. ///
  10. /// - Use "ToAudioClip" method for loading wav file / bytes.
  11. /// Loads .wav (PCM uncompressed) files at 8,16,24 and 32 bits and converts data to Unity's AudioClip.
  12. ///
  13. /// - Use "FromAudioClip" method for saving wav file / bytes.
  14. /// Converts an AudioClip's float data into wav byte array at 16 bit.
  15. /// </summary>
  16. /// <remarks>
  17. /// For documentation and usage examples: https://github.com/deadlyfingers/UnityWav
  18. /// </remarks>
  19.  
  20. public class WavUtility
  21. {
  22. 	// Force save as 16-bit .wav
  23. 	const int BlockSize_16Bit = 2;
  24.  
  25. 	/// <summary>
  26. 	/// Load PCM format *.wav audio file (using Unity's Application data path) and convert to AudioClip.
  27. 	/// </summary>
  28. 	/// <returns>The AudioClip.</returns>
  29. 	/// <param name="filePath">Local file path to .wav file</param>
  30. 	public static AudioClip ToAudioClip (string filePath)
  31. 	{
  32. 		if (!filePath.StartsWith (Application.persistentDataPath) && !filePath.StartsWith (Application.dataPath)) {
  33. 			Debug.LogWarning ("This only supports files that are stored using Unity's Application data path. \nTo load bundled resources use 'Resources.Load(\"filename\") typeof(AudioClip)' method. \nhttps://docs.unity3d.com/ScriptReference/Resources.Load.html");
  34. 			return null;
  35. 		}
  36. 		byte[] fileBytes = File.ReadAllBytes (filePath);
  37. 		return ToAudioClip (fileBytes, 0);
  38. 	}
  39.  
  40. 	public static AudioClip ToAudioClip (byte[] fileBytes, int offsetSamples = 0, string name = "wav")
  41. 	{
  42. 		//string riff = Encoding.ASCII.GetString (fileBytes, 0, 4);
  43. 		//string wave = Encoding.ASCII.GetString (fileBytes, 8, 4);
  44. 		int subchunk1 = BitConverter.ToInt32 (fileBytes, 16);
  45. 		UInt16 audioFormat = BitConverter.ToUInt16 (fileBytes, 20);
  46.  
  47. 		// NB: Only uncompressed PCM wav files are supported.
  48. 		string formatCode = FormatCode (audioFormat);
  49. 		Debug.AssertFormat (audioFormat == 1 || audioFormat == 65534, "Detected format code '{0}' {1}, but only PCM and WaveFormatExtensable uncompressed formats are currently supported.", audioFormat, formatCode);
  50.  
  51. 		UInt16 channels = BitConverter.ToUInt16 (fileBytes, 22);
  52. 		int sampleRate = BitConverter.ToInt32 (fileBytes, 24);
  53. 		//int byteRate = BitConverter.ToInt32 (fileBytes, 28);
  54. 		//UInt16 blockAlign = BitConverter.ToUInt16 (fileBytes, 32);
  55. 		UInt16 bitDepth = BitConverter.ToUInt16 (fileBytes, 34);
  56.  
  57. 		int headerOffset = 16 + 4 + subchunk1 + 4;
  58. 		int subchunk2 = BitConverter.ToInt32 (fileBytes, headerOffset);
  59. 		//Debug.LogFormat ("riff={0} wave={1} subchunk1={2} format={3} channels={4} sampleRate={5} byteRate={6} blockAlign={7} bitDepth={8} headerOffset={9} subchunk2={10} filesize={11}", riff, wave, subchunk1, formatCode, channels, sampleRate, byteRate, blockAlign, bitDepth, headerOffset, subchunk2, fileBytes.Length);
  60.  
  61. 		float[] data;
  62.         Debug.Log("bitDepth:"+bitDepth);
  63. 		switch (bitDepth) {
  64. 		case 8:
  65. 			data = Convert8BitByteArrayToAudioClipData (fileBytes, headerOffset, subchunk2);
  66. 			break;
  67. 		case 16:
  68. 			data = Convert16BitByteArrayToAudioClipData (fileBytes, headerOffset, subchunk2);
  69. 			break;
  70. 		case 24:
  71. 			data = Convert24BitByteArrayToAudioClipData (fileBytes, headerOffset, subchunk2);
  72. 			break;
  73. 		case 32:
  74. 			data = Convert32BitByteArrayToAudioClipData (fileBytes, headerOffset, subchunk2);
  75. 			break;
  76. 		default:
  77. 			throw new Exception (bitDepth + " bit depth is not supported.");
  78. 		}
  79.  
  80. 		AudioClip audioClip = AudioClip.Create (name, data.Length, (int)channels, sampleRate, false);
  81.         Debug.Log("name:"+name);
  82.         Debug.Log("lengthSample:"+data.Length);
  83.         Debug.Log("Chanel"+channels);
  84.         Debug.Log("frequency:"+sampleRate);
  85. 		audioClip.SetData (data, 0);
  86. 		return audioClip;
  87. 	}
  88.  
  89. 	#region wav file bytes to Unity AudioClip conversion methods
  90.  
  91. 	private static float[] Convert8BitByteArrayToAudioClipData (byte[] source, int headerOffset, int dataSize)
  92. 	{
  93. 		int wavSize = BitConverter.ToInt32 (source, headerOffset);
  94. 		headerOffset += sizeof(int);
  95. 		Debug.AssertFormat (wavSize > 0 && wavSize == dataSize, "Failed to get valid 8-bit wav size: {0} from data bytes: {1} at offset: {2}", wavSize, dataSize, headerOffset);
  96.  
  97. 		float[] data = new float[wavSize];
  98.  
  99. 		sbyte maxValue = sbyte.MaxValue;
  100.  
  101. 		int i = 0;
  102. 		while (i < wavSize) {
  103. 			data [i] = (float)source [i] / maxValue;
  104. 			++i;
  105. 		}
  106.  
  107. 		return data;
  108. 	}
  109.  
  110. 	private static float[] Convert16BitByteArrayToAudioClipData (byte[] source, int headerOffset, int dataSize)
  111. 	{
  112. 		int wavSize = BitConverter.ToInt32 (source, headerOffset);
  113. 		headerOffset += sizeof(int);
  114. 		Debug.AssertFormat (wavSize > 0 && wavSize == dataSize, "Failed to get valid 16-bit wav size: {0} from data bytes: {1} at offset: {2}", wavSize, dataSize, headerOffset);
  115.  
  116. 		int x = sizeof(Int16); // block size = 2
  117. 		int convertedSize = wavSize / x;
  118.  
  119. 		float[] data = new float[convertedSize];
  120.  
  121. 		Int16 maxValue = Int16.MaxValue;
  122.  
  123. 		int offset = 0;
  124. 		int i = 0;
  125. 		while (i < convertedSize) {
  126. 			offset = i * x + headerOffset;
  127. 			data [i] = (float)BitConverter.ToInt16 (source, offset) / maxValue;
  128. 			++i;
  129. 		}
  130.  
  131. 		Debug.AssertFormat (data.Length == convertedSize, "AudioClip .wav data is wrong size: {0} == {1}", data.Length, convertedSize);
  132.  
  133. 		return data;
  134. 	}
  135.  
  136. 	private static float[] Convert24BitByteArrayToAudioClipData (byte[] source, int headerOffset, int dataSize)
  137. 	{
  138. 		int wavSize = BitConverter.ToInt32 (source, headerOffset);
  139. 		headerOffset += sizeof(int);
  140. 		Debug.AssertFormat (wavSize > 0 && wavSize == dataSize, "Failed to get valid 24-bit wav size: {0} from data bytes: {1} at offset: {2}", wavSize, dataSize, headerOffset);
  141.  
  142. 		int x = 3; // block size = 3
  143. 		int convertedSize = wavSize / x;
  144.  
  145. 		int maxValue = Int32.MaxValue;
  146.  
  147. 		float[] data = new float[convertedSize];
  148.  
  149. 		byte[] block = new byte[sizeof(int)]; // using a 4 byte block for copying 3 bytes, then copy bytes with 1 offset
  150.  
  151. 		int offset = 0;
  152. 		int i = 0;
  153. 		while (i < convertedSize) {
  154. 			offset = i * x + headerOffset;
  155. 			Buffer.BlockCopy (source, offset, block, 1, x);
  156. 			data [i] = (float)BitConverter.ToInt32 (block, 0) / maxValue;
  157. 			++i;
  158. 		}
  159.  
  160. 		Debug.AssertFormat (data.Length == convertedSize, "AudioClip .wav data is wrong size: {0} == {1}", data.Length, convertedSize);
  161.  
  162. 		return data;
  163. 	}
  164.  
  165. 	private static float[] Convert32BitByteArrayToAudioClipData (byte[] source, int headerOffset, int dataSize)
  166. 	{
  167. 		int wavSize = BitConverter.ToInt32 (source, headerOffset);
  168. 		headerOffset += sizeof(int);
  169. 		Debug.AssertFormat (wavSize > 0 && wavSize == dataSize, "Failed to get valid 32-bit wav size: {0} from data bytes: {1} at offset: {2}", wavSize, dataSize, headerOffset);
  170.  
  171. 		int x = sizeof(float); //  block size = 4
  172. 		int convertedSize = wavSize / x;
  173.  
  174. 		Int32 maxValue = Int32.MaxValue;
  175.  
  176. 		float[] data = new float[convertedSize];
  177.  
  178. 		int offset = 0;
  179. 		int i = 0;
  180. 		while (i < convertedSize) {
  181. 			offset = i * x + headerOffset;
  182. 			data [i] = (float)BitConverter.ToInt32 (source, offset) / maxValue;
  183. 			++i;
  184. 		}
  185.  
  186. 		Debug.AssertFormat (data.Length == convertedSize, "AudioClip .wav data is wrong size: {0} == {1}", data.Length, convertedSize);
  187.  
  188. 		return data;
  189. 	}
  190.  
  191. 	#endregion
  192.  
  193. 	public static byte[] FromAudioClip (AudioClip audioClip)
  194. 	{
  195. 		string file;
  196. 		return FromAudioClip (audioClip, out file, false);
  197. 	}
  198.  
  199. 	public static byte[] FromAudioClip (AudioClip audioClip, out string filepath, bool saveAsFile = true, string dirname = "recordings")
  200. 	{
  201. 		MemoryStream stream = new MemoryStream ();
  202.  
  203. 		const int headerSize = 44;
  204.  
  205. 		// get bit depth
  206. 		UInt16 bitDepth = 16; //BitDepth (audioClip);
  207.  
  208. 		// NB: Only supports 16 bit
  209. 		//Debug.AssertFormat (bitDepth == 16, "Only converting 16 bit is currently supported. The audio clip data is {0} bit.", bitDepth);
  210.  
  211. 		// total file size = 44 bytes for header format and audioClip.samples * factor due to float to Int16 / sbyte conversion
  212. 		int fileSize = audioClip.samples * BlockSize_16Bit + headerSize; // BlockSize (bitDepth)
  213.  
  214. 		// chunk descriptor (riff)
  215. 		WriteFileHeader (ref stream, fileSize);
  216. 		// file header (fmt)
  217. 		WriteFileFormat (ref stream, audioClip.channels, audioClip.frequency, bitDepth);
  218. 		// data chunks (data)
  219. 		WriteFileData (ref stream, audioClip, bitDepth);
  220.  
  221. 		byte[] bytes = stream.ToArray ();
  222.  
  223. 		// Validate total bytes
  224. 		Debug.AssertFormat (bytes.Length == fileSize, "Unexpected AudioClip to wav format byte count: {0} == {1}", bytes.Length, fileSize);
  225.  
  226. 		// Save file to persistant storage location
  227. 		if (saveAsFile) {
  228. 			filepath = string.Format ("{0}/{1}/{2}.{3}", Application.persistentDataPath, dirname, DateTime.UtcNow.ToString ("yyMMdd-HHmmss-fff"), "wav");
  229. 			Directory.CreateDirectory (Path.GetDirectoryName (filepath));
  230. 			File.WriteAllBytes (filepath, bytes);
  231. 			//Debug.Log ("Auto-saved .wav file: " + filepath);
  232. 		} else {
  233. 			filepath = null;
  234. 		}
  235.  
  236. 		stream.Dispose ();
  237.  
  238. 		return bytes;
  239. 	}
  240.  
  241. 	#region write .wav file functions
  242.  
  243. 	private static int WriteFileHeader (ref MemoryStream stream, int fileSize)
  244. 	{
  245. 		int count = 0;
  246. 		int total = 12;
  247.  
  248. 		// riff chunk id
  249. 		byte[] riff = Encoding.ASCII.GetBytes ("RIFF");
  250. 		count += WriteBytesToMemoryStream (ref stream, riff, "ID");
  251.  
  252. 		// riff chunk size
  253. 		int chunkSize = fileSize - 8; // total size - 8 for the other two fields in the header
  254. 		count += WriteBytesToMemoryStream (ref stream, BitConverter.GetBytes (chunkSize), "CHUNK_SIZE");
  255.  
  256. 		byte[] wave = Encoding.ASCII.GetBytes ("WAVE");
  257. 		count += WriteBytesToMemoryStream (ref stream, wave, "FORMAT");
  258.  
  259. 		// Validate header
  260. 		Debug.AssertFormat (count == total, "Unexpected wav descriptor byte count: {0} == {1}", count, total);
  261.  
  262. 		return count;
  263. 	}
  264.  
  265. 	private static int WriteFileFormat (ref MemoryStream stream, int channels, int sampleRate, UInt16 bitDepth)
  266. 	{
  267. 		int count = 0;
  268. 		int total = 24;
  269.  
  270. 		byte[] id = Encoding.ASCII.GetBytes ("fmt ");
  271. 		count += WriteBytesToMemoryStream (ref stream, id, "FMT_ID");
  272.  
  273. 		int subchunk1Size = 16; // 24 - 8
  274. 		count += WriteBytesToMemoryStream (ref stream, BitConverter.GetBytes (subchunk1Size), "SUBCHUNK_SIZE");
  275.  
  276. 		UInt16 audioFormat = 1;
  277. 		count += WriteBytesToMemoryStream (ref stream, BitConverter.GetBytes (audioFormat), "AUDIO_FORMAT");
  278.  
  279. 		UInt16 numChannels = Convert.ToUInt16 (channels);
  280. 		count += WriteBytesToMemoryStream (ref stream, BitConverter.GetBytes (numChannels), "CHANNELS");
  281.  
  282. 		count += WriteBytesToMemoryStream (ref stream, BitConverter.GetBytes (sampleRate), "SAMPLE_RATE");
  283.  
  284. 		int byteRate = sampleRate * channels * BytesPerSample (bitDepth);
  285. 		count += WriteBytesToMemoryStream (ref stream, BitConverter.GetBytes (byteRate), "BYTE_RATE");
  286.  
  287. 		UInt16 blockAlign = Convert.ToUInt16 (channels * BytesPerSample (bitDepth));
  288. 		count += WriteBytesToMemoryStream (ref stream, BitConverter.GetBytes (blockAlign), "BLOCK_ALIGN");
  289.  
  290. 		count += WriteBytesToMemoryStream (ref stream, BitConverter.GetBytes (bitDepth), "BITS_PER_SAMPLE");
  291.  
  292. 		// Validate format
  293. 		Debug.AssertFormat (count == total, "Unexpected wav fmt byte count: {0} == {1}", count, total);
  294.  
  295. 		return count;
  296. 	}
  297.  
  298. 	private static int WriteFileData (ref MemoryStream stream, AudioClip audioClip, UInt16 bitDepth)
  299. 	{
  300. 		int count = 0;
  301. 		int total = 8;
  302.  
  303. 		// Copy float[] data from AudioClip
  304. 		float[] data = new float[audioClip.samples * audioClip.channels];
  305. 		audioClip.GetData (data, 0);
  306.  
  307. 		byte[] bytes = ConvertAudioClipDataToInt16ByteArray (data);
  308.  
  309. 		byte[] id = Encoding.ASCII.GetBytes ("data");
  310. 		count += WriteBytesToMemoryStream (ref stream, id, "DATA_ID");
  311.  
  312. 		int subchunk2Size = Convert.ToInt32 (audioClip.samples * BlockSize_16Bit); // BlockSize (bitDepth)
  313. 		count += WriteBytesToMemoryStream (ref stream, BitConverter.GetBytes (subchunk2Size), "SAMPLES");
  314.  
  315. 		// Validate header
  316. 		Debug.AssertFormat (count == total, "Unexpected wav data id byte count: {0} == {1}", count, total);
  317.  
  318. 		// Write bytes to stream
  319. 		count += WriteBytesToMemoryStream (ref stream, bytes, "DATA");
  320.  
  321. 		// Validate audio data
  322. 		Debug.AssertFormat (bytes.Length == subchunk2Size, "Unexpected AudioClip to wav subchunk2 size: {0} == {1}", bytes.Length, subchunk2Size);
  323.  
  324. 		return count;
  325. 	}
  326.  
  327. 	private static byte[] ConvertAudioClipDataToInt16ByteArray (float[] data)
  328. 	{
  329. 		MemoryStream dataStream = new MemoryStream ();
  330.  
  331. 		int x = sizeof(Int16);
  332.  
  333. 		Int16 maxValue = Int16.MaxValue;
  334.  
  335. 		int i = 0;
  336. 		while (i < data.Length) {
  337. 			dataStream.Write (BitConverter.GetBytes (Convert.ToInt16 (data [i] * maxValue)), 0, x);
  338. 			++i;
  339. 		}
  340. 		byte[] bytes = dataStream.ToArray ();
  341.  
  342. 		// Validate converted bytes
  343. 		Debug.AssertFormat (data.Length * x == bytes.Length, "Unexpected float[] to Int16 to byte[] size: {0} == {1}", data.Length * x, bytes.Length);
  344.  
  345. 		dataStream.Dispose ();
  346.  
  347. 		return bytes;
  348. 	}
  349.  
  350. 	private static int WriteBytesToMemoryStream (ref MemoryStream stream, byte[] bytes, string tag = "")
  351. 	{
  352. 		int count = bytes.Length;
  353. 		stream.Write (bytes, 0, count);
  354. 		//Debug.LogFormat ("WAV:{0} wrote {1} bytes.", tag, count);
  355. 		return count;
  356. 	}
  357.  
  358. 	#endregion
  359.  
  360. 	/// <summary>
  361. 	/// Calculates the bit depth of an AudioClip
  362. 	/// </summary>
  363. 	/// <returns>The bit depth. Should be 8 or 16 or 32 bit.</returns>
  364. 	/// <param name="audioClip">Audio clip.</param>
  365. 	public static UInt16 BitDepth (AudioClip audioClip)
  366. 	{
  367. 		UInt16 bitDepth = Convert.ToUInt16 (audioClip.samples * audioClip.channels * audioClip.length / audioClip.frequency);
  368. 		Debug.AssertFormat (bitDepth == 8 || bitDepth == 16 || bitDepth == 32, "Unexpected AudioClip bit depth: {0}. Expected 8 or 16 or 32 bit.", bitDepth);
  369. 		return bitDepth;
  370. 	}
  371.  
  372. 	private static int BytesPerSample (UInt16 bitDepth)
  373. 	{
  374. 		return bitDepth / 8;
  375. 	}
  376.  
  377. 	private static int BlockSize (UInt16 bitDepth)
  378. 	{
  379. 		switch (bitDepth) {
  380. 		case 32:
  381. 			return sizeof(Int32); // 32-bit -> 4 bytes (Int32)
  382. 		case 16:
  383. 			return sizeof(Int16); // 16-bit -> 2 bytes (Int16)
  384. 		case 8:
  385. 			return sizeof(sbyte); // 8-bit -> 1 byte (sbyte)
  386. 		default:
  387. 			throw new Exception (bitDepth + " bit depth is not supported.");
  388. 		}
  389. 	}
  390.  
  391. 	private static string FormatCode (UInt16 code)
  392. 	{
  393. 		switch (code) {
  394. 		case 1:
  395. 			return "PCM";
  396. 		case 2:
  397. 			return "ADPCM";
  398. 		case 3:
  399. 			return "IEEE";
  400. 		case 7:
  401. 			return "μ-law";
  402. 		case 65534:
  403. 			return "WaveFormatExtensable";
  404. 		default:
  405. 			Debug.LogWarning ("Unknown wav code format:" + code);
  406. 			return "";
  407. 		}
  408. 	}
  409.  
  410. }

3  调用如下：

  1. public AudioClip GetAudioClipByByte(byte[] buffer)
  2.     {
  3.         AudioClip audioClip = WavUtility.ToAudioClip(buffer);
  4.         return audioClip;
  5.     }

 

 

 

 

 

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/108343?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号