1 /*
2 * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 import java.io.ByteArrayInputStream;
25
26 import javax.sound.sampled.AudioFileFormat;
27 import javax.sound.sampled.AudioFormat;
28 import javax.sound.sampled.AudioInputStream;
29 import javax.sound.sampled.AudioSystem;
30
31 /**
32 * @test
33 * @bug 8132782 6729836
34 */
35 public final class RecognizeHugeWaveFiles {
36
37 /**
38 * The maximum size in bytes per WAVE specification.
39 */
40 private static final /*unsigned int */ long MAX_UNSIGNED_INT = 0xffffffffL;
41
42 /**
43 * The supported wave pcm_float format and sample size in bits.
44 */
45 private static final byte[][] waveTypeBits = {
46 {0x0001/*WAVE_FORMAT_PCM*/,1},
47 {0x0001/*WAVE_FORMAT_PCM*/,2},
48 {0x0001/*WAVE_FORMAT_PCM*/,4},
49 {0x0001/*WAVE_FORMAT_PCM*/,8},
50 {0x0001/*WAVE_FORMAT_PCM*/,16},
51 {0x0001/*WAVE_FORMAT_PCM*/,20},
52 {0x0001/*WAVE_FORMAT_PCM*/,24},
53 {0x0001/*WAVE_FORMAT_PCM*/,32},
54 {0x0003/*WAVE_FORMAT_IEEE_FLOAT*/, 32},
55 {0x0006/*WAVE_FORMAT_ALAW*/, 8},
56 {0x0007/*WAVE_FORMAT_MULAW*/, 8}
57 };
58
59 /**
60 * The list of supported sample rates(stored as unsigned int).
61 */
62 private static final int[] sampleRates = {
63 8000, 11025, 16000, 22050, 32000, 37800, 44056, 44100, 47250, 48000,
64 50000, 50400, 88200, 96000, 176400, 192000, 352800, 2822400,
65 5644800, Integer.MAX_VALUE
66 };
67
68 /**
69 * The list of supported channels (stored as unsigned int).
70 */
71 private static final int[] channels = {
72 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
73 };
74
75 /**
76 * The list of supported size of data (stored as unsigned int).
77 * <p>
78 * The {@code MAX_UNSIGNED_INT} is a maximum size.
79 */
80 private static final long[] dataSizes = {
81 0, 1, 2, 3, Integer.MAX_VALUE - 1, Integer.MAX_VALUE,
82 (long) Integer.MAX_VALUE + 1, MAX_UNSIGNED_INT - 1, MAX_UNSIGNED_INT
83 };
84
85 public static void main(final String[] args) throws Exception {
86 for (final byte[] type : waveTypeBits) {
87 for (final int sampleRate : sampleRates) {
88 for (final int channel : channels) {
89 for (final long dataSize : dataSizes) {
90 testAFF(type, sampleRate, channel, dataSize);
91 testAIS(type, sampleRate, channel, dataSize);
92 }
93 }
94 }
95 }
96 }
97
98 /**
99 * Tests the {@code AudioFileFormat} fetched from the fake header.
100 * <p>
101 * Note that the frameLength and byteLength are stored as int which means
102 * that {@code AudioFileFormat} will store the data above {@code MAX_INT} as
103 * NOT_SPECIFIED.
104 */
105 private static void testAFF(final byte[] type, final int rate,
106 final int channel, final long size)
107 throws Exception {
108 final byte[] header = createHeader(type, rate, channel, size);
109 final ByteArrayInputStream fake = new ByteArrayInputStream(header);
110 final AudioFileFormat aff = AudioSystem.getAudioFileFormat(fake);
111 final AudioFormat format = aff.getFormat();
112
113 if (aff.getType() != AudioFileFormat.Type.WAVE) {
114 throw new RuntimeException("Error");
115 }
116
117 final long frameLength = size / format.getFrameSize();
118 if (frameLength <= Integer.MAX_VALUE) {
119 if (aff.getFrameLength() != frameLength) {
120 System.err.println("Expected: " + frameLength);
121 System.err.println("Actual: " + aff.getFrameLength());
122 throw new RuntimeException();
123 }
124 } else {
125 if (aff.getFrameLength() != AudioSystem.NOT_SPECIFIED) {
126 System.err.println("Expected: " + AudioSystem.NOT_SPECIFIED);
127 System.err.println("Actual: " + aff.getFrameLength());
128 throw new RuntimeException();
129 }
130 }
131 validateFormat(type[1], rate, channel, aff.getFormat());
132 }
133
134 /**
135 * Tests the {@code AudioInputStream} fetched from the fake header.
136 * <p>
137 * Note that the frameLength is stored as long which means that {@code
138 * AudioInputStream} must store all possible data from wave file.
139 */
140 private static void testAIS(final byte[] type, final int rate,
141 final int channel, final long size)
142 throws Exception {
143 final byte[] header = createHeader(type, rate, channel, size);
144 final ByteArrayInputStream fake = new ByteArrayInputStream(header);
145 final AudioInputStream ais = AudioSystem.getAudioInputStream(fake);
146 final AudioFormat format = ais.getFormat();
147 final long frameLength = size / format.getFrameSize();
148 if (frameLength != ais.getFrameLength()) {
149 System.err.println("Expected: " + frameLength);
150 System.err.println("Actual: " + ais.getFrameLength());
151 throw new RuntimeException();
152 }
153 if (ais.available() < 0) {
154 System.err.println("available should be >=0: " + ais.available());
155 throw new RuntimeException();
156 }
157
158 validateFormat(type[1], rate, channel, format);
159 }
160
161 /**
162 * Tests that format contains the same data as were provided to the fake
163 * stream.
164 */
165 private static void validateFormat(final byte bits, final int rate,
166 final int channel,
167 final AudioFormat format) {
168
169 if (Float.compare(format.getSampleRate(), rate) != 0) {
170 System.err.println("Expected: " + rate);
171 System.err.println("Actual: " + format.getSampleRate());
172 throw new RuntimeException();
173 }
174 if (format.getChannels() != channel) {
175 System.err.println("Expected: " + channel);
176 System.err.println("Actual: " + format.getChannels());
177 throw new RuntimeException();
178 }
179 int frameSize = ((bits + 7) / 8) * channel;
180 if (format.getFrameSize() != frameSize) {
181 System.err.println("Expected: " + frameSize);
182 System.err.println("Actual: " + format.getFrameSize());
183 throw new RuntimeException();
184 }
185 }
186
187 /**
188 * Creates the custom header of the WAVE file. It is expected that all
189 * passed data are supported.
190 */
191 private static byte[] createHeader(final byte[] type, final int rate,
192 final int channel, final long size) {
193 final int frameSize = ((type[1] + 7) / 8) * channel;
194 return new byte[]{
195 // RIFF_MAGIC
196 0x52, 0x49, 0x46, 0x46,
197 // fileLength
198 -1, -1, -1, -1,
199 // waveMagic
200 0x57, 0x41, 0x56, 0x45,
201 // FMT_MAGIC
202 0x66, 0x6d, 0x74, 0x20,
203 // size
204 16, 0, 0, 0,
205 // wav_type WAVE_FORMAT_IEEE_FLOAT
206 type[0], 0,
207 // channels
208 (byte) (channel), (byte) (channel >> 8),
209 // samplerate
210 (byte) (rate), (byte) (rate >> 8), (byte) (rate >> 16),
211 (byte) (rate >> 24),
212 // framerate
213 1, 0, 0, 0,
214 // framesize
215 (byte) (frameSize), (byte) (frameSize >> 8),
216 // bits
217 type[1], 0,
218 // DATA_MAGIC
219 0x64, 0x61, 0x74, 0x61,
220 // data size
221 (byte) (size), (byte) (size >> 8), (byte) (size >> 16),
222 (byte) (size >> 24)
223 // data
224 , 0, 0, 0, 0, 0
225 };
226 }
227 }