diff options
Diffstat (limited to 'songdbj/javazoom/jl/converter')
-rw-r--r-- | songdbj/javazoom/jl/converter/Converter.java | 411 | ||||
-rw-r--r-- | songdbj/javazoom/jl/converter/RiffFile.java | 495 | ||||
-rw-r--r-- | songdbj/javazoom/jl/converter/WaveFile.java | 522 | ||||
-rw-r--r-- | songdbj/javazoom/jl/converter/WaveFileObuffer.java | 141 | ||||
-rw-r--r-- | songdbj/javazoom/jl/converter/jlc.java | 216 |
5 files changed, 0 insertions, 1785 deletions
diff --git a/songdbj/javazoom/jl/converter/Converter.java b/songdbj/javazoom/jl/converter/Converter.java deleted file mode 100644 index 845082e626..0000000000 --- a/songdbj/javazoom/jl/converter/Converter.java +++ /dev/null | |||
@@ -1,411 +0,0 @@ | |||
1 | /* | ||
2 | * 11/19/04 1.0 moved to LGPL. | ||
3 | * 12/12/99 Original verion. mdm@techie.com. | ||
4 | *----------------------------------------------------------------------- | ||
5 | * This program is free software; you can redistribute it and/or modify | ||
6 | * it under the terms of the GNU Library General Public License as published | ||
7 | * by the Free Software Foundation; either version 2 of the License, or | ||
8 | * (at your option) any later version. | ||
9 | * | ||
10 | * This program is distributed in the hope that it will be useful, | ||
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
13 | * GNU Library General Public License for more details. | ||
14 | * | ||
15 | * You should have received a copy of the GNU Library General Public | ||
16 | * License along with this program; if not, write to the Free Software | ||
17 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
18 | *---------------------------------------------------------------------- | ||
19 | */ | ||
20 | |||
21 | package javazoom.jl.converter; | ||
22 | |||
23 | import java.io.BufferedInputStream; | ||
24 | import java.io.File; | ||
25 | import java.io.FileInputStream; | ||
26 | import java.io.IOException; | ||
27 | import java.io.InputStream; | ||
28 | import java.io.PrintWriter; | ||
29 | |||
30 | import javazoom.jl.decoder.Bitstream; | ||
31 | import javazoom.jl.decoder.Decoder; | ||
32 | import javazoom.jl.decoder.Header; | ||
33 | import javazoom.jl.decoder.JavaLayerException; | ||
34 | import javazoom.jl.decoder.Obuffer; | ||
35 | |||
36 | /** | ||
37 | * The <code>Converter</code> class implements the conversion of | ||
38 | * an MPEG audio file to a .WAV file. To convert an MPEG audio stream, | ||
39 | * just create an instance of this class and call the convert() | ||
40 | * method, passing in the names of the input and output files. You can | ||
41 | * pass in optional <code>ProgressListener</code> and | ||
42 | * <code>Decoder.Params</code> objects also to customize the conversion. | ||
43 | * | ||
44 | * @author MDM 12/12/99 | ||
45 | * @since 0.0.7 | ||
46 | */ | ||
47 | public class Converter | ||
48 | { | ||
49 | /** | ||
50 | * Creates a new converter instance. | ||
51 | */ | ||
52 | public Converter() | ||
53 | { | ||
54 | } | ||
55 | |||
56 | public synchronized void convert(String sourceName, String destName) | ||
57 | throws JavaLayerException | ||
58 | { | ||
59 | convert(sourceName, destName, null, null); | ||
60 | } | ||
61 | |||
62 | public synchronized void convert(String sourceName, String destName, | ||
63 | ProgressListener progressListener) | ||
64 | throws JavaLayerException | ||
65 | { | ||
66 | convert(sourceName, destName, progressListener, null); | ||
67 | } | ||
68 | |||
69 | |||
70 | public void convert(String sourceName, String destName, | ||
71 | ProgressListener progressListener, Decoder.Params decoderParams) | ||
72 | throws JavaLayerException | ||
73 | { | ||
74 | if (destName.length()==0) | ||
75 | destName = null; | ||
76 | try { | ||
77 | InputStream in = openInput(sourceName); | ||
78 | convert(in, destName, progressListener, decoderParams); | ||
79 | in.close(); | ||
80 | } catch(IOException ioe) { | ||
81 | throw new JavaLayerException(ioe.getLocalizedMessage(), ioe); | ||
82 | } | ||
83 | } | ||
84 | |||
85 | public synchronized void convert(InputStream sourceStream, String destName, | ||
86 | ProgressListener progressListener, Decoder.Params decoderParams) | ||
87 | throws JavaLayerException | ||
88 | { | ||
89 | if (progressListener==null) | ||
90 | progressListener = PrintWriterProgressListener.newStdOut( | ||
91 | PrintWriterProgressListener.NO_DETAIL); | ||
92 | try { | ||
93 | if (!(sourceStream instanceof BufferedInputStream)) | ||
94 | sourceStream = new BufferedInputStream(sourceStream); | ||
95 | int frameCount = -1; | ||
96 | if (sourceStream.markSupported()) { | ||
97 | sourceStream.mark(-1); | ||
98 | frameCount = countFrames(sourceStream); | ||
99 | sourceStream.reset(); | ||
100 | } | ||
101 | progressListener.converterUpdate(ProgressListener.UPDATE_FRAME_COUNT, frameCount, 0); | ||
102 | |||
103 | |||
104 | Obuffer output = null; | ||
105 | Decoder decoder = new Decoder(decoderParams); | ||
106 | Bitstream stream = new Bitstream(sourceStream); | ||
107 | |||
108 | if (frameCount==-1) | ||
109 | frameCount = Integer.MAX_VALUE; | ||
110 | |||
111 | int frame = 0; | ||
112 | long startTime = System.currentTimeMillis(); | ||
113 | |||
114 | try | ||
115 | { | ||
116 | for (; frame<frameCount; frame++) | ||
117 | { | ||
118 | try | ||
119 | { | ||
120 | Header header = stream.readFrame(); | ||
121 | if (header==null) | ||
122 | break; | ||
123 | |||
124 | progressListener.readFrame(frame, header); | ||
125 | |||
126 | if (output==null) | ||
127 | { | ||
128 | // REVIEW: Incorrect functionality. | ||
129 | // the decoder should provide decoded | ||
130 | // frequency and channels output as it may differ from | ||
131 | // the source (e.g. when downmixing stereo to mono.) | ||
132 | int channels = (header.mode()==Header.SINGLE_CHANNEL) ? 1 : 2; | ||
133 | int freq = header.frequency(); | ||
134 | output = new WaveFileObuffer(channels, freq, destName); | ||
135 | decoder.setOutputBuffer(output); | ||
136 | } | ||
137 | |||
138 | Obuffer decoderOutput = decoder.decodeFrame(header, stream); | ||
139 | |||
140 | // REVIEW: the way the output buffer is set | ||
141 | // on the decoder is a bit dodgy. Even though | ||
142 | // this exception should never happen, we test to be sure. | ||
143 | if (decoderOutput!=output) | ||
144 | throw new InternalError("Output buffers are different."); | ||
145 | |||
146 | |||
147 | progressListener.decodedFrame(frame, header, output); | ||
148 | |||
149 | stream.closeFrame(); | ||
150 | |||
151 | } | ||
152 | catch (Exception ex) | ||
153 | { | ||
154 | boolean stop = !progressListener.converterException(ex); | ||
155 | |||
156 | if (stop) | ||
157 | { | ||
158 | throw new JavaLayerException(ex.getLocalizedMessage(), ex); | ||
159 | } | ||
160 | } | ||
161 | } | ||
162 | |||
163 | } | ||
164 | finally | ||
165 | { | ||
166 | |||
167 | if (output!=null) | ||
168 | output.close(); | ||
169 | } | ||
170 | |||
171 | int time = (int)(System.currentTimeMillis()-startTime); | ||
172 | progressListener.converterUpdate(ProgressListener.UPDATE_CONVERT_COMPLETE, | ||
173 | time, frame); | ||
174 | } | ||
175 | catch (IOException ex) | ||
176 | { | ||
177 | throw new JavaLayerException(ex.getLocalizedMessage(), ex); | ||
178 | } | ||
179 | } | ||
180 | |||
181 | |||
182 | protected int countFrames(InputStream in) | ||
183 | { | ||
184 | return -1; | ||
185 | } | ||
186 | |||
187 | |||
188 | protected InputStream openInput(String fileName) | ||
189 | throws IOException | ||
190 | { | ||
191 | // ensure name is abstract path name | ||
192 | File file = new File(fileName); | ||
193 | InputStream fileIn = new FileInputStream(file); | ||
194 | BufferedInputStream bufIn = new BufferedInputStream(fileIn); | ||
195 | |||
196 | return bufIn; | ||
197 | } | ||
198 | |||
199 | |||
200 | /** | ||
201 | * This interface is used by the Converter to provide | ||
202 | * notification of tasks being carried out by the converter, | ||
203 | * and to provide new information as it becomes available. | ||
204 | */ | ||
205 | |||
206 | static public interface ProgressListener | ||
207 | { | ||
208 | public static final int UPDATE_FRAME_COUNT = 1; | ||
209 | |||
210 | /** | ||
211 | * Conversion is complete. Param1 contains the time | ||
212 | * to convert in milliseconds. Param2 contains the number | ||
213 | * of MPEG audio frames converted. | ||
214 | */ | ||
215 | public static final int UPDATE_CONVERT_COMPLETE = 2; | ||
216 | |||
217 | |||
218 | /** | ||
219 | * Notifies the listener that new information is available. | ||
220 | * | ||
221 | * @param updateID Code indicating the information that has been | ||
222 | * updated. | ||
223 | * | ||
224 | * @param param1 Parameter whose value depends upon the update code. | ||
225 | * @param param2 Parameter whose value depends upon the update code. | ||
226 | * | ||
227 | * The <code>updateID</code> parameter can take these values: | ||
228 | * | ||
229 | * UPDATE_FRAME_COUNT: param1 is the frame count, or -1 if not known. | ||
230 | * UPDATE_CONVERT_COMPLETE: param1 is the conversion time, param2 | ||
231 | * is the number of frames converted. | ||
232 | */ | ||
233 | public void converterUpdate(int updateID, int param1, int param2); | ||
234 | |||
235 | /** | ||
236 | * If the converter wishes to make a first pass over the | ||
237 | * audio frames, this is called as each frame is parsed. | ||
238 | */ | ||
239 | public void parsedFrame(int frameNo, Header header); | ||
240 | |||
241 | /** | ||
242 | * This method is called after each frame has been read, | ||
243 | * but before it has been decoded. | ||
244 | * | ||
245 | * @param frameNo The 0-based sequence number of the frame. | ||
246 | * @param header The Header rerpesenting the frame just read. | ||
247 | */ | ||
248 | public void readFrame(int frameNo, Header header); | ||
249 | |||
250 | /** | ||
251 | * This method is called after a frame has been decoded. | ||
252 | * | ||
253 | * @param frameNo The 0-based sequence number of the frame. | ||
254 | * @param header The Header rerpesenting the frame just read. | ||
255 | * @param o The Obuffer the deocded data was written to. | ||
256 | */ | ||
257 | public void decodedFrame(int frameNo, Header header, Obuffer o); | ||
258 | |||
259 | /** | ||
260 | * Called when an exception is thrown during while converting | ||
261 | * a frame. | ||
262 | * | ||
263 | * @param t The <code>Throwable</code> instance that | ||
264 | * was thrown. | ||
265 | * | ||
266 | * @return <code>true</code> to continue processing, or false | ||
267 | * to abort conversion. | ||
268 | * | ||
269 | * If this method returns <code>false</code>, the exception | ||
270 | * is propagated to the caller of the convert() method. If | ||
271 | * <code>true</code> is returned, the exception is silently | ||
272 | * ignored and the converter moves onto the next frame. | ||
273 | */ | ||
274 | public boolean converterException(Throwable t); | ||
275 | |||
276 | } | ||
277 | |||
278 | |||
279 | /** | ||
280 | * Implementation of <code>ProgressListener</code> that writes | ||
281 | * notification text to a <code>PrintWriter</code>. | ||
282 | */ | ||
283 | // REVIEW: i18n of text and order required. | ||
284 | static public class PrintWriterProgressListener implements ProgressListener | ||
285 | { | ||
286 | static public final int NO_DETAIL = 0; | ||
287 | |||
288 | /** | ||
289 | * Level of detail typically expected of expert | ||
290 | * users. | ||
291 | */ | ||
292 | static public final int EXPERT_DETAIL = 1; | ||
293 | |||
294 | /** | ||
295 | * Verbose detail. | ||
296 | */ | ||
297 | static public final int VERBOSE_DETAIL = 2; | ||
298 | |||
299 | /** | ||
300 | * Debug detail. All frame read notifications are shown. | ||
301 | */ | ||
302 | static public final int DEBUG_DETAIL = 7; | ||
303 | |||
304 | static public final int MAX_DETAIL = 10; | ||
305 | |||
306 | private PrintWriter pw; | ||
307 | |||
308 | private int detailLevel; | ||
309 | |||
310 | static public PrintWriterProgressListener newStdOut(int detail) | ||
311 | { | ||
312 | return new PrintWriterProgressListener( | ||
313 | new PrintWriter(System.out, true), detail); | ||
314 | } | ||
315 | |||
316 | public PrintWriterProgressListener(PrintWriter writer, int detailLevel) | ||
317 | { | ||
318 | this.pw = writer; | ||
319 | this.detailLevel = detailLevel; | ||
320 | } | ||
321 | |||
322 | |||
323 | public boolean isDetail(int detail) | ||
324 | { | ||
325 | return (this.detailLevel >= detail); | ||
326 | } | ||
327 | |||
328 | public void converterUpdate(int updateID, int param1, int param2) | ||
329 | { | ||
330 | if (isDetail(VERBOSE_DETAIL)) | ||
331 | { | ||
332 | switch (updateID) | ||
333 | { | ||
334 | case UPDATE_CONVERT_COMPLETE: | ||
335 | // catch divide by zero errors. | ||
336 | if (param2==0) | ||
337 | param2 = 1; | ||
338 | |||
339 | pw.println(); | ||
340 | pw.println("Converted "+param2+" frames in "+param1+" ms ("+ | ||
341 | (param1/param2)+" ms per frame.)"); | ||
342 | } | ||
343 | } | ||
344 | } | ||
345 | |||
346 | public void parsedFrame(int frameNo, Header header) | ||
347 | { | ||
348 | if ((frameNo==0) && isDetail(VERBOSE_DETAIL)) | ||
349 | { | ||
350 | String headerString = header.toString(); | ||
351 | pw.println("File is a "+headerString); | ||
352 | } | ||
353 | else if (isDetail(MAX_DETAIL)) | ||
354 | { | ||
355 | String headerString = header.toString(); | ||
356 | pw.println("Prased frame "+frameNo+": "+headerString); | ||
357 | } | ||
358 | } | ||
359 | |||
360 | public void readFrame(int frameNo, Header header) | ||
361 | { | ||
362 | if ((frameNo==0) && isDetail(VERBOSE_DETAIL)) | ||
363 | { | ||
364 | String headerString = header.toString(); | ||
365 | pw.println("File is a "+headerString); | ||
366 | } | ||
367 | else if (isDetail(MAX_DETAIL)) | ||
368 | { | ||
369 | String headerString = header.toString(); | ||
370 | pw.println("Read frame "+frameNo+": "+headerString); | ||
371 | } | ||
372 | } | ||
373 | |||
374 | public void decodedFrame(int frameNo, Header header, Obuffer o) | ||
375 | { | ||
376 | if (isDetail(MAX_DETAIL)) | ||
377 | { | ||
378 | String headerString = header.toString(); | ||
379 | pw.println("Decoded frame "+frameNo+": "+headerString); | ||
380 | pw.println("Output: "+o); | ||
381 | } | ||
382 | else if (isDetail(VERBOSE_DETAIL)) | ||
383 | { | ||
384 | if (frameNo==0) | ||
385 | { | ||
386 | pw.print("Converting."); | ||
387 | pw.flush(); | ||
388 | } | ||
389 | |||
390 | if ((frameNo % 10)==0) | ||
391 | { | ||
392 | pw.print('.'); | ||
393 | pw.flush(); | ||
394 | } | ||
395 | } | ||
396 | } | ||
397 | |||
398 | public boolean converterException(Throwable t) | ||
399 | { | ||
400 | if (this.detailLevel>NO_DETAIL) | ||
401 | { | ||
402 | t.printStackTrace(pw); | ||
403 | pw.flush(); | ||
404 | } | ||
405 | return false; | ||
406 | } | ||
407 | |||
408 | } | ||
409 | |||
410 | |||
411 | } \ No newline at end of file | ||
diff --git a/songdbj/javazoom/jl/converter/RiffFile.java b/songdbj/javazoom/jl/converter/RiffFile.java deleted file mode 100644 index fb5d9e53c6..0000000000 --- a/songdbj/javazoom/jl/converter/RiffFile.java +++ /dev/null | |||
@@ -1,495 +0,0 @@ | |||
1 | /* | ||
2 | * 11/19/04 1.0 moved to LGPL. | ||
3 | * 02/23/99 JavaConversion by E.B | ||
4 | * Don Cross, April 1993. | ||
5 | * RIFF file format classes. | ||
6 | * See Chapter 8 of "Multimedia Programmer's Reference" in | ||
7 | * the Microsoft Windows SDK. | ||
8 | * | ||
9 | *----------------------------------------------------------------------- | ||
10 | * This program is free software; you can redistribute it and/or modify | ||
11 | * it under the terms of the GNU Library General Public License as published | ||
12 | * by the Free Software Foundation; either version 2 of the License, or | ||
13 | * (at your option) any later version. | ||
14 | * | ||
15 | * This program is distributed in the hope that it will be useful, | ||
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
18 | * GNU Library General Public License for more details. | ||
19 | * | ||
20 | * You should have received a copy of the GNU Library General Public | ||
21 | * License along with this program; if not, write to the Free Software | ||
22 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
23 | *---------------------------------------------------------------------- | ||
24 | */ | ||
25 | |||
26 | package javazoom.jl.converter; | ||
27 | |||
28 | import java.io.IOException; | ||
29 | import java.io.RandomAccessFile; | ||
30 | |||
31 | |||
32 | /** | ||
33 | * Class to manage RIFF files | ||
34 | */ | ||
35 | public class RiffFile | ||
36 | { | ||
37 | class RiffChunkHeader | ||
38 | { | ||
39 | public int ckID = 0; // Four-character chunk ID | ||
40 | public int ckSize = 0; // Length of data in chunk | ||
41 | public RiffChunkHeader() | ||
42 | {} | ||
43 | } | ||
44 | |||
45 | |||
46 | // DDCRET | ||
47 | public static final int DDC_SUCCESS = 0; // The operation succeded | ||
48 | public static final int DDC_FAILURE = 1; // The operation failed for unspecified reasons | ||
49 | public static final int DDC_OUT_OF_MEMORY = 2; // Operation failed due to running out of memory | ||
50 | public static final int DDC_FILE_ERROR = 3; // Operation encountered file I/O error | ||
51 | public static final int DDC_INVALID_CALL = 4; // Operation was called with invalid parameters | ||
52 | public static final int DDC_USER_ABORT = 5; // Operation was aborted by the user | ||
53 | public static final int DDC_INVALID_FILE = 6; // File format does not match | ||
54 | |||
55 | // RiffFileMode | ||
56 | public static final int RFM_UNKNOWN = 0; // undefined type (can use to mean "N/A" or "not open") | ||
57 | public static final int RFM_WRITE = 1; // open for write | ||
58 | public static final int RFM_READ = 2; // open for read | ||
59 | |||
60 | private RiffChunkHeader riff_header; // header for whole file | ||
61 | protected int fmode; // current file I/O mode | ||
62 | protected RandomAccessFile file; // I/O stream to use | ||
63 | |||
64 | /** | ||
65 | * Dummy Constructor | ||
66 | */ | ||
67 | public RiffFile() | ||
68 | { | ||
69 | file = null; | ||
70 | fmode = RFM_UNKNOWN; | ||
71 | riff_header = new RiffChunkHeader(); | ||
72 | |||
73 | riff_header.ckID = FourCC("RIFF"); | ||
74 | riff_header.ckSize = 0; | ||
75 | } | ||
76 | |||
77 | /** | ||
78 | * Return File Mode. | ||
79 | */ | ||
80 | public int CurrentFileMode() | ||
81 | {return fmode;} | ||
82 | |||
83 | /** | ||
84 | * Open a RIFF file. | ||
85 | */ | ||
86 | public int Open(String Filename, int NewMode) | ||
87 | { | ||
88 | int retcode = DDC_SUCCESS; | ||
89 | |||
90 | if ( fmode != RFM_UNKNOWN ) | ||
91 | { | ||
92 | retcode = Close(); | ||
93 | } | ||
94 | |||
95 | if ( retcode == DDC_SUCCESS ) | ||
96 | { | ||
97 | switch ( NewMode ) | ||
98 | { | ||
99 | case RFM_WRITE: | ||
100 | try | ||
101 | { | ||
102 | file = new RandomAccessFile(Filename,"rw"); | ||
103 | |||
104 | try | ||
105 | { | ||
106 | // Write the RIFF header... | ||
107 | // We will have to come back later and patch it! | ||
108 | byte[] br = new byte[8]; | ||
109 | br[0] = (byte) ((riff_header.ckID >>> 24) & 0x000000FF); | ||
110 | br[1] = (byte) ((riff_header.ckID >>> 16) & 0x000000FF); | ||
111 | br[2] = (byte) ((riff_header.ckID >>> 8) & 0x000000FF); | ||
112 | br[3] = (byte) (riff_header.ckID & 0x000000FF); | ||
113 | |||
114 | byte br4 = (byte) ((riff_header.ckSize >>> 24)& 0x000000FF); | ||
115 | byte br5 = (byte) ((riff_header.ckSize >>> 16)& 0x000000FF); | ||
116 | byte br6 = (byte) ((riff_header.ckSize >>> 8)& 0x000000FF); | ||
117 | byte br7 = (byte) (riff_header.ckSize & 0x000000FF); | ||
118 | |||
119 | br[4] = br7; | ||
120 | br[5] = br6; | ||
121 | br[6] = br5; | ||
122 | br[7] = br4; | ||
123 | |||
124 | file.write(br,0,8); | ||
125 | fmode = RFM_WRITE; | ||
126 | } catch (IOException ioe) | ||
127 | { | ||
128 | file.close(); | ||
129 | fmode = RFM_UNKNOWN; | ||
130 | } | ||
131 | } catch (IOException ioe) | ||
132 | { | ||
133 | fmode = RFM_UNKNOWN; | ||
134 | retcode = DDC_FILE_ERROR; | ||
135 | } | ||
136 | break; | ||
137 | |||
138 | case RFM_READ: | ||
139 | try | ||
140 | { | ||
141 | file = new RandomAccessFile(Filename,"r"); | ||
142 | try | ||
143 | { | ||
144 | // Try to read the RIFF header... | ||
145 | byte[] br = new byte[8]; | ||
146 | file.read(br,0,8); | ||
147 | fmode = RFM_READ; | ||
148 | riff_header.ckID = ((br[0]<<24)& 0xFF000000) | ((br[1]<<16)&0x00FF0000) | ((br[2]<<8)&0x0000FF00) | (br[3]&0x000000FF); | ||
149 | riff_header.ckSize = ((br[4]<<24)& 0xFF000000) | ((br[5]<<16)&0x00FF0000) | ((br[6]<<8)&0x0000FF00) | (br[7]&0x000000FF); | ||
150 | } catch (IOException ioe) | ||
151 | { | ||
152 | file.close(); | ||
153 | fmode = RFM_UNKNOWN; | ||
154 | } | ||
155 | } catch (IOException ioe) | ||
156 | { | ||
157 | fmode = RFM_UNKNOWN; | ||
158 | retcode = DDC_FILE_ERROR; | ||
159 | } | ||
160 | break; | ||
161 | default: | ||
162 | retcode = DDC_INVALID_CALL; | ||
163 | } | ||
164 | } | ||
165 | return retcode; | ||
166 | } | ||
167 | |||
168 | /** | ||
169 | * Write NumBytes data. | ||
170 | */ | ||
171 | public int Write(byte[] Data, int NumBytes ) | ||
172 | { | ||
173 | if ( fmode != RFM_WRITE ) | ||
174 | { | ||
175 | return DDC_INVALID_CALL; | ||
176 | } | ||
177 | try | ||
178 | { | ||
179 | file.write(Data,0,NumBytes); | ||
180 | fmode = RFM_WRITE; | ||
181 | } | ||
182 | catch (IOException ioe) | ||
183 | { | ||
184 | return DDC_FILE_ERROR; | ||
185 | } | ||
186 | riff_header.ckSize += NumBytes; | ||
187 | return DDC_SUCCESS; | ||
188 | } | ||
189 | |||
190 | |||
191 | |||
192 | /** | ||
193 | * Write NumBytes data. | ||
194 | */ | ||
195 | public int Write(short[] Data, int NumBytes ) | ||
196 | { | ||
197 | byte[] theData = new byte[NumBytes]; | ||
198 | int yc = 0; | ||
199 | for (int y = 0;y<NumBytes;y=y+2) | ||
200 | { | ||
201 | theData[y] = (byte) (Data[yc] & 0x00FF); | ||
202 | theData[y+1] =(byte) ((Data[yc++] >>> 8) & 0x00FF); | ||
203 | } | ||
204 | if ( fmode != RFM_WRITE ) | ||
205 | { | ||
206 | return DDC_INVALID_CALL; | ||
207 | } | ||
208 | try | ||
209 | { | ||
210 | file.write(theData,0,NumBytes); | ||
211 | fmode = RFM_WRITE; | ||
212 | } | ||
213 | catch (IOException ioe) | ||
214 | { | ||
215 | return DDC_FILE_ERROR; | ||
216 | } | ||
217 | riff_header.ckSize += NumBytes; | ||
218 | return DDC_SUCCESS; | ||
219 | } | ||
220 | |||
221 | /** | ||
222 | * Write NumBytes data. | ||
223 | */ | ||
224 | public int Write(RiffChunkHeader Triff_header, int NumBytes ) | ||
225 | { | ||
226 | byte[] br = new byte[8]; | ||
227 | br[0] = (byte) ((Triff_header.ckID >>> 24) & 0x000000FF); | ||
228 | br[1] = (byte) ((Triff_header.ckID >>> 16) & 0x000000FF); | ||
229 | br[2] = (byte) ((Triff_header.ckID >>> 8) & 0x000000FF); | ||
230 | br[3] = (byte) (Triff_header.ckID & 0x000000FF); | ||
231 | |||
232 | byte br4 = (byte) ((Triff_header.ckSize >>> 24)& 0x000000FF); | ||
233 | byte br5 = (byte) ((Triff_header.ckSize >>> 16)& 0x000000FF); | ||
234 | byte br6 = (byte) ((Triff_header.ckSize >>> 8)& 0x000000FF); | ||
235 | byte br7 = (byte) (Triff_header.ckSize & 0x000000FF); | ||
236 | |||
237 | br[4] = br7; | ||
238 | br[5] = br6; | ||
239 | br[6] = br5; | ||
240 | br[7] = br4; | ||
241 | |||
242 | if ( fmode != RFM_WRITE ) | ||
243 | { | ||
244 | return DDC_INVALID_CALL; | ||
245 | } | ||
246 | try | ||
247 | { | ||
248 | file.write(br,0,NumBytes); | ||
249 | fmode = RFM_WRITE; | ||
250 | } catch (IOException ioe) | ||
251 | { | ||
252 | return DDC_FILE_ERROR; | ||
253 | } | ||
254 | riff_header.ckSize += NumBytes; | ||
255 | return DDC_SUCCESS; | ||
256 | } | ||
257 | |||
258 | /** | ||
259 | * Write NumBytes data. | ||
260 | */ | ||
261 | public int Write(short Data, int NumBytes ) | ||
262 | { | ||
263 | short theData = (short) ( ((Data>>>8)&0x00FF) | ((Data<<8)&0xFF00) ); | ||
264 | if ( fmode != RFM_WRITE ) | ||
265 | { | ||
266 | return DDC_INVALID_CALL; | ||
267 | } | ||
268 | try | ||
269 | { | ||
270 | file.writeShort(theData); | ||
271 | fmode = RFM_WRITE; | ||
272 | } catch (IOException ioe) | ||
273 | { | ||
274 | return DDC_FILE_ERROR; | ||
275 | } | ||
276 | riff_header.ckSize += NumBytes; | ||
277 | return DDC_SUCCESS; | ||
278 | } | ||
279 | /** | ||
280 | * Write NumBytes data. | ||
281 | */ | ||
282 | public int Write(int Data, int NumBytes ) | ||
283 | { | ||
284 | short theDataL = (short) ((Data>>>16)&0x0000FFFF); | ||
285 | short theDataR = (short) (Data&0x0000FFFF); | ||
286 | short theDataLI = (short) ( ((theDataL>>>8)&0x00FF) | ((theDataL<<8)&0xFF00) ); | ||
287 | short theDataRI = (short) ( ((theDataR>>>8)&0x00FF) | ((theDataR<<8)&0xFF00) ); | ||
288 | int theData = ((theDataRI<<16)&0xFFFF0000) | (theDataLI&0x0000FFFF); | ||
289 | if ( fmode != RFM_WRITE ) | ||
290 | { | ||
291 | return DDC_INVALID_CALL; | ||
292 | } | ||
293 | try | ||
294 | { | ||
295 | file.writeInt(theData); | ||
296 | fmode = RFM_WRITE; | ||
297 | } catch (IOException ioe) | ||
298 | { | ||
299 | return DDC_FILE_ERROR; | ||
300 | } | ||
301 | riff_header.ckSize += NumBytes; | ||
302 | return DDC_SUCCESS; | ||
303 | } | ||
304 | |||
305 | |||
306 | |||
307 | /** | ||
308 | * Read NumBytes data. | ||
309 | */ | ||
310 | public int Read (byte[] Data, int NumBytes) | ||
311 | { | ||
312 | int retcode = DDC_SUCCESS; | ||
313 | try | ||
314 | { | ||
315 | file.read(Data,0,NumBytes); | ||
316 | } catch (IOException ioe) | ||
317 | { | ||
318 | retcode = DDC_FILE_ERROR; | ||
319 | } | ||
320 | return retcode; | ||
321 | } | ||
322 | |||
323 | /** | ||
324 | * Expect NumBytes data. | ||
325 | */ | ||
326 | public int Expect(String Data, int NumBytes ) | ||
327 | { | ||
328 | byte target = 0; | ||
329 | int cnt = 0; | ||
330 | try | ||
331 | { | ||
332 | while ((NumBytes--) != 0) | ||
333 | { | ||
334 | target = file.readByte(); | ||
335 | if (target != Data.charAt(cnt++)) return DDC_FILE_ERROR; | ||
336 | } | ||
337 | } catch (IOException ioe) | ||
338 | { | ||
339 | return DDC_FILE_ERROR; | ||
340 | } | ||
341 | return DDC_SUCCESS; | ||
342 | } | ||
343 | |||
344 | /** | ||
345 | * Close Riff File. | ||
346 | * Length is written too. | ||
347 | */ | ||
348 | public int Close() | ||
349 | { | ||
350 | int retcode = DDC_SUCCESS; | ||
351 | |||
352 | switch ( fmode ) | ||
353 | { | ||
354 | case RFM_WRITE: | ||
355 | try | ||
356 | { | ||
357 | file.seek(0); | ||
358 | try | ||
359 | { | ||
360 | byte[] br = new byte[8]; | ||
361 | br[0] = (byte) ((riff_header.ckID >>> 24) & 0x000000FF); | ||
362 | br[1] = (byte) ((riff_header.ckID >>> 16) & 0x000000FF); | ||
363 | br[2] = (byte) ((riff_header.ckID >>> 8) & 0x000000FF); | ||
364 | br[3] = (byte) (riff_header.ckID & 0x000000FF); | ||
365 | |||
366 | br[7] = (byte) ((riff_header.ckSize >>> 24)& 0x000000FF); | ||
367 | br[6] = (byte) ((riff_header.ckSize >>> 16)& 0x000000FF); | ||
368 | br[5] = (byte) ((riff_header.ckSize >>> 8)& 0x000000FF); | ||
369 | br[4] = (byte) (riff_header.ckSize & 0x000000FF); | ||
370 | file.write(br,0,8); | ||
371 | file.close(); | ||
372 | } catch (IOException ioe) | ||
373 | { | ||
374 | retcode = DDC_FILE_ERROR; | ||
375 | } | ||
376 | } catch (IOException ioe) | ||
377 | { | ||
378 | retcode = DDC_FILE_ERROR; | ||
379 | } | ||
380 | break; | ||
381 | |||
382 | case RFM_READ: | ||
383 | try | ||
384 | { | ||
385 | file.close(); | ||
386 | } catch (IOException ioe) | ||
387 | { | ||
388 | retcode = DDC_FILE_ERROR; | ||
389 | } | ||
390 | break; | ||
391 | } | ||
392 | file = null; | ||
393 | fmode = RFM_UNKNOWN; | ||
394 | return retcode; | ||
395 | } | ||
396 | |||
397 | /** | ||
398 | * Return File Position. | ||
399 | */ | ||
400 | public long CurrentFilePosition() | ||
401 | { | ||
402 | long position; | ||
403 | try | ||
404 | { | ||
405 | position = file.getFilePointer(); | ||
406 | } catch (IOException ioe) | ||
407 | { | ||
408 | position = -1; | ||
409 | } | ||
410 | return position; | ||
411 | } | ||
412 | |||
413 | /** | ||
414 | * Write Data to specified offset. | ||
415 | */ | ||
416 | public int Backpatch (long FileOffset, RiffChunkHeader Data, int NumBytes ) | ||
417 | { | ||
418 | if (file == null) | ||
419 | { | ||
420 | return DDC_INVALID_CALL; | ||
421 | } | ||
422 | try | ||
423 | { | ||
424 | file.seek(FileOffset); | ||
425 | } catch (IOException ioe) | ||
426 | { | ||
427 | return DDC_FILE_ERROR; | ||
428 | } | ||
429 | return Write ( Data, NumBytes ); | ||
430 | } | ||
431 | |||
432 | public int Backpatch (long FileOffset, byte[] Data, int NumBytes ) | ||
433 | { | ||
434 | if (file == null) | ||
435 | { | ||
436 | return DDC_INVALID_CALL; | ||
437 | } | ||
438 | try | ||
439 | { | ||
440 | file.seek(FileOffset); | ||
441 | } catch (IOException ioe) | ||
442 | { | ||
443 | return DDC_FILE_ERROR; | ||
444 | } | ||
445 | return Write ( Data, NumBytes ); | ||
446 | } | ||
447 | |||
448 | |||
449 | /** | ||
450 | * Seek in the File. | ||
451 | */ | ||
452 | protected int Seek(long offset) | ||
453 | { | ||
454 | int rc; | ||
455 | try | ||
456 | { | ||
457 | file.seek(offset); | ||
458 | rc = DDC_SUCCESS; | ||
459 | } catch (IOException ioe) | ||
460 | { | ||
461 | rc = DDC_FILE_ERROR; | ||
462 | } | ||
463 | return rc; | ||
464 | } | ||
465 | |||
466 | /** | ||
467 | * Error Messages. | ||
468 | */ | ||
469 | private String DDCRET_String(int retcode) | ||
470 | { | ||
471 | switch ( retcode ) | ||
472 | { | ||
473 | case DDC_SUCCESS: return "DDC_SUCCESS"; | ||
474 | case DDC_FAILURE: return "DDC_FAILURE"; | ||
475 | case DDC_OUT_OF_MEMORY: return "DDC_OUT_OF_MEMORY"; | ||
476 | case DDC_FILE_ERROR: return "DDC_FILE_ERROR"; | ||
477 | case DDC_INVALID_CALL: return "DDC_INVALID_CALL"; | ||
478 | case DDC_USER_ABORT: return "DDC_USER_ABORT"; | ||
479 | case DDC_INVALID_FILE: return "DDC_INVALID_FILE"; | ||
480 | } | ||
481 | return "Unknown Error"; | ||
482 | } | ||
483 | |||
484 | /** | ||
485 | * Fill the header. | ||
486 | */ | ||
487 | public static int FourCC(String ChunkName) | ||
488 | { | ||
489 | byte[] p = {0x20,0x20,0x20,0x20}; | ||
490 | ChunkName.getBytes(0,4,p,0); | ||
491 | int ret = (((p[0] << 24)& 0xFF000000) | ((p[1] << 16)&0x00FF0000) | ((p[2] << 8)&0x0000FF00) | (p[3]&0x000000FF)); | ||
492 | return ret; | ||
493 | } | ||
494 | |||
495 | } | ||
diff --git a/songdbj/javazoom/jl/converter/WaveFile.java b/songdbj/javazoom/jl/converter/WaveFile.java deleted file mode 100644 index f158d7a39a..0000000000 --- a/songdbj/javazoom/jl/converter/WaveFile.java +++ /dev/null | |||
@@ -1,522 +0,0 @@ | |||
1 | /* | ||
2 | * 11/19/04 1.0 moved to LGPL. | ||
3 | * 02/23/99 JavaConversion by E.B | ||
4 | * Don Cross, April 1993. | ||
5 | * RIFF file format classes. | ||
6 | * See Chapter 8 of "Multimedia Programmer's Reference" in | ||
7 | * the Microsoft Windows SDK. | ||
8 | * | ||
9 | *----------------------------------------------------------------------- | ||
10 | * This program is free software; you can redistribute it and/or modify | ||
11 | * it under the terms of the GNU Library General Public License as published | ||
12 | * by the Free Software Foundation; either version 2 of the License, or | ||
13 | * (at your option) any later version. | ||
14 | * | ||
15 | * This program is distributed in the hope that it will be useful, | ||
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
18 | * GNU Library General Public License for more details. | ||
19 | * | ||
20 | * You should have received a copy of the GNU Library General Public | ||
21 | * License along with this program; if not, write to the Free Software | ||
22 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
23 | *---------------------------------------------------------------------- | ||
24 | */ | ||
25 | |||
26 | package javazoom.jl.converter; | ||
27 | |||
28 | /** | ||
29 | * Class allowing WaveFormat Access | ||
30 | */ | ||
31 | public class WaveFile extends RiffFile | ||
32 | { | ||
33 | public static final int MAX_WAVE_CHANNELS = 2; | ||
34 | |||
35 | class WaveFormat_ChunkData | ||
36 | { | ||
37 | public short wFormatTag = 0; // Format category (PCM=1) | ||
38 | public short nChannels = 0; // Number of channels (mono=1, stereo=2) | ||
39 | public int nSamplesPerSec = 0; // Sampling rate [Hz] | ||
40 | public int nAvgBytesPerSec = 0; | ||
41 | public short nBlockAlign = 0; | ||
42 | public short nBitsPerSample = 0; | ||
43 | |||
44 | public WaveFormat_ChunkData() | ||
45 | { | ||
46 | wFormatTag = 1; // PCM | ||
47 | Config(44100,(short)16,(short)1); | ||
48 | } | ||
49 | |||
50 | public void Config (int NewSamplingRate, short NewBitsPerSample, short NewNumChannels) | ||
51 | { | ||
52 | nSamplesPerSec = NewSamplingRate; | ||
53 | nChannels = NewNumChannels; | ||
54 | nBitsPerSample = NewBitsPerSample; | ||
55 | nAvgBytesPerSec = (nChannels * nSamplesPerSec * nBitsPerSample) / 8; | ||
56 | nBlockAlign = (short) ((nChannels * nBitsPerSample) / 8); | ||
57 | } | ||
58 | } | ||
59 | |||
60 | |||
61 | class WaveFormat_Chunk | ||
62 | { | ||
63 | public RiffChunkHeader header; | ||
64 | public WaveFormat_ChunkData data; | ||
65 | |||
66 | public WaveFormat_Chunk() | ||
67 | { | ||
68 | header = new RiffChunkHeader(); | ||
69 | data = new WaveFormat_ChunkData(); | ||
70 | header.ckID = FourCC("fmt "); | ||
71 | header.ckSize = 16; | ||
72 | } | ||
73 | |||
74 | public int VerifyValidity() | ||
75 | { | ||
76 | boolean ret = header.ckID == FourCC("fmt ") && | ||
77 | |||
78 | (data.nChannels == 1 || data.nChannels == 2) && | ||
79 | |||
80 | data.nAvgBytesPerSec == ( data.nChannels * | ||
81 | data.nSamplesPerSec * | ||
82 | data.nBitsPerSample ) / 8 && | ||
83 | |||
84 | data.nBlockAlign == ( data.nChannels * | ||
85 | data.nBitsPerSample ) / 8; | ||
86 | if (ret == true) return 1; | ||
87 | else return 0; | ||
88 | } | ||
89 | } | ||
90 | |||
91 | public class WaveFileSample | ||
92 | { | ||
93 | public short[] chan; | ||
94 | |||
95 | public WaveFileSample() | ||
96 | {chan = new short[WaveFile.MAX_WAVE_CHANNELS];} | ||
97 | } | ||
98 | |||
99 | private WaveFormat_Chunk wave_format; | ||
100 | private RiffChunkHeader pcm_data; | ||
101 | private long pcm_data_offset = 0; // offset of 'pcm_data' in output file | ||
102 | private int num_samples = 0; | ||
103 | |||
104 | |||
105 | /** | ||
106 | * Constructs a new WaveFile instance. | ||
107 | */ | ||
108 | public WaveFile() | ||
109 | { | ||
110 | pcm_data = new RiffChunkHeader(); | ||
111 | wave_format = new WaveFormat_Chunk(); | ||
112 | pcm_data.ckID = FourCC("data"); | ||
113 | pcm_data.ckSize = 0; | ||
114 | num_samples = 0; | ||
115 | } | ||
116 | |||
117 | /** | ||
118 | * | ||
119 | * | ||
120 | public int OpenForRead (String Filename) | ||
121 | { | ||
122 | // Verify filename parameter as best we can... | ||
123 | if (Filename == null) | ||
124 | { | ||
125 | return DDC_INVALID_CALL; | ||
126 | } | ||
127 | int retcode = Open ( Filename, RFM_READ ); | ||
128 | |||
129 | if ( retcode == DDC_SUCCESS ) | ||
130 | { | ||
131 | retcode = Expect ( "WAVE", 4 ); | ||
132 | |||
133 | if ( retcode == DDC_SUCCESS ) | ||
134 | { | ||
135 | retcode = Read(wave_format,24); | ||
136 | |||
137 | if ( retcode == DDC_SUCCESS && !wave_format.VerifyValidity() ) | ||
138 | { | ||
139 | // This isn't standard PCM, so we don't know what it is! | ||
140 | retcode = DDC_FILE_ERROR; | ||
141 | } | ||
142 | |||
143 | if ( retcode == DDC_SUCCESS ) | ||
144 | { | ||
145 | pcm_data_offset = CurrentFilePosition(); | ||
146 | |||
147 | // Figure out number of samples from | ||
148 | // file size, current file position, and | ||
149 | // WAVE header. | ||
150 | retcode = Read (pcm_data, 8 ); | ||
151 | num_samples = filelength(fileno(file)) - CurrentFilePosition(); | ||
152 | num_samples /= NumChannels(); | ||
153 | num_samples /= (BitsPerSample() / 8); | ||
154 | } | ||
155 | } | ||
156 | } | ||
157 | return retcode; | ||
158 | }*/ | ||
159 | |||
160 | /** | ||
161 | * | ||
162 | */ | ||
163 | public int OpenForWrite (String Filename, int SamplingRate, short BitsPerSample, short NumChannels) | ||
164 | { | ||
165 | // Verify parameters... | ||
166 | if ( (Filename==null) || | ||
167 | (BitsPerSample != 8 && BitsPerSample != 16) || | ||
168 | NumChannels < 1 || NumChannels > 2 ) | ||
169 | { | ||
170 | return DDC_INVALID_CALL; | ||
171 | } | ||
172 | |||
173 | wave_format.data.Config ( SamplingRate, BitsPerSample, NumChannels ); | ||
174 | |||
175 | int retcode = Open ( Filename, RFM_WRITE ); | ||
176 | |||
177 | if ( retcode == DDC_SUCCESS ) | ||
178 | { | ||
179 | byte [] theWave = {(byte)'W',(byte)'A',(byte)'V',(byte)'E'}; | ||
180 | retcode = Write ( theWave, 4 ); | ||
181 | |||
182 | if ( retcode == DDC_SUCCESS ) | ||
183 | { | ||
184 | // Ecriture de wave_format | ||
185 | retcode = Write (wave_format.header, 8); | ||
186 | retcode = Write (wave_format.data.wFormatTag, 2); | ||
187 | retcode = Write (wave_format.data.nChannels, 2); | ||
188 | retcode = Write (wave_format.data.nSamplesPerSec, 4); | ||
189 | retcode = Write (wave_format.data.nAvgBytesPerSec, 4); | ||
190 | retcode = Write (wave_format.data.nBlockAlign, 2); | ||
191 | retcode = Write (wave_format.data.nBitsPerSample, 2); | ||
192 | /* byte[] br = new byte[16]; | ||
193 | br[0] = (byte) ((wave_format.data.wFormatTag >> 8) & 0x00FF); | ||
194 | br[1] = (byte) (wave_format.data.wFormatTag & 0x00FF); | ||
195 | |||
196 | br[2] = (byte) ((wave_format.data.nChannels >> 8) & 0x00FF); | ||
197 | br[3] = (byte) (wave_format.data.nChannels & 0x00FF); | ||
198 | |||
199 | br[4] = (byte) ((wave_format.data.nSamplesPerSec >> 24)& 0x000000FF); | ||
200 | br[5] = (byte) ((wave_format.data.nSamplesPerSec >> 16)& 0x000000FF); | ||
201 | br[6] = (byte) ((wave_format.data.nSamplesPerSec >> 8)& 0x000000FF); | ||
202 | br[7] = (byte) (wave_format.data.nSamplesPerSec & 0x000000FF); | ||
203 | |||
204 | br[8] = (byte) ((wave_format.data.nAvgBytesPerSec>> 24)& 0x000000FF); | ||
205 | br[9] = (byte) ((wave_format.data.nAvgBytesPerSec >> 16)& 0x000000FF); | ||
206 | br[10] = (byte) ((wave_format.data.nAvgBytesPerSec >> 8)& 0x000000FF); | ||
207 | br[11] = (byte) (wave_format.data.nAvgBytesPerSec & 0x000000FF); | ||
208 | |||
209 | br[12] = (byte) ((wave_format.data.nBlockAlign >> 8) & 0x00FF); | ||
210 | br[13] = (byte) (wave_format.data.nBlockAlign & 0x00FF); | ||
211 | |||
212 | br[14] = (byte) ((wave_format.data.nBitsPerSample >> 8) & 0x00FF); | ||
213 | br[15] = (byte) (wave_format.data.nBitsPerSample & 0x00FF); | ||
214 | retcode = Write (br, 16); */ | ||
215 | |||
216 | |||
217 | if ( retcode == DDC_SUCCESS ) | ||
218 | { | ||
219 | pcm_data_offset = CurrentFilePosition(); | ||
220 | retcode = Write ( pcm_data, 8 ); | ||
221 | } | ||
222 | } | ||
223 | } | ||
224 | |||
225 | return retcode; | ||
226 | } | ||
227 | |||
228 | /** | ||
229 | * | ||
230 | * | ||
231 | public int ReadSample ( short[] Sample ) | ||
232 | { | ||
233 | |||
234 | }*/ | ||
235 | |||
236 | /** | ||
237 | * | ||
238 | * | ||
239 | public int WriteSample( short[] Sample ) | ||
240 | { | ||
241 | int retcode = DDC_SUCCESS; | ||
242 | switch ( wave_format.data.nChannels ) | ||
243 | { | ||
244 | case 1: | ||
245 | switch ( wave_format.data.nBitsPerSample ) | ||
246 | { | ||
247 | case 8: | ||
248 | pcm_data.ckSize += 1; | ||
249 | retcode = Write ( Sample, 1 ); | ||
250 | break; | ||
251 | |||
252 | case 16: | ||
253 | pcm_data.ckSize += 2; | ||
254 | retcode = Write ( Sample, 2 ); | ||
255 | break; | ||
256 | |||
257 | default: | ||
258 | retcode = DDC_INVALID_CALL; | ||
259 | } | ||
260 | break; | ||
261 | |||
262 | case 2: | ||
263 | switch ( wave_format.data.nBitsPerSample ) | ||
264 | { | ||
265 | case 8: | ||
266 | retcode = Write ( Sample, 1 ); | ||
267 | if ( retcode == DDC_SUCCESS ) | ||
268 | { | ||
269 | // &Sample[1] | ||
270 | retcode = Write (Sample, 1 ); | ||
271 | if ( retcode == DDC_SUCCESS ) | ||
272 | { | ||
273 | pcm_data.ckSize += 2; | ||
274 | } | ||
275 | } | ||
276 | break; | ||
277 | |||
278 | case 16: | ||
279 | retcode = Write ( Sample, 2 ); | ||
280 | if ( retcode == DDC_SUCCESS ) | ||
281 | { | ||
282 | // &Sample[1] | ||
283 | retcode = Write (Sample, 2 ); | ||
284 | if ( retcode == DDC_SUCCESS ) | ||
285 | { | ||
286 | pcm_data.ckSize += 4; | ||
287 | } | ||
288 | } | ||
289 | break; | ||
290 | |||
291 | default: | ||
292 | retcode = DDC_INVALID_CALL; | ||
293 | } | ||
294 | break; | ||
295 | |||
296 | default: | ||
297 | retcode = DDC_INVALID_CALL; | ||
298 | } | ||
299 | |||
300 | return retcode; | ||
301 | }*/ | ||
302 | |||
303 | /** | ||
304 | * | ||
305 | * | ||
306 | public int SeekToSample ( long SampleIndex ) | ||
307 | { | ||
308 | if ( SampleIndex >= NumSamples() ) | ||
309 | { | ||
310 | return DDC_INVALID_CALL; | ||
311 | } | ||
312 | int SampleSize = (BitsPerSample() + 7) / 8; | ||
313 | int rc = Seek ( pcm_data_offset + 8 + | ||
314 | SampleSize * NumChannels() * SampleIndex ); | ||
315 | return rc; | ||
316 | }*/ | ||
317 | |||
318 | /** | ||
319 | * Write 16-bit audio | ||
320 | */ | ||
321 | public int WriteData ( short[] data, int numData ) | ||
322 | { | ||
323 | int extraBytes = numData * 2; | ||
324 | pcm_data.ckSize += extraBytes; | ||
325 | return super.Write ( data, extraBytes ); | ||
326 | } | ||
327 | |||
328 | /** | ||
329 | * Read 16-bit audio. | ||
330 | * | ||
331 | public int ReadData (short[] data, int numData) | ||
332 | {return super.Read ( data, numData * 2);} */ | ||
333 | |||
334 | /** | ||
335 | * Write 8-bit audio. | ||
336 | * | ||
337 | public int WriteData ( byte[] data, int numData ) | ||
338 | { | ||
339 | pcm_data.ckSize += numData; | ||
340 | return super.Write ( data, numData ); | ||
341 | }*/ | ||
342 | |||
343 | /** | ||
344 | * Read 8-bit audio. | ||
345 | * | ||
346 | public int ReadData ( byte[] data, int numData ) | ||
347 | {return super.Read ( data, numData );} */ | ||
348 | |||
349 | |||
350 | /** | ||
351 | * | ||
352 | * | ||
353 | public int ReadSamples (int num, int [] WaveFileSample) | ||
354 | { | ||
355 | |||
356 | }*/ | ||
357 | |||
358 | /** | ||
359 | * | ||
360 | * | ||
361 | public int WriteMonoSample ( short[] SampleData ) | ||
362 | { | ||
363 | switch ( wave_format.data.nBitsPerSample ) | ||
364 | { | ||
365 | case 8: | ||
366 | pcm_data.ckSize += 1; | ||
367 | return Write ( SampleData, 1 ); | ||
368 | |||
369 | case 16: | ||
370 | pcm_data.ckSize += 2; | ||
371 | return Write ( SampleData, 2 ); | ||
372 | } | ||
373 | return DDC_INVALID_CALL; | ||
374 | }*/ | ||
375 | |||
376 | /** | ||
377 | * | ||
378 | * | ||
379 | public int WriteStereoSample ( short[] LeftSample, short[] RightSample ) | ||
380 | { | ||
381 | int retcode = DDC_SUCCESS; | ||
382 | switch ( wave_format.data.nBitsPerSample ) | ||
383 | { | ||
384 | case 8: | ||
385 | retcode = Write ( LeftSample, 1 ); | ||
386 | if ( retcode == DDC_SUCCESS ) | ||
387 | { | ||
388 | retcode = Write ( RightSample, 1 ); | ||
389 | if ( retcode == DDC_SUCCESS ) | ||
390 | { | ||
391 | pcm_data.ckSize += 2; | ||
392 | } | ||
393 | } | ||
394 | break; | ||
395 | |||
396 | case 16: | ||
397 | retcode = Write ( LeftSample, 2 ); | ||
398 | if ( retcode == DDC_SUCCESS ) | ||
399 | { | ||
400 | retcode = Write ( RightSample, 2 ); | ||
401 | if ( retcode == DDC_SUCCESS ) | ||
402 | { | ||
403 | pcm_data.ckSize += 4; | ||
404 | } | ||
405 | } | ||
406 | break; | ||
407 | |||
408 | default: | ||
409 | retcode = DDC_INVALID_CALL; | ||
410 | } | ||
411 | return retcode; | ||
412 | }*/ | ||
413 | |||
414 | /** | ||
415 | * | ||
416 | * | ||
417 | public int ReadMonoSample ( short[] Sample ) | ||
418 | { | ||
419 | int retcode = DDC_SUCCESS; | ||
420 | switch ( wave_format.data.nBitsPerSample ) | ||
421 | { | ||
422 | case 8: | ||
423 | byte[] x = {0}; | ||
424 | retcode = Read ( x, 1 ); | ||
425 | Sample[0] = (short)(x[0]); | ||
426 | break; | ||
427 | |||
428 | case 16: | ||
429 | retcode = Read ( Sample, 2 ); | ||
430 | break; | ||
431 | |||
432 | default: | ||
433 | retcode = DDC_INVALID_CALL; | ||
434 | } | ||
435 | return retcode; | ||
436 | }*/ | ||
437 | |||
438 | /** | ||
439 | * | ||
440 | * | ||
441 | public int ReadStereoSample ( short[] LeftSampleData, short[] RightSampleData ) | ||
442 | { | ||
443 | int retcode = DDC_SUCCESS; | ||
444 | byte[] x = new byte[2]; | ||
445 | short[] y = new short[2]; | ||
446 | switch ( wave_format.data.nBitsPerSample ) | ||
447 | { | ||
448 | case 8: | ||
449 | retcode = Read ( x, 2 ); | ||
450 | L[0] = (short) ( x[0] ); | ||
451 | R[0] = (short) ( x[1] ); | ||
452 | break; | ||
453 | |||
454 | case 16: | ||
455 | retcode = Read ( y, 4 ); | ||
456 | L[0] = (short) ( y[0] ); | ||
457 | R[0] = (short) ( y[1] ); | ||
458 | break; | ||
459 | |||
460 | default: | ||
461 | retcode = DDC_INVALID_CALL; | ||
462 | } | ||
463 | return retcode; | ||
464 | }*/ | ||
465 | |||
466 | |||
467 | /** | ||
468 | * | ||
469 | */ | ||
470 | public int Close() | ||
471 | { | ||
472 | int rc = DDC_SUCCESS; | ||
473 | |||
474 | if ( fmode == RFM_WRITE ) | ||
475 | rc = Backpatch ( pcm_data_offset, pcm_data, 8 ); | ||
476 | if ( rc == DDC_SUCCESS ) | ||
477 | rc = super.Close(); | ||
478 | return rc; | ||
479 | } | ||
480 | |||
481 | // [Hz] | ||
482 | public int SamplingRate() | ||
483 | {return wave_format.data.nSamplesPerSec;} | ||
484 | |||
485 | public short BitsPerSample() | ||
486 | {return wave_format.data.nBitsPerSample;} | ||
487 | |||
488 | public short NumChannels() | ||
489 | {return wave_format.data.nChannels;} | ||
490 | |||
491 | public int NumSamples() | ||
492 | {return num_samples;} | ||
493 | |||
494 | |||
495 | /** | ||
496 | * Open for write using another wave file's parameters... | ||
497 | */ | ||
498 | public int OpenForWrite (String Filename, WaveFile OtherWave ) | ||
499 | { | ||
500 | return OpenForWrite ( Filename, | ||
501 | OtherWave.SamplingRate(), | ||
502 | OtherWave.BitsPerSample(), | ||
503 | OtherWave.NumChannels() ); | ||
504 | } | ||
505 | |||
506 | /** | ||
507 | * | ||
508 | */ | ||
509 | public long CurrentFilePosition() | ||
510 | { | ||
511 | return super.CurrentFilePosition(); | ||
512 | } | ||
513 | |||
514 | /* public int FourCC(String ChunkName) | ||
515 | { | ||
516 | byte[] p = {0x20,0x20,0x20,0x20}; | ||
517 | ChunkName.getBytes(0,4,p,0); | ||
518 | int ret = (((p[0] << 24)& 0xFF000000) | ((p[1] << 16)&0x00FF0000) | ((p[2] << 8)&0x0000FF00) | (p[3]&0x000000FF)); | ||
519 | return ret; | ||
520 | }*/ | ||
521 | |||
522 | } \ No newline at end of file | ||
diff --git a/songdbj/javazoom/jl/converter/WaveFileObuffer.java b/songdbj/javazoom/jl/converter/WaveFileObuffer.java deleted file mode 100644 index eaa1dd46d4..0000000000 --- a/songdbj/javazoom/jl/converter/WaveFileObuffer.java +++ /dev/null | |||
@@ -1,141 +0,0 @@ | |||
1 | /* | ||
2 | * 11/19/04 1.0 moved to LGPL. | ||
3 | * | ||
4 | * 12/12/99 0.0.7 Renamed class, additional constructor arguments | ||
5 | * and larger write buffers. mdm@techie.com. | ||
6 | * | ||
7 | * 15/02/99 Java Conversion by E.B ,javalayer@javazoom.net | ||
8 | * | ||
9 | *----------------------------------------------------------------------- | ||
10 | * This program is free software; you can redistribute it and/or modify | ||
11 | * it under the terms of the GNU Library General Public License as published | ||
12 | * by the Free Software Foundation; either version 2 of the License, or | ||
13 | * (at your option) any later version. | ||
14 | * | ||
15 | * This program is distributed in the hope that it will be useful, | ||
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
18 | * GNU Library General Public License for more details. | ||
19 | * | ||
20 | * You should have received a copy of the GNU Library General Public | ||
21 | * License along with this program; if not, write to the Free Software | ||
22 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
23 | *---------------------------------------------------------------------- | ||
24 | */ | ||
25 | |||
26 | package javazoom.jl.converter; | ||
27 | |||
28 | import javazoom.jl.decoder.Obuffer; | ||
29 | |||
30 | /** | ||
31 | * Implements an Obuffer by writing the data to | ||
32 | * a file in RIFF WAVE format. | ||
33 | * | ||
34 | * @since 0.0 | ||
35 | */ | ||
36 | |||
37 | |||
38 | public class WaveFileObuffer extends Obuffer | ||
39 | { | ||
40 | private short[] buffer; | ||
41 | private short[] bufferp; | ||
42 | private int channels; | ||
43 | private WaveFile outWave; | ||
44 | |||
45 | /** | ||
46 | * Creates a new WareFileObuffer instance. | ||
47 | * | ||
48 | * @param number_of_channels | ||
49 | * The number of channels of audio data | ||
50 | * this buffer will receive. | ||
51 | * | ||
52 | * @param freq The sample frequency of the samples in the buffer. | ||
53 | * | ||
54 | * @param fileName The filename to write the data to. | ||
55 | */ | ||
56 | public WaveFileObuffer(int number_of_channels, int freq, String FileName) | ||
57 | { | ||
58 | if (FileName==null) | ||
59 | throw new NullPointerException("FileName"); | ||
60 | |||
61 | buffer = new short[OBUFFERSIZE]; | ||
62 | bufferp = new short[MAXCHANNELS]; | ||
63 | channels = number_of_channels; | ||
64 | |||
65 | for (int i = 0; i < number_of_channels; ++i) | ||
66 | bufferp[i] = (short)i; | ||
67 | |||
68 | outWave = new WaveFile(); | ||
69 | |||
70 | int rc = outWave.OpenForWrite (FileName,freq,(short)16,(short)channels); | ||
71 | } | ||
72 | |||
73 | /** | ||
74 | * Takes a 16 Bit PCM sample. | ||
75 | */ | ||
76 | public void append(int channel, short value) | ||
77 | { | ||
78 | buffer[bufferp[channel]] = value; | ||
79 | bufferp[channel] += channels; | ||
80 | } | ||
81 | |||
82 | /** | ||
83 | * Write the samples to the file (Random Acces). | ||
84 | */ | ||
85 | short[] myBuffer = new short[2]; | ||
86 | public void write_buffer(int val) | ||
87 | { | ||
88 | |||
89 | int k = 0; | ||
90 | int rc = 0; | ||
91 | |||
92 | rc = outWave.WriteData(buffer, bufferp[0]); | ||
93 | // REVIEW: handle RiffFile errors. | ||
94 | /* | ||
95 | for (int j=0;j<bufferp[0];j=j+2) | ||
96 | { | ||
97 | |||
98 | //myBuffer[0] = (short)(((buffer[j]>>8)&0x000000FF) | ((buffer[j]<<8)&0x0000FF00)); | ||
99 | //myBuffer[1] = (short) (((buffer[j+1]>>8)&0x000000FF) | ((buffer[j+1]<<8)&0x0000FF00)); | ||
100 | myBuffer[0] = buffer[j]; | ||
101 | myBuffer[1] = buffer[j+1]; | ||
102 | rc = outWave.WriteData (myBuffer,2); | ||
103 | } | ||
104 | */ | ||
105 | for (int i = 0; i < channels; ++i) bufferp[i] = (short)i; | ||
106 | } | ||
107 | |||
108 | public void close() | ||
109 | { | ||
110 | outWave.Close(); | ||
111 | } | ||
112 | |||
113 | /** | ||
114 | * | ||
115 | */ | ||
116 | public void clear_buffer() | ||
117 | {} | ||
118 | |||
119 | /** | ||
120 | * | ||
121 | */ | ||
122 | public void set_stop_flag() | ||
123 | {} | ||
124 | |||
125 | /* | ||
126 | * Create STDOUT buffer | ||
127 | * | ||
128 | * | ||
129 | public static Obuffer create_stdout_obuffer(MPEG_Args maplay_args) | ||
130 | { | ||
131 | Obuffer thebuffer = null; | ||
132 | int mode = maplay_args.MPEGheader.mode(); | ||
133 | int which_channels = maplay_args.which_c; | ||
134 | if (mode == Header.single_channel || which_channels != MPEG_Args.both) | ||
135 | thebuffer = new FileObuffer(1,maplay_args.output_filename); | ||
136 | else | ||
137 | thebuffer = new FileObuffer(2,maplay_args.output_filename); | ||
138 | return(thebuffer); | ||
139 | } | ||
140 | */ | ||
141 | } | ||
diff --git a/songdbj/javazoom/jl/converter/jlc.java b/songdbj/javazoom/jl/converter/jlc.java deleted file mode 100644 index 57c84eba4a..0000000000 --- a/songdbj/javazoom/jl/converter/jlc.java +++ /dev/null | |||
@@ -1,216 +0,0 @@ | |||
1 | /* | ||
2 | * 11/19/04 1.0 moved to LGPL. | ||
3 | * | ||
4 | * 29/01/00 Initial version. mdm@techie.com | ||
5 | * | ||
6 | * 12/12/99 JavaLayer 0.0.7 mdm@techie.com | ||
7 | * | ||
8 | * 14/02/99 MPEG_Args Based Class - E.B | ||
9 | * Adapted from javalayer and MPEG_Args. | ||
10 | * Doc'ed and integerated with JL converter. Removed | ||
11 | * Win32 specifics from original Maplay code. | ||
12 | *----------------------------------------------------------------------- | ||
13 | * This program is free software; you can redistribute it and/or modify | ||
14 | * it under the terms of the GNU Library General Public License as published | ||
15 | * by the Free Software Foundation; either version 2 of the License, or | ||
16 | * (at your option) any later version. | ||
17 | * | ||
18 | * This program is distributed in the hope that it will be useful, | ||
19 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
20 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
21 | * GNU Library General Public License for more details. | ||
22 | * | ||
23 | * You should have received a copy of the GNU Library General Public | ||
24 | * License along with this program; if not, write to the Free Software | ||
25 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
26 | *---------------------------------------------------------------------- | ||
27 | */ | ||
28 | |||
29 | package javazoom.jl.converter; | ||
30 | |||
31 | import java.io.PrintWriter; | ||
32 | |||
33 | import javazoom.jl.decoder.Crc16; | ||
34 | import javazoom.jl.decoder.JavaLayerException; | ||
35 | import javazoom.jl.decoder.OutputChannels; | ||
36 | |||
37 | /** | ||
38 | * The <code>jlc</code> class presents the JavaLayer | ||
39 | * Conversion functionality as a command-line program. | ||
40 | * | ||
41 | * @since 0.0.7 | ||
42 | */ | ||
43 | public class jlc | ||
44 | { | ||
45 | |||
46 | static public void main(String args[]) | ||
47 | { | ||
48 | String[] argv; | ||
49 | long start = System.currentTimeMillis(); | ||
50 | int argc = args.length + 1; | ||
51 | argv = new String[argc]; | ||
52 | argv[0] = "jlc"; | ||
53 | for(int i=0;i<args.length;i++) | ||
54 | argv[i+1] = args[i]; | ||
55 | |||
56 | jlcArgs ma = new jlcArgs(); | ||
57 | if (!ma.processArgs(argv)) | ||
58 | System.exit(1); | ||
59 | |||
60 | Converter conv = new Converter(); | ||
61 | |||
62 | int detail = (ma.verbose_mode ? | ||
63 | ma.verbose_level : | ||
64 | Converter.PrintWriterProgressListener.NO_DETAIL); | ||
65 | |||
66 | Converter.ProgressListener listener = | ||
67 | new Converter.PrintWriterProgressListener( | ||
68 | new PrintWriter(System.out, true), detail); | ||
69 | |||
70 | try | ||
71 | { | ||
72 | conv.convert(ma.filename, ma.output_filename, listener); | ||
73 | } | ||
74 | catch (JavaLayerException ex) | ||
75 | { | ||
76 | System.err.println("Convertion failure: "+ex); | ||
77 | } | ||
78 | |||
79 | System.exit(0); | ||
80 | } | ||
81 | |||
82 | |||
83 | /** | ||
84 | * Class to contain arguments for maplay. | ||
85 | */ | ||
86 | static class jlcArgs | ||
87 | { | ||
88 | // channel constants moved into OutputChannels class. | ||
89 | //public static final int both = 0; | ||
90 | //public static final int left = 1; | ||
91 | //public static final int right = 2; | ||
92 | //public static final int downmix = 3; | ||
93 | |||
94 | public int which_c; | ||
95 | public int output_mode; | ||
96 | public boolean use_own_scalefactor; | ||
97 | public float scalefactor; | ||
98 | public String output_filename; | ||
99 | public String filename; | ||
100 | //public boolean stdout_mode; | ||
101 | public boolean verbose_mode; | ||
102 | public int verbose_level = 3; | ||
103 | |||
104 | public jlcArgs() | ||
105 | { | ||
106 | which_c = OutputChannels.BOTH_CHANNELS; | ||
107 | use_own_scalefactor = false; | ||
108 | scalefactor = (float) 32768.0; | ||
109 | //stdout_mode = false; | ||
110 | verbose_mode = false; | ||
111 | } | ||
112 | |||
113 | /** | ||
114 | * Process user arguments. | ||
115 | * | ||
116 | * Returns true if successful. | ||
117 | */ | ||
118 | public boolean processArgs(String[] argv) | ||
119 | { | ||
120 | filename = null; | ||
121 | Crc16[] crc; | ||
122 | crc = new Crc16[1]; | ||
123 | int i; | ||
124 | int argc = argv.length; | ||
125 | |||
126 | //stdout_mode = false; | ||
127 | verbose_mode = false; | ||
128 | output_mode = OutputChannels.BOTH_CHANNELS; | ||
129 | output_filename = ""; | ||
130 | if (argc < 2 || argv[1].equals("-h")) | ||
131 | return Usage(); | ||
132 | |||
133 | i = 1; | ||
134 | while (i < argc) | ||
135 | { | ||
136 | /* System.out.println("Option = "+argv[i]);*/ | ||
137 | if (argv[i].charAt(0) == '-') | ||
138 | { | ||
139 | if (argv[i].startsWith("-v")) | ||
140 | { | ||
141 | verbose_mode = true; | ||
142 | if (argv[i].length()>2) | ||
143 | { | ||
144 | try | ||
145 | { | ||
146 | String level = argv[i].substring(2); | ||
147 | verbose_level = Integer.parseInt(level); | ||
148 | } | ||
149 | catch (NumberFormatException ex) | ||
150 | { | ||
151 | System.err.println("Invalid verbose level. Using default."); | ||
152 | } | ||
153 | } | ||
154 | System.out.println("Verbose Activated (level "+verbose_level+")"); | ||
155 | } | ||
156 | /* else if (argv[i].equals("-s")) | ||
157 | ma.stdout_mode = true; */ | ||
158 | else if (argv[i].equals("-p")) | ||
159 | { | ||
160 | if (++i == argc) | ||
161 | { | ||
162 | System.out.println("Please specify an output filename after the -p option!"); | ||
163 | System.exit (1); | ||
164 | } | ||
165 | //output_mode = O_WAVEFILE; | ||
166 | output_filename = argv[i]; | ||
167 | } | ||
168 | /*else if (argv[i].equals("-f")) | ||
169 | { | ||
170 | if (++i == argc) | ||
171 | { | ||
172 | System.out.println("Please specify a new scalefactor after the -f option!"); | ||
173 | System.exit(1); | ||
174 | } | ||
175 | ma.use_own_scalefactor = true; | ||
176 | // ma.scalefactor = argv[i]; | ||
177 | }*/ | ||
178 | else return Usage(); | ||
179 | } | ||
180 | else | ||
181 | { | ||
182 | filename = argv[i]; | ||
183 | System.out.println("FileName = "+argv[i]); | ||
184 | if (filename == null) return Usage(); | ||
185 | } | ||
186 | i++; | ||
187 | } | ||
188 | if (filename == null) | ||
189 | return Usage(); | ||
190 | |||
191 | return true; | ||
192 | } | ||
193 | |||
194 | |||
195 | /** | ||
196 | * Usage of JavaLayer. | ||
197 | */ | ||
198 | public boolean Usage() | ||
199 | { | ||
200 | System.out.println("JavaLayer Converter :"); | ||
201 | System.out.println(" -v[x] verbose mode. "); | ||
202 | System.out.println(" default = 2"); | ||
203 | /* System.out.println(" -s write u-law samples at 8 kHz rate to stdout"); | ||
204 | System.out.println(" -l decode only the left channel"); | ||
205 | System.out.println(" -r decode only the right channel"); | ||
206 | System.out.println(" -d downmix mode (layer III only)"); | ||
207 | System.out.println(" -s write pcm samples to stdout"); | ||
208 | System.out.println(" -d downmix mode (layer III only)");*/ | ||
209 | System.out.println(" -p name output as a PCM wave file"); | ||
210 | System.out.println(""); | ||
211 | System.out.println(" More info on http://www.javazoom.net"); | ||
212 | /* System.out.println(" -f ushort use this scalefactor instead of the default value 32768");*/ | ||
213 | return false; | ||
214 | } | ||
215 | }; | ||
216 | }; \ No newline at end of file | ||