468 lines
15 KiB
Java
468 lines
15 KiB
Java
/*
|
|
* Copyright (c) 1999, 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.DataOutputStream;
|
|
import java.io.PipedInputStream;
|
|
import java.io.PipedOutputStream;
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.SequenceInputStream;
|
|
import java.io.File;
|
|
import java.io.FileOutputStream;
|
|
import java.io.InputStream;
|
|
import java.io.IOException;
|
|
import java.io.OutputStream;
|
|
|
|
import javax.sound.midi.InvalidMidiDataException;
|
|
import javax.sound.midi.MidiEvent;
|
|
import javax.sound.midi.MetaMessage;
|
|
import javax.sound.midi.Sequence;
|
|
import javax.sound.midi.ShortMessage;
|
|
import javax.sound.midi.SysexMessage;
|
|
import javax.sound.midi.Track;
|
|
import javax.sound.midi.spi.MidiFileWriter;
|
|
|
|
|
|
/**
|
|
* MIDI file writer.
|
|
*
|
|
* @author Kara Kytle
|
|
* @author Jan Borgersen
|
|
*/
|
|
public final class StandardMidiFileWriter extends MidiFileWriter {
|
|
|
|
private static final int MThd_MAGIC = 0x4d546864; // 'MThd'
|
|
private static final int MTrk_MAGIC = 0x4d54726b; // 'MTrk'
|
|
|
|
private static final int ONE_BYTE = 1;
|
|
private static final int TWO_BYTE = 2;
|
|
private static final int SYSEX = 3;
|
|
private static final int META = 4;
|
|
private static final int ERROR = 5;
|
|
private static final int IGNORE = 6;
|
|
|
|
private static final int MIDI_TYPE_0 = 0;
|
|
private static final int MIDI_TYPE_1 = 1;
|
|
|
|
private static final int bufferSize = 16384; // buffersize for write
|
|
private DataOutputStream tddos; // data output stream for track writing
|
|
|
|
|
|
|
|
/**
|
|
* MIDI parser types
|
|
*/
|
|
private static final int types[] = {
|
|
MIDI_TYPE_0,
|
|
MIDI_TYPE_1
|
|
};
|
|
|
|
|
|
/**
|
|
* new
|
|
*/
|
|
public int[] getMidiFileTypes() {
|
|
int[] localArray = new int[types.length];
|
|
System.arraycopy(types, 0, localArray, 0, types.length);
|
|
return localArray;
|
|
}
|
|
|
|
/**
|
|
* Obtains the file types that this provider can write from the
|
|
* sequence specified.
|
|
* @param sequence the sequence for which midi file type support
|
|
* is queried
|
|
* @return array of file types. If no file types are supported,
|
|
* returns an array of length 0.
|
|
*/
|
|
public int[] getMidiFileTypes(Sequence sequence){
|
|
int typesArray[];
|
|
Track tracks[] = sequence.getTracks();
|
|
|
|
if( tracks.length==1 ) {
|
|
typesArray = new int[2];
|
|
typesArray[0] = MIDI_TYPE_0;
|
|
typesArray[1] = MIDI_TYPE_1;
|
|
} else {
|
|
typesArray = new int[1];
|
|
typesArray[0] = MIDI_TYPE_1;
|
|
}
|
|
|
|
return typesArray;
|
|
}
|
|
|
|
public boolean isFileTypeSupported(int type) {
|
|
for(int i=0; i<types.length; i++) {
|
|
if( type == types[i] ) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public int write(Sequence in, int type, OutputStream out) throws IOException {
|
|
byte [] buffer = null;
|
|
|
|
int bytesRead = 0;
|
|
long bytesWritten = 0;
|
|
|
|
if( !isFileTypeSupported(type,in) ) {
|
|
throw new IllegalArgumentException("Could not write MIDI file");
|
|
}
|
|
// First get the fileStream from this sequence
|
|
InputStream fileStream = getFileStream(type,in);
|
|
if (fileStream == null) {
|
|
throw new IllegalArgumentException("Could not write MIDI file");
|
|
}
|
|
buffer = new byte[bufferSize];
|
|
|
|
while( (bytesRead = fileStream.read( buffer )) >= 0 ) {
|
|
out.write( buffer, 0, (int)bytesRead );
|
|
bytesWritten += bytesRead;
|
|
}
|
|
// Done....return bytesWritten
|
|
return (int) bytesWritten;
|
|
}
|
|
|
|
public int write(Sequence in, int type, File out) throws IOException {
|
|
FileOutputStream fos = new FileOutputStream(out); // throws IOException
|
|
int bytesWritten = write( in, type, fos );
|
|
fos.close();
|
|
return bytesWritten;
|
|
}
|
|
|
|
//=================================================================================
|
|
|
|
|
|
private InputStream getFileStream(int type, Sequence sequence) throws IOException {
|
|
Track tracks[] = sequence.getTracks();
|
|
int bytesBuilt = 0;
|
|
int headerLength = 14;
|
|
int length = 0;
|
|
int timeFormat;
|
|
float divtype;
|
|
|
|
PipedOutputStream hpos = null;
|
|
DataOutputStream hdos = null;
|
|
PipedInputStream headerStream = null;
|
|
|
|
InputStream trackStreams [] = null;
|
|
InputStream trackStream = null;
|
|
InputStream fStream = null;
|
|
|
|
// Determine the filetype to write
|
|
if( type==MIDI_TYPE_0 ) {
|
|
if (tracks.length != 1) {
|
|
return null;
|
|
}
|
|
} else if( type==MIDI_TYPE_1 ) {
|
|
if (tracks.length < 1) { // $$jb: 05.31.99: we _can_ write TYPE_1 if tracks.length==1
|
|
return null;
|
|
}
|
|
} else {
|
|
if(tracks.length==1) {
|
|
type = MIDI_TYPE_0;
|
|
} else if(tracks.length>1) {
|
|
type = MIDI_TYPE_1;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Now build the file one track at a time
|
|
// Note that above we made sure that MIDI_TYPE_0 only happens
|
|
// if tracks.length==1
|
|
|
|
trackStreams = new InputStream[tracks.length];
|
|
int trackCount = 0;
|
|
for(int i=0; i<tracks.length; i++) {
|
|
try {
|
|
trackStreams[trackCount] = writeTrack( tracks[i], type );
|
|
trackCount++;
|
|
} catch (InvalidMidiDataException e) {
|
|
if(Printer.err) Printer.err("Exception in write: " + e.getMessage());
|
|
}
|
|
//bytesBuilt += trackStreams[i].getLength();
|
|
}
|
|
|
|
// Now seqence the track streams
|
|
if( trackCount == 1 ) {
|
|
trackStream = trackStreams[0];
|
|
} else if( trackCount > 1 ){
|
|
trackStream = trackStreams[0];
|
|
for(int i=1; i<tracks.length; i++) {
|
|
// fix for 5048381: NullPointerException when saving a MIDI sequence
|
|
// don't include failed track streams
|
|
if (trackStreams[i] != null) {
|
|
trackStream = new SequenceInputStream( trackStream, trackStreams[i]);
|
|
}
|
|
}
|
|
} else {
|
|
throw new IllegalArgumentException("invalid MIDI data in sequence");
|
|
}
|
|
|
|
// Now build the header...
|
|
hpos = new PipedOutputStream();
|
|
hdos = new DataOutputStream(hpos);
|
|
headerStream = new PipedInputStream(hpos);
|
|
|
|
// Write the magic number
|
|
hdos.writeInt( MThd_MAGIC );
|
|
|
|
// Write the header length
|
|
hdos.writeInt( headerLength - 8 );
|
|
|
|
// Write the filetype
|
|
if(type==MIDI_TYPE_0) {
|
|
hdos.writeShort( 0 );
|
|
} else {
|
|
// MIDI_TYPE_1
|
|
hdos.writeShort( 1 );
|
|
}
|
|
|
|
// Write the number of tracks
|
|
hdos.writeShort( (short) trackCount );
|
|
|
|
// Determine and write the timing format
|
|
divtype = sequence.getDivisionType();
|
|
if( divtype == Sequence.PPQ ) {
|
|
timeFormat = sequence.getResolution();
|
|
} else if( divtype == Sequence.SMPTE_24) {
|
|
timeFormat = (24<<8) * -1;
|
|
timeFormat += (sequence.getResolution() & 0xFF);
|
|
} else if( divtype == Sequence.SMPTE_25) {
|
|
timeFormat = (25<<8) * -1;
|
|
timeFormat += (sequence.getResolution() & 0xFF);
|
|
} else if( divtype == Sequence.SMPTE_30DROP) {
|
|
timeFormat = (29<<8) * -1;
|
|
timeFormat += (sequence.getResolution() & 0xFF);
|
|
} else if( divtype == Sequence.SMPTE_30) {
|
|
timeFormat = (30<<8) * -1;
|
|
timeFormat += (sequence.getResolution() & 0xFF);
|
|
} else {
|
|
// $$jb: 04.08.99: What to really do here?
|
|
return null;
|
|
}
|
|
hdos.writeShort( timeFormat );
|
|
|
|
// now construct an InputStream to become the FileStream
|
|
fStream = new SequenceInputStream(headerStream, trackStream);
|
|
hdos.close();
|
|
|
|
length = bytesBuilt + headerLength;
|
|
return fStream;
|
|
}
|
|
|
|
/**
|
|
* Returns ONE_BYTE, TWO_BYTE, SYSEX, META,
|
|
* ERROR, or IGNORE (i.e. invalid for a MIDI file)
|
|
*/
|
|
private int getType(int byteValue) {
|
|
if ((byteValue & 0xF0) == 0xF0) {
|
|
switch(byteValue) {
|
|
case 0xF0:
|
|
case 0xF7:
|
|
return SYSEX;
|
|
case 0xFF:
|
|
return META;
|
|
}
|
|
return IGNORE;
|
|
}
|
|
|
|
switch(byteValue & 0xF0) {
|
|
case 0x80:
|
|
case 0x90:
|
|
case 0xA0:
|
|
case 0xB0:
|
|
case 0xE0:
|
|
return TWO_BYTE;
|
|
case 0xC0:
|
|
case 0xD0:
|
|
return ONE_BYTE;
|
|
}
|
|
return ERROR;
|
|
}
|
|
|
|
private final static long mask = 0x7F;
|
|
|
|
private int writeVarInt(long value) throws IOException {
|
|
int len = 1;
|
|
int shift=63; // number of bitwise left-shifts of mask
|
|
// first screen out leading zeros
|
|
while ((shift > 0) && ((value & (mask << shift)) == 0)) shift-=7;
|
|
// then write actual values
|
|
while (shift > 0) {
|
|
tddos.writeByte((int) (((value & (mask << shift)) >> shift) | 0x80));
|
|
shift-=7;
|
|
len++;
|
|
}
|
|
tddos.writeByte((int) (value & mask));
|
|
return len;
|
|
}
|
|
|
|
private InputStream writeTrack( Track track, int type ) throws IOException, InvalidMidiDataException {
|
|
int bytesWritten = 0;
|
|
int lastBytesWritten = 0;
|
|
int size = track.size();
|
|
PipedOutputStream thpos = new PipedOutputStream();
|
|
DataOutputStream thdos = new DataOutputStream(thpos);
|
|
PipedInputStream thpis = new PipedInputStream(thpos);
|
|
|
|
ByteArrayOutputStream tdbos = new ByteArrayOutputStream();
|
|
tddos = new DataOutputStream(tdbos);
|
|
ByteArrayInputStream tdbis = null;
|
|
|
|
SequenceInputStream fStream = null;
|
|
|
|
long currentTick = 0;
|
|
long deltaTick = 0;
|
|
long eventTick = 0;
|
|
int runningStatus = -1;
|
|
|
|
// -----------------------------
|
|
// Write each event in the track
|
|
// -----------------------------
|
|
for(int i=0; i<size; i++) {
|
|
MidiEvent event = track.get(i);
|
|
|
|
int status;
|
|
int eventtype;
|
|
int metatype;
|
|
int data1, data2;
|
|
int length;
|
|
byte data[] = null;
|
|
ShortMessage shortMessage = null;
|
|
MetaMessage metaMessage = null;
|
|
SysexMessage sysexMessage = null;
|
|
|
|
// get the tick
|
|
// $$jb: this gets easier if we change all system-wide time to delta ticks
|
|
eventTick = event.getTick();
|
|
deltaTick = event.getTick() - currentTick;
|
|
currentTick = event.getTick();
|
|
|
|
// get the status byte
|
|
status = event.getMessage().getStatus();
|
|
eventtype = getType( status );
|
|
|
|
switch( eventtype ) {
|
|
case ONE_BYTE:
|
|
shortMessage = (ShortMessage) event.getMessage();
|
|
data1 = shortMessage.getData1();
|
|
bytesWritten += writeVarInt( deltaTick );
|
|
|
|
if(status!=runningStatus) {
|
|
runningStatus=status;
|
|
tddos.writeByte(status); bytesWritten += 1;
|
|
}
|
|
tddos.writeByte(data1); bytesWritten += 1;
|
|
break;
|
|
|
|
case TWO_BYTE:
|
|
shortMessage = (ShortMessage) event.getMessage();
|
|
data1 = shortMessage.getData1();
|
|
data2 = shortMessage.getData2();
|
|
|
|
bytesWritten += writeVarInt( deltaTick );
|
|
if(status!=runningStatus) {
|
|
runningStatus=status;
|
|
tddos.writeByte(status); bytesWritten += 1;
|
|
}
|
|
tddos.writeByte(data1); bytesWritten += 1;
|
|
tddos.writeByte(data2); bytesWritten += 1;
|
|
break;
|
|
|
|
case SYSEX:
|
|
sysexMessage = (SysexMessage) event.getMessage();
|
|
length = sysexMessage.getLength();
|
|
data = sysexMessage.getMessage();
|
|
bytesWritten += writeVarInt( deltaTick );
|
|
|
|
// $$jb: 04.08.99: always write status for sysex
|
|
runningStatus=status;
|
|
tddos.writeByte( data[0] ); bytesWritten += 1;
|
|
|
|
// $$jb: 10.18.99: we don't maintain length in
|
|
// the message data for SysEx (it is not transmitted
|
|
// over the line), so write the calculated length
|
|
// minus the status byte
|
|
bytesWritten += writeVarInt( (data.length-1) );
|
|
|
|
// $$jb: 10.18.99: now write the rest of the
|
|
// message
|
|
tddos.write(data, 1, (data.length-1));
|
|
bytesWritten += (data.length-1);
|
|
break;
|
|
|
|
case META:
|
|
metaMessage = (MetaMessage) event.getMessage();
|
|
length = metaMessage.getLength();
|
|
data = metaMessage.getMessage();
|
|
bytesWritten += writeVarInt( deltaTick );
|
|
|
|
// $$jb: 10.18.99: getMessage() returns the
|
|
// entire valid midi message for a file,
|
|
// including the status byte and the var-length-int
|
|
// length value, so we can just write the data
|
|
// here. note that we must _always_ write the
|
|
// status byte, regardless of runningStatus.
|
|
runningStatus=status;
|
|
tddos.write( data, 0, data.length );
|
|
bytesWritten += data.length;
|
|
break;
|
|
|
|
case IGNORE:
|
|
// ignore this event
|
|
break;
|
|
|
|
case ERROR:
|
|
// ignore this event
|
|
break;
|
|
|
|
default:
|
|
throw new InvalidMidiDataException("internal file writer error");
|
|
}
|
|
}
|
|
// ---------------------------------
|
|
// End write each event in the track
|
|
// ---------------------------------
|
|
|
|
// Build Track header now that we know length
|
|
thdos.writeInt(MTrk_MAGIC);
|
|
thdos.writeInt(bytesWritten);
|
|
bytesWritten += 8;
|
|
|
|
// Now sequence them
|
|
tdbis = new ByteArrayInputStream( tdbos.toByteArray() );
|
|
fStream = new SequenceInputStream(thpis,tdbis);
|
|
thdos.close();
|
|
tddos.close();
|
|
|
|
return fStream;
|
|
}
|
|
}
|