366 lines
11 KiB
Java
366 lines
11 KiB
Java
/*
|
|
* Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
package com.sun.media.sound;
|
|
|
|
import java.io.File;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.IOException;
|
|
import java.io.OutputStream;
|
|
import java.io.RandomAccessFile;
|
|
|
|
/**
|
|
* Resource Interchange File Format (RIFF) stream encoder.
|
|
*
|
|
* @author Karl Helgason
|
|
*/
|
|
public final class RIFFWriter extends OutputStream {
|
|
|
|
private interface RandomAccessWriter {
|
|
|
|
public void seek(long chunksizepointer) throws IOException;
|
|
|
|
public long getPointer() throws IOException;
|
|
|
|
public void close() throws IOException;
|
|
|
|
public void write(int b) throws IOException;
|
|
|
|
public void write(byte[] b, int off, int len) throws IOException;
|
|
|
|
public void write(byte[] bytes) throws IOException;
|
|
|
|
public long length() throws IOException;
|
|
|
|
public void setLength(long i) throws IOException;
|
|
}
|
|
|
|
private static class RandomAccessFileWriter implements RandomAccessWriter {
|
|
|
|
RandomAccessFile raf;
|
|
|
|
RandomAccessFileWriter(File file) throws FileNotFoundException {
|
|
this.raf = new RandomAccessFile(file, "rw");
|
|
}
|
|
|
|
RandomAccessFileWriter(String name) throws FileNotFoundException {
|
|
this.raf = new RandomAccessFile(name, "rw");
|
|
}
|
|
|
|
public void seek(long chunksizepointer) throws IOException {
|
|
raf.seek(chunksizepointer);
|
|
}
|
|
|
|
public long getPointer() throws IOException {
|
|
return raf.getFilePointer();
|
|
}
|
|
|
|
public void close() throws IOException {
|
|
raf.close();
|
|
}
|
|
|
|
public void write(int b) throws IOException {
|
|
raf.write(b);
|
|
}
|
|
|
|
public void write(byte[] b, int off, int len) throws IOException {
|
|
raf.write(b, off, len);
|
|
}
|
|
|
|
public void write(byte[] bytes) throws IOException {
|
|
raf.write(bytes);
|
|
}
|
|
|
|
public long length() throws IOException {
|
|
return raf.length();
|
|
}
|
|
|
|
public void setLength(long i) throws IOException {
|
|
raf.setLength(i);
|
|
}
|
|
}
|
|
|
|
private static class RandomAccessByteWriter implements RandomAccessWriter {
|
|
|
|
byte[] buff = new byte[32];
|
|
int length = 0;
|
|
int pos = 0;
|
|
byte[] s;
|
|
final OutputStream stream;
|
|
|
|
RandomAccessByteWriter(OutputStream stream) {
|
|
this.stream = stream;
|
|
}
|
|
|
|
public void seek(long chunksizepointer) throws IOException {
|
|
pos = (int) chunksizepointer;
|
|
}
|
|
|
|
public long getPointer() throws IOException {
|
|
return pos;
|
|
}
|
|
|
|
public void close() throws IOException {
|
|
stream.write(buff, 0, length);
|
|
stream.close();
|
|
}
|
|
|
|
public void write(int b) throws IOException {
|
|
if (s == null)
|
|
s = new byte[1];
|
|
s[0] = (byte)b;
|
|
write(s, 0, 1);
|
|
}
|
|
|
|
public void write(byte[] b, int off, int len) throws IOException {
|
|
int newsize = pos + len;
|
|
if (newsize > length)
|
|
setLength(newsize);
|
|
int end = off + len;
|
|
for (int i = off; i < end; i++) {
|
|
buff[pos++] = b[i];
|
|
}
|
|
}
|
|
|
|
public void write(byte[] bytes) throws IOException {
|
|
write(bytes, 0, bytes.length);
|
|
}
|
|
|
|
public long length() throws IOException {
|
|
return length;
|
|
}
|
|
|
|
public void setLength(long i) throws IOException {
|
|
length = (int) i;
|
|
if (length > buff.length) {
|
|
int newlen = Math.max(buff.length << 1, length);
|
|
byte[] newbuff = new byte[newlen];
|
|
System.arraycopy(buff, 0, newbuff, 0, buff.length);
|
|
buff = newbuff;
|
|
}
|
|
}
|
|
}
|
|
private int chunktype = 0; // 0=RIFF, 1=LIST; 2=CHUNK
|
|
private RandomAccessWriter raf;
|
|
private final long chunksizepointer;
|
|
private final long startpointer;
|
|
private RIFFWriter childchunk = null;
|
|
private boolean open = true;
|
|
private boolean writeoverride = false;
|
|
|
|
public RIFFWriter(String name, String format) throws IOException {
|
|
this(new RandomAccessFileWriter(name), format, 0);
|
|
}
|
|
|
|
public RIFFWriter(File file, String format) throws IOException {
|
|
this(new RandomAccessFileWriter(file), format, 0);
|
|
}
|
|
|
|
public RIFFWriter(OutputStream stream, String format) throws IOException {
|
|
this(new RandomAccessByteWriter(stream), format, 0);
|
|
}
|
|
|
|
private RIFFWriter(RandomAccessWriter raf, String format, int chunktype)
|
|
throws IOException {
|
|
if (chunktype == 0)
|
|
if (raf.length() != 0)
|
|
raf.setLength(0);
|
|
this.raf = raf;
|
|
if (raf.getPointer() % 2 != 0)
|
|
raf.write(0);
|
|
|
|
if (chunktype == 0)
|
|
raf.write("RIFF".getBytes("ascii"));
|
|
else if (chunktype == 1)
|
|
raf.write("LIST".getBytes("ascii"));
|
|
else
|
|
raf.write((format + " ").substring(0, 4).getBytes("ascii"));
|
|
|
|
chunksizepointer = raf.getPointer();
|
|
this.chunktype = 2;
|
|
writeUnsignedInt(0);
|
|
this.chunktype = chunktype;
|
|
startpointer = raf.getPointer();
|
|
if (chunktype != 2)
|
|
raf.write((format + " ").substring(0, 4).getBytes("ascii"));
|
|
|
|
}
|
|
|
|
public void seek(long pos) throws IOException {
|
|
raf.seek(pos);
|
|
}
|
|
|
|
public long getFilePointer() throws IOException {
|
|
return raf.getPointer();
|
|
}
|
|
|
|
public void setWriteOverride(boolean writeoverride) {
|
|
this.writeoverride = writeoverride;
|
|
}
|
|
|
|
public boolean getWriteOverride() {
|
|
return writeoverride;
|
|
}
|
|
|
|
public void close() throws IOException {
|
|
if (!open)
|
|
return;
|
|
if (childchunk != null) {
|
|
childchunk.close();
|
|
childchunk = null;
|
|
}
|
|
|
|
int bakchunktype = chunktype;
|
|
long fpointer = raf.getPointer();
|
|
raf.seek(chunksizepointer);
|
|
chunktype = 2;
|
|
writeUnsignedInt(fpointer - startpointer);
|
|
|
|
if (bakchunktype == 0)
|
|
raf.close();
|
|
else
|
|
raf.seek(fpointer);
|
|
open = false;
|
|
raf = null;
|
|
}
|
|
|
|
public void write(int b) throws IOException {
|
|
if (!writeoverride) {
|
|
if (chunktype != 2) {
|
|
throw new IllegalArgumentException(
|
|
"Only chunks can write bytes!");
|
|
}
|
|
if (childchunk != null) {
|
|
childchunk.close();
|
|
childchunk = null;
|
|
}
|
|
}
|
|
raf.write(b);
|
|
}
|
|
|
|
public void write(byte b[], int off, int len) throws IOException {
|
|
if (!writeoverride) {
|
|
if (chunktype != 2) {
|
|
throw new IllegalArgumentException(
|
|
"Only chunks can write bytes!");
|
|
}
|
|
if (childchunk != null) {
|
|
childchunk.close();
|
|
childchunk = null;
|
|
}
|
|
}
|
|
raf.write(b, off, len);
|
|
}
|
|
|
|
public RIFFWriter writeList(String format) throws IOException {
|
|
if (chunktype == 2) {
|
|
throw new IllegalArgumentException(
|
|
"Only LIST and RIFF can write lists!");
|
|
}
|
|
if (childchunk != null) {
|
|
childchunk.close();
|
|
childchunk = null;
|
|
}
|
|
childchunk = new RIFFWriter(this.raf, format, 1);
|
|
return childchunk;
|
|
}
|
|
|
|
public RIFFWriter writeChunk(String format) throws IOException {
|
|
if (chunktype == 2) {
|
|
throw new IllegalArgumentException(
|
|
"Only LIST and RIFF can write chunks!");
|
|
}
|
|
if (childchunk != null) {
|
|
childchunk.close();
|
|
childchunk = null;
|
|
}
|
|
childchunk = new RIFFWriter(this.raf, format, 2);
|
|
return childchunk;
|
|
}
|
|
|
|
// Write ASCII chars to stream
|
|
public void writeString(String string) throws IOException {
|
|
byte[] buff = string.getBytes();
|
|
write(buff);
|
|
}
|
|
|
|
// Write ASCII chars to stream
|
|
public void writeString(String string, int len) throws IOException {
|
|
byte[] buff = string.getBytes();
|
|
if (buff.length > len)
|
|
write(buff, 0, len);
|
|
else {
|
|
write(buff);
|
|
for (int i = buff.length; i < len; i++)
|
|
write(0);
|
|
}
|
|
}
|
|
|
|
// Write 8 bit signed integer to stream
|
|
public void writeByte(int b) throws IOException {
|
|
write(b);
|
|
}
|
|
|
|
// Write 16 bit signed integer to stream
|
|
public void writeShort(short b) throws IOException {
|
|
write((b >>> 0) & 0xFF);
|
|
write((b >>> 8) & 0xFF);
|
|
}
|
|
|
|
// Write 32 bit signed integer to stream
|
|
public void writeInt(int b) throws IOException {
|
|
write((b >>> 0) & 0xFF);
|
|
write((b >>> 8) & 0xFF);
|
|
write((b >>> 16) & 0xFF);
|
|
write((b >>> 24) & 0xFF);
|
|
}
|
|
|
|
// Write 64 bit signed integer to stream
|
|
public void writeLong(long b) throws IOException {
|
|
write((int) (b >>> 0) & 0xFF);
|
|
write((int) (b >>> 8) & 0xFF);
|
|
write((int) (b >>> 16) & 0xFF);
|
|
write((int) (b >>> 24) & 0xFF);
|
|
write((int) (b >>> 32) & 0xFF);
|
|
write((int) (b >>> 40) & 0xFF);
|
|
write((int) (b >>> 48) & 0xFF);
|
|
write((int) (b >>> 56) & 0xFF);
|
|
}
|
|
|
|
// Write 8 bit unsigned integer to stream
|
|
public void writeUnsignedByte(int b) throws IOException {
|
|
writeByte((byte) b);
|
|
}
|
|
|
|
// Write 16 bit unsigned integer to stream
|
|
public void writeUnsignedShort(int b) throws IOException {
|
|
writeShort((short) b);
|
|
}
|
|
|
|
// Write 32 bit unsigned integer to stream
|
|
public void writeUnsignedInt(long b) throws IOException {
|
|
writeInt((int) b);
|
|
}
|
|
}
|