29
29
using UnityEngine ;
30
30
using System . Collections . Generic ;
31
31
32
- public static class SavWav {
32
+ public static class SaveWav {
33
33
34
34
const int HEADER_SIZE = 44 ;
35
35
36
- public static bool Save ( string filename , AudioClip clip ) {
36
+ public static byte [ ] Save ( string filename , AudioClip clip ) {
37
37
if ( ! filename . ToLower ( ) . EndsWith ( ".wav" ) ) {
38
38
filename += ".wav" ;
39
39
}
@@ -43,14 +43,12 @@ public static bool Save(string filename, AudioClip clip) {
43
43
// Make sure directory exists if user is saving to sub dir.
44
44
Directory . CreateDirectory ( Path . GetDirectoryName ( filepath ) ) ;
45
45
46
- using ( var fileStream = CreateEmpty ( filepath ) ) {
47
-
48
- ConvertAndWrite ( fileStream , clip ) ;
49
-
50
- WriteHeader ( fileStream , clip ) ;
46
+ using ( var memoryStream = CreateEmpty ( filepath ) )
47
+ {
48
+ ConvertAndWrite ( memoryStream , clip ) ;
49
+ WriteHeader ( memoryStream , clip ) ;
50
+ return memoryStream . GetBuffer ( ) ;
51
51
}
52
-
53
- return true ; // TODO: return false if there's a failure saving the file
54
52
}
55
53
56
54
public static AudioClip TrimSilence ( AudioClip clip , float min ) {
@@ -91,19 +89,19 @@ public static AudioClip TrimSilence(List<float> samples, float min, int channels
91
89
return clip ;
92
90
}
93
91
94
- static FileStream CreateEmpty ( string filepath ) {
95
- var fileStream = new FileStream ( filepath , FileMode . Create ) ;
96
- byte emptyByte = new byte ( ) ;
92
+ static MemoryStream CreateEmpty ( string filepath ) {
93
+ var memoryStream = new MemoryStream ( ) ;
94
+ byte emptyByte = new byte ( ) ;
97
95
98
- for ( int i = 0 ; i < HEADER_SIZE ; i ++ ) //preparing the header
99
- {
100
- fileStream . WriteByte ( emptyByte ) ;
101
- }
96
+ for ( int i = 0 ; i < HEADER_SIZE ; i ++ ) //preparing the header
97
+ {
98
+ memoryStream . WriteByte ( emptyByte ) ;
99
+ }
102
100
103
- return fileStream ;
101
+ return memoryStream ;
104
102
}
105
103
106
- static void ConvertAndWrite ( FileStream fileStream , AudioClip clip ) {
104
+ static void ConvertAndWrite ( MemoryStream memoryStream , AudioClip clip ) {
107
105
108
106
var samples = new float [ clip . samples ] ;
109
107
@@ -125,60 +123,60 @@ static void ConvertAndWrite(FileStream fileStream, AudioClip clip) {
125
123
byteArr . CopyTo ( bytesData , i * 2 ) ;
126
124
}
127
125
128
- fileStream . Write ( bytesData , 0 , bytesData . Length ) ;
126
+ memoryStream . Write ( bytesData , 0 , bytesData . Length ) ;
129
127
}
130
128
131
- static void WriteHeader ( FileStream fileStream , AudioClip clip ) {
129
+ static void WriteHeader ( MemoryStream memoryStream , AudioClip clip ) {
132
130
133
131
var hz = clip . frequency ;
134
132
var channels = clip . channels ;
135
133
var samples = clip . samples ;
136
134
137
- fileStream . Seek ( 0 , SeekOrigin . Begin ) ;
135
+ memoryStream . Seek ( 0 , SeekOrigin . Begin ) ;
138
136
139
137
Byte [ ] riff = System . Text . Encoding . UTF8 . GetBytes ( "RIFF" ) ;
140
- fileStream . Write ( riff , 0 , 4 ) ;
138
+ memoryStream . Write ( riff , 0 , 4 ) ;
141
139
142
- Byte [ ] chunkSize = BitConverter . GetBytes ( fileStream . Length - 8 ) ;
143
- fileStream . Write ( chunkSize , 0 , 4 ) ;
140
+ Byte [ ] chunkSize = BitConverter . GetBytes ( memoryStream . Length - 8 ) ;
141
+ memoryStream . Write ( chunkSize , 0 , 4 ) ;
144
142
145
143
Byte [ ] wave = System . Text . Encoding . UTF8 . GetBytes ( "WAVE" ) ;
146
- fileStream . Write ( wave , 0 , 4 ) ;
144
+ memoryStream . Write ( wave , 0 , 4 ) ;
147
145
148
146
Byte [ ] fmt = System . Text . Encoding . UTF8 . GetBytes ( "fmt " ) ;
149
- fileStream . Write ( fmt , 0 , 4 ) ;
147
+ memoryStream . Write ( fmt , 0 , 4 ) ;
150
148
151
149
Byte [ ] subChunk1 = BitConverter . GetBytes ( 16 ) ;
152
- fileStream . Write ( subChunk1 , 0 , 4 ) ;
150
+ memoryStream . Write ( subChunk1 , 0 , 4 ) ;
153
151
154
152
UInt16 two = 2 ;
155
153
UInt16 one = 1 ;
156
154
157
155
Byte [ ] audioFormat = BitConverter . GetBytes ( one ) ;
158
- fileStream . Write ( audioFormat , 0 , 2 ) ;
156
+ memoryStream . Write ( audioFormat , 0 , 2 ) ;
159
157
160
158
Byte [ ] numChannels = BitConverter . GetBytes ( channels ) ;
161
- fileStream . Write ( numChannels , 0 , 2 ) ;
159
+ memoryStream . Write ( numChannels , 0 , 2 ) ;
162
160
163
161
Byte [ ] sampleRate = BitConverter . GetBytes ( hz ) ;
164
- fileStream . Write ( sampleRate , 0 , 4 ) ;
162
+ memoryStream . Write ( sampleRate , 0 , 4 ) ;
165
163
166
164
Byte [ ] byteRate = BitConverter . GetBytes ( hz * channels * 2 ) ; // sampleRate * bytesPerSample*number of channels, here 44100*2*2
167
- fileStream . Write ( byteRate , 0 , 4 ) ;
165
+ memoryStream . Write ( byteRate , 0 , 4 ) ;
168
166
169
167
UInt16 blockAlign = ( ushort ) ( channels * 2 ) ;
170
- fileStream . Write ( BitConverter . GetBytes ( blockAlign ) , 0 , 2 ) ;
168
+ memoryStream . Write ( BitConverter . GetBytes ( blockAlign ) , 0 , 2 ) ;
171
169
172
170
UInt16 bps = 16 ;
173
171
Byte [ ] bitsPerSample = BitConverter . GetBytes ( bps ) ;
174
- fileStream . Write ( bitsPerSample , 0 , 2 ) ;
172
+ memoryStream . Write ( bitsPerSample , 0 , 2 ) ;
175
173
176
174
Byte [ ] datastring = System . Text . Encoding . UTF8 . GetBytes ( "data" ) ;
177
- fileStream . Write ( datastring , 0 , 4 ) ;
175
+ memoryStream . Write ( datastring , 0 , 4 ) ;
178
176
179
177
Byte [ ] subChunk2 = BitConverter . GetBytes ( samples * channels * 2 ) ;
180
- fileStream . Write ( subChunk2 , 0 , 4 ) ;
178
+ memoryStream . Write ( subChunk2 , 0 , 4 ) ;
181
179
182
180
// fileStream.Close();
183
181
}
184
- }
182
+ }
0 commit comments