/*
* Copyright (c) 2007, 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 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;
public RandomAccessFileWriter(File file) throws FileNotFoundException {
this.raf = new RandomAccessFile(file, "rw");
}
public 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;
OutputStream stream;
public 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 long chunksizepointer;
private 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);
}
}