javax.sound.midi.spi.MidiFileReader Java Examples

/**
 * Obtains the MIDI file format of the data in the specified URL. The URL
 * must point to valid MIDI file data for a file type recognized by the
 * system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader. It may fail with an
 * {@code InvalidMidiDataException} even for valid files if no compatible
 * file reader is installed. It will also fail with an
 * {@code InvalidMidiDataException} if a compatible file reader is
 * installed, but encounters errors while determining the file format.
 *
 * @param  url the URL from which file format information should be
 *         extracted
 * @return a {@code MidiFileFormat} object describing the MIDI file format
 * @throws InvalidMidiDataException if the URL does not point to valid MIDI
 *         file data recognized by the system
 * @throws IOException if an I/O exception occurs while accessing the URL
 * @throws NullPointerException if {@code url} is {@code null}
 * @see #getMidiFileFormat(InputStream)
 * @see #getMidiFileFormat(File)
 */
public static MidiFileFormat getMidiFileFormat(final URL url)
        throws InvalidMidiDataException, IOException {
    Objects.requireNonNull(url);

    List<MidiFileReader> providers = getMidiFileReaders();
    MidiFileFormat format = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = providers.get(i);
        try {
            format = reader.getMidiFileFormat( url ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( format==null ) {
        throw new InvalidMidiDataException("url is not a supported file type");
    } else {
        return format;
    }
}
 

/**
 * Obtains a MIDI sequence from the specified URL.  The URL must
 * point to valid MIDI file data for a file type recognized
 * by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader.  It may fail with an InvalidMidiDataException
 * even for valid files if no compatible file reader is installed.  It
 * will also fail with an InvalidMidiDataException if a compatible file reader
 * is installed, but encounters errors while constructing the <code>Sequence</code>
 * object from the file data.
 *
 * @param url the URL from which the <code>Sequence</code> should be
 * constructed
 * @return a <code>Sequence</code> object based on the MIDI file data
 * pointed to by the URL
 * @throws InvalidMidiDataException if the URL does not point to valid MIDI
 * file data recognized by the system
 * @throws IOException if an I/O exception occurs while accessing the URL
 */
public static Sequence getSequence(URL url)
    throws InvalidMidiDataException, IOException {

    List providers = getMidiFileReaders();
    Sequence sequence = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = (MidiFileReader) providers.get(i);
        try {
            sequence = reader.getSequence( url ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( sequence==null ) {
        throw new InvalidMidiDataException("could not get sequence from URL");
    } else {
        return sequence;
    }
}
 

/**
 * Obtains the MIDI file format of the data in the specified URL.  The URL
 * must point to valid MIDI file data for a file type recognized
 * by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader.  It may fail with an InvalidMidiDataException
 * even for valid files if no compatible file reader is installed.  It
 * will also fail with an InvalidMidiDataException if a compatible file reader
 * is installed, but encounters errors while determining the file format.
 *
 * @param url the URL from which file format information should be
 * extracted
 * @return a <code>MidiFileFormat</code> object describing the MIDI file
 * format
 * @throws InvalidMidiDataException if the URL does not point to valid MIDI
 * file data recognized by the system
 * @throws IOException if an I/O exception occurs while accessing the URL
 *
 * @see #getMidiFileFormat(InputStream)
 * @see #getMidiFileFormat(File)
 */
public static MidiFileFormat getMidiFileFormat(URL url)
    throws InvalidMidiDataException, IOException {

    List providers = getMidiFileReaders();
    MidiFileFormat format = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = (MidiFileReader) providers.get(i);
        try {
            format = reader.getMidiFileFormat( url ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( format==null ) {
        throw new InvalidMidiDataException("url is not a supported file type");
    } else {
        return format;
    }
}
 

/**
 * Obtains a MIDI sequence from the specified URL.  The URL must
 * point to valid MIDI file data for a file type recognized
 * by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader.  It may fail with an InvalidMidiDataException
 * even for valid files if no compatible file reader is installed.  It
 * will also fail with an InvalidMidiDataException if a compatible file reader
 * is installed, but encounters errors while constructing the <code>Sequence</code>
 * object from the file data.
 *
 * @param url the URL from which the <code>Sequence</code> should be
 * constructed
 * @return a <code>Sequence</code> object based on the MIDI file data
 * pointed to by the URL
 * @throws InvalidMidiDataException if the URL does not point to valid MIDI
 * file data recognized by the system
 * @throws IOException if an I/O exception occurs while accessing the URL
 */
public static Sequence getSequence(URL url)
    throws InvalidMidiDataException, IOException {

    List providers = getMidiFileReaders();
    Sequence sequence = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = (MidiFileReader) providers.get(i);
        try {
            sequence = reader.getSequence( url ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( sequence==null ) {
        throw new InvalidMidiDataException("could not get sequence from URL");
    } else {
        return sequence;
    }
}
 

/**
 * Obtains a MIDI sequence from the specified <code>File</code>.
 * The <code>File</code> must point to valid MIDI file data
 * for a file type recognized by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader.  It may fail with an InvalidMidiDataException
 * even for valid files if no compatible file reader is installed.  It
 * will also fail with an InvalidMidiDataException if a compatible file reader
 * is installed, but encounters errors while constructing the <code>Sequence</code>
 * object from the file data.
 *
 * @param file the <code>File</code> from which the <code>Sequence</code>
 * should be constructed
 * @return a <code>Sequence</code> object based on the MIDI file data
 * pointed to by the File
 * @throws InvalidMidiDataException if the File does not point to valid MIDI
 * file data recognized by the system
 * @throws IOException if an I/O exception occurs
 */
public static Sequence getSequence(File file)
    throws InvalidMidiDataException, IOException {

    List providers = getMidiFileReaders();
    Sequence sequence = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = (MidiFileReader) providers.get(i);
        try {
            sequence = reader.getSequence( file ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( sequence==null ) {
        throw new InvalidMidiDataException("could not get sequence from file");
    } else {
        return sequence;
    }
}
 

/**
 * Obtains a List containing installed instances of the providers for the
 * requested service. The returned List is immutable.
 *
 * @param serviceClass The type of providers requested. This should be one
 *                     of AudioFileReader.class, AudioFileWriter.class,
 *                     FormatConversionProvider.class, MixerProvider.class,
 *                     MidiDeviceProvider.class, MidiFileReader.class,
 *                     MidiFileWriter.class or SoundbankReader.class.
 *
 * @return A List of providers of the requested type. This List is
 *         immutable.
 */
public static List<?> getProviders(final Class<?> serviceClass) {
    final List<?> providers;
    if (!MixerProvider.class.equals(serviceClass)
            && !FormatConversionProvider.class.equals(serviceClass)
            && !AudioFileReader.class.equals(serviceClass)
            && !AudioFileWriter.class.equals(serviceClass)
            && !MidiDeviceProvider.class.equals(serviceClass)
            && !SoundbankReader.class.equals(serviceClass)
            && !MidiFileWriter.class.equals(serviceClass)
            && !MidiFileReader.class.equals(serviceClass)) {
        providers = new ArrayList<>(0);
    } else {
        providers = JSSecurityManager.getProviders(serviceClass);
    }
    return Collections.unmodifiableList(providers);
}
 

/**
 * Obtains a List containing installed instances of the providers for the
 * requested service. The returned List is immutable.
 *
 * @param serviceClass The type of providers requested. This should be one
 *                     of AudioFileReader.class, AudioFileWriter.class,
 *                     FormatConversionProvider.class, MixerProvider.class,
 *                     MidiDeviceProvider.class, MidiFileReader.class,
 *                     MidiFileWriter.class or SoundbankReader.class.
 *
 * @return A List of providers of the requested type. This List is
 *         immutable.
 */
public static List<?> getProviders(final Class<?> serviceClass) {
    final List<?> providers;
    if (!MixerProvider.class.equals(serviceClass)
            && !FormatConversionProvider.class.equals(serviceClass)
            && !AudioFileReader.class.equals(serviceClass)
            && !AudioFileWriter.class.equals(serviceClass)
            && !MidiDeviceProvider.class.equals(serviceClass)
            && !SoundbankReader.class.equals(serviceClass)
            && !MidiFileWriter.class.equals(serviceClass)
            && !MidiFileReader.class.equals(serviceClass)) {
        providers = new ArrayList<>(0);
    } else {
        providers = JSSecurityManager.getProviders(serviceClass);
    }
    return Collections.unmodifiableList(providers);
}
 

/**
 * Obtains the MIDI file format of the specified <code>File</code>.  The
 * <code>File</code> must point to valid MIDI file data for a file type
 * recognized by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader.  It may fail with an InvalidMidiDataException
 * even for valid files if no compatible file reader is installed.  It
 * will also fail with an InvalidMidiDataException if a compatible file reader
 * is installed, but encounters errors while determining the file format.
 *
 * @param file the <code>File</code> from which file format information
 * should be extracted
 * @return a <code>MidiFileFormat</code> object describing the MIDI file
 * format
 * @throws InvalidMidiDataException if the <code>File</code> does not point
 *  to valid MIDI file data recognized by the system
 * @throws IOException if an I/O exception occurs while accessing the file
 *
 * @see #getMidiFileFormat(InputStream)
 * @see #getMidiFileFormat(URL)
 */
public static MidiFileFormat getMidiFileFormat(File file)
    throws InvalidMidiDataException, IOException {

    List providers = getMidiFileReaders();
    MidiFileFormat format = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = (MidiFileReader) providers.get(i);
        try {
            format = reader.getMidiFileFormat( file ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( format==null ) {
        throw new InvalidMidiDataException("file is not a supported file type");
    } else {
        return format;
    }
}
 

/**
 * Obtains a MIDI sequence from the specified URL.  The URL must
 * point to valid MIDI file data for a file type recognized
 * by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader.  It may fail with an InvalidMidiDataException
 * even for valid files if no compatible file reader is installed.  It
 * will also fail with an InvalidMidiDataException if a compatible file reader
 * is installed, but encounters errors while constructing the <code>Sequence</code>
 * object from the file data.
 *
 * @param url the URL from which the <code>Sequence</code> should be
 * constructed
 * @return a <code>Sequence</code> object based on the MIDI file data
 * pointed to by the URL
 * @throws InvalidMidiDataException if the URL does not point to valid MIDI
 * file data recognized by the system
 * @throws IOException if an I/O exception occurs while accessing the URL
 */
public static Sequence getSequence(URL url)
    throws InvalidMidiDataException, IOException {

    List providers = getMidiFileReaders();
    Sequence sequence = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = (MidiFileReader) providers.get(i);
        try {
            sequence = reader.getSequence( url ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( sequence==null ) {
        throw new InvalidMidiDataException("could not get sequence from URL");
    } else {
        return sequence;
    }
}
 

/**
 * Obtains a List containing installed instances of the providers for the
 * requested service. The returned List is immutable.
 *
 * @param serviceClass The type of providers requested. This should be one
 *                     of AudioFileReader.class, AudioFileWriter.class,
 *                     FormatConversionProvider.class, MixerProvider.class,
 *                     MidiDeviceProvider.class, MidiFileReader.class,
 *                     MidiFileWriter.class or SoundbankReader.class.
 *
 * @return A List of providers of the requested type. This List is
 *         immutable.
 */
public static List<?> getProviders(final Class<?> serviceClass) {
    final List<?> providers;
    if (!MixerProvider.class.equals(serviceClass)
            && !FormatConversionProvider.class.equals(serviceClass)
            && !AudioFileReader.class.equals(serviceClass)
            && !AudioFileWriter.class.equals(serviceClass)
            && !MidiDeviceProvider.class.equals(serviceClass)
            && !SoundbankReader.class.equals(serviceClass)
            && !MidiFileWriter.class.equals(serviceClass)
            && !MidiFileReader.class.equals(serviceClass)) {
        providers = new ArrayList<>(0);
    } else {
        providers = JSSecurityManager.getProviders(serviceClass);
    }
    return Collections.unmodifiableList(providers);
}
 

/**
 * Obtains a List containing installed instances of the providers for the
 * requested service. The returned List is immutable.
 *
 * @param serviceClass The type of providers requested. This should be one
 *                     of AudioFileReader.class, AudioFileWriter.class,
 *                     FormatConversionProvider.class, MixerProvider.class,
 *                     MidiDeviceProvider.class, MidiFileReader.class,
 *                     MidiFileWriter.class or SoundbankReader.class.
 *
 * @return A List of providers of the requested type. This List is
 *         immutable.
 */
public static List<?> getProviders(final Class<?> serviceClass) {
    final List<?> providers;
    if (!MixerProvider.class.equals(serviceClass)
            && !FormatConversionProvider.class.equals(serviceClass)
            && !AudioFileReader.class.equals(serviceClass)
            && !AudioFileWriter.class.equals(serviceClass)
            && !MidiDeviceProvider.class.equals(serviceClass)
            && !SoundbankReader.class.equals(serviceClass)
            && !MidiFileWriter.class.equals(serviceClass)
            && !MidiFileReader.class.equals(serviceClass)) {
        providers = new ArrayList<>(0);
    } else {
        providers = JSSecurityManager.getProviders(serviceClass);
    }
    return Collections.unmodifiableList(providers);
}
 

/**
 * Obtains the MIDI file format of the specified <code>File</code>.  The
 * <code>File</code> must point to valid MIDI file data for a file type
 * recognized by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader.  It may fail with an InvalidMidiDataException
 * even for valid files if no compatible file reader is installed.  It
 * will also fail with an InvalidMidiDataException if a compatible file reader
 * is installed, but encounters errors while determining the file format.
 *
 * @param file the <code>File</code> from which file format information
 * should be extracted
 * @return a <code>MidiFileFormat</code> object describing the MIDI file
 * format
 * @throws InvalidMidiDataException if the <code>File</code> does not point
 *  to valid MIDI file data recognized by the system
 * @throws IOException if an I/O exception occurs while accessing the file
 *
 * @see #getMidiFileFormat(InputStream)
 * @see #getMidiFileFormat(URL)
 */
public static MidiFileFormat getMidiFileFormat(File file)
    throws InvalidMidiDataException, IOException {

    List providers = getMidiFileReaders();
    MidiFileFormat format = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = (MidiFileReader) providers.get(i);
        try {
            format = reader.getMidiFileFormat( file ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( format==null ) {
        throw new InvalidMidiDataException("file is not a supported file type");
    } else {
        return format;
    }
}
 

/**
 * Obtains a MIDI sequence from the specified URL.  The URL must
 * point to valid MIDI file data for a file type recognized
 * by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader.  It may fail with an InvalidMidiDataException
 * even for valid files if no compatible file reader is installed.  It
 * will also fail with an InvalidMidiDataException if a compatible file reader
 * is installed, but encounters errors while constructing the <code>Sequence</code>
 * object from the file data.
 *
 * @param url the URL from which the <code>Sequence</code> should be
 * constructed
 * @return a <code>Sequence</code> object based on the MIDI file data
 * pointed to by the URL
 * @throws InvalidMidiDataException if the URL does not point to valid MIDI
 * file data recognized by the system
 * @throws IOException if an I/O exception occurs while accessing the URL
 */
public static Sequence getSequence(URL url)
    throws InvalidMidiDataException, IOException {

    List providers = getMidiFileReaders();
    Sequence sequence = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = (MidiFileReader) providers.get(i);
        try {
            sequence = reader.getSequence( url ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( sequence==null ) {
        throw new InvalidMidiDataException("could not get sequence from URL");
    } else {
        return sequence;
    }
}
 

/**
 * Obtains a MIDI sequence from the specified URL.  The URL must
 * point to valid MIDI file data for a file type recognized
 * by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader.  It may fail with an InvalidMidiDataException
 * even for valid files if no compatible file reader is installed.  It
 * will also fail with an InvalidMidiDataException if a compatible file reader
 * is installed, but encounters errors while constructing the <code>Sequence</code>
 * object from the file data.
 *
 * @param url the URL from which the <code>Sequence</code> should be
 * constructed
 * @return a <code>Sequence</code> object based on the MIDI file data
 * pointed to by the URL
 * @throws InvalidMidiDataException if the URL does not point to valid MIDI
 * file data recognized by the system
 * @throws IOException if an I/O exception occurs while accessing the URL
 */
public static Sequence getSequence(URL url)
    throws InvalidMidiDataException, IOException {

    List providers = getMidiFileReaders();
    Sequence sequence = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = (MidiFileReader) providers.get(i);
        try {
            sequence = reader.getSequence( url ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( sequence==null ) {
        throw new InvalidMidiDataException("could not get sequence from URL");
    } else {
        return sequence;
    }
}
 

/**
 * Obtains a MIDI sequence from the specified <code>File</code>.
 * The <code>File</code> must point to valid MIDI file data
 * for a file type recognized by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader.  It may fail with an InvalidMidiDataException
 * even for valid files if no compatible file reader is installed.  It
 * will also fail with an InvalidMidiDataException if a compatible file reader
 * is installed, but encounters errors while constructing the <code>Sequence</code>
 * object from the file data.
 *
 * @param file the <code>File</code> from which the <code>Sequence</code>
 * should be constructed
 * @return a <code>Sequence</code> object based on the MIDI file data
 * pointed to by the File
 * @throws InvalidMidiDataException if the File does not point to valid MIDI
 * file data recognized by the system
 * @throws IOException if an I/O exception occurs
 */
public static Sequence getSequence(File file)
    throws InvalidMidiDataException, IOException {

    List providers = getMidiFileReaders();
    Sequence sequence = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = (MidiFileReader) providers.get(i);
        try {
            sequence = reader.getSequence( file ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( sequence==null ) {
        throw new InvalidMidiDataException("could not get sequence from file");
    } else {
        return sequence;
    }
}
 

/**
 * Obtains the MIDI file format of the data in the specified URL.  The URL
 * must point to valid MIDI file data for a file type recognized
 * by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader.  It may fail with an InvalidMidiDataException
 * even for valid files if no compatible file reader is installed.  It
 * will also fail with an InvalidMidiDataException if a compatible file reader
 * is installed, but encounters errors while determining the file format.
 *
 * @param url the URL from which file format information should be
 * extracted
 * @return a <code>MidiFileFormat</code> object describing the MIDI file
 * format
 * @throws InvalidMidiDataException if the URL does not point to valid MIDI
 * file data recognized by the system
 * @throws IOException if an I/O exception occurs while accessing the URL
 *
 * @see #getMidiFileFormat(InputStream)
 * @see #getMidiFileFormat(File)
 */
public static MidiFileFormat getMidiFileFormat(URL url)
    throws InvalidMidiDataException, IOException {

    List providers = getMidiFileReaders();
    MidiFileFormat format = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = (MidiFileReader) providers.get(i);
        try {
            format = reader.getMidiFileFormat( url ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( format==null ) {
        throw new InvalidMidiDataException("url is not a supported file type");
    } else {
        return format;
    }
}
 

/**
 * Obtains the MIDI file format of the specified {@code File}. The
 * {@code File} must point to valid MIDI file data for a file type
 * recognized by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader. It may fail with an
 * {@code InvalidMidiDataException} even for valid files if no compatible
 * file reader is installed. It will also fail with an
 * {@code InvalidMidiDataException} if a compatible file reader is
 * installed, but encounters errors while determining the file format.
 *
 * @param  file the {@code File} from which file format information should
 *         be extracted
 * @return a {@code MidiFileFormat} object describing the MIDI file format
 * @throws InvalidMidiDataException if the {@code File} does not point to
 *         valid MIDI file data recognized by the system
 * @throws IOException if an I/O exception occurs while accessing the file
 * @throws NullPointerException if {@code file} is {@code null}
 * @see #getMidiFileFormat(InputStream)
 * @see #getMidiFileFormat(URL)
 */
public static MidiFileFormat getMidiFileFormat(final File file)
        throws InvalidMidiDataException, IOException {
    Objects.requireNonNull(file);

    List<MidiFileReader> providers = getMidiFileReaders();
    MidiFileFormat format = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = providers.get(i);
        try {
            format = reader.getMidiFileFormat( file ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( format==null ) {
        throw new InvalidMidiDataException("file is not a supported file type");
    } else {
        return format;
    }
}
 

/**
 * Obtains a MIDI sequence from the specified URL. The URL must point to
 * valid MIDI file data for a file type recognized by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader. It may fail with an
 * {@code InvalidMidiDataException} even for valid files if no compatible
 * file reader is installed. It will also fail with an
 * {@code InvalidMidiDataException} if a compatible file reader is
 * installed, but encounters errors while constructing the {@code Sequence}
 * object from the file data.
 *
 * @param  url the URL from which the {@code Sequence} should be constructed
 * @return a {@code Sequence} object based on the MIDI file data pointed to
 *         by the URL
 * @throws InvalidMidiDataException if the URL does not point to valid MIDI
 *         file data recognized by the system
 * @throws IOException if an I/O exception occurs while accessing the URL
 * @throws NullPointerException if {@code url} is {@code null}
 */
public static Sequence getSequence(final URL url)
        throws InvalidMidiDataException, IOException {
    Objects.requireNonNull(url);

    List<MidiFileReader> providers = getMidiFileReaders();
    Sequence sequence = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = providers.get(i);
        try {
            sequence = reader.getSequence( url ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( sequence==null ) {
        throw new InvalidMidiDataException("could not get sequence from URL");
    } else {
        return sequence;
    }
}
 

/**
 * Obtains a MIDI sequence from the specified {@code File}. The {@code File}
 * must point to valid MIDI file data for a file type recognized by the
 * system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader. It may fail with an
 * {@code InvalidMidiDataException} even for valid files if no compatible
 * file reader is installed. It will also fail with an
 * {@code InvalidMidiDataException} if a compatible file reader is
 * installed, but encounters errors while constructing the {@code Sequence}
 * object from the file data.
 *
 * @param  file the {@code File} from which the {@code Sequence} should be
 *         constructed
 * @return a {@code Sequence} object based on the MIDI file data pointed to
 *         by the File
 * @throws InvalidMidiDataException if the File does not point to valid MIDI
 *         file data recognized by the system
 * @throws IOException if an I/O exception occurs
 * @throws NullPointerException if {@code file} is {@code null}
 */
public static Sequence getSequence(final File file)
        throws InvalidMidiDataException, IOException {
    Objects.requireNonNull(file);

    List<MidiFileReader> providers = getMidiFileReaders();
    Sequence sequence = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = providers.get(i);
        try {
            sequence = reader.getSequence( file ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( sequence==null ) {
        throw new InvalidMidiDataException("could not get sequence from file");
    } else {
        return sequence;
    }
}
 

/**
 * Obtains a List containing installed instances of the providers for the
 * requested service. The returned List is immutable.
 *
 * @param serviceClass The type of providers requested. This should be one
 *                     of AudioFileReader.class, AudioFileWriter.class,
 *                     FormatConversionProvider.class, MixerProvider.class,
 *                     MidiDeviceProvider.class, MidiFileReader.class,
 *                     MidiFileWriter.class or SoundbankReader.class.
 *
 * @return A List of providers of the requested type. This List is
 *         immutable.
 */
public static List<?> getProviders(final Class<?> serviceClass) {
    final List<?> providers;
    if (!MixerProvider.class.equals(serviceClass)
            && !FormatConversionProvider.class.equals(serviceClass)
            && !AudioFileReader.class.equals(serviceClass)
            && !AudioFileWriter.class.equals(serviceClass)
            && !MidiDeviceProvider.class.equals(serviceClass)
            && !SoundbankReader.class.equals(serviceClass)
            && !MidiFileWriter.class.equals(serviceClass)
            && !MidiFileReader.class.equals(serviceClass)) {
        providers = new ArrayList<>(0);
    } else {
        providers = JSSecurityManager.getProviders(serviceClass);
    }
    return Collections.unmodifiableList(providers);
}
 

/**
 * Obtains a MIDI sequence from the specified <code>File</code>.
 * The <code>File</code> must point to valid MIDI file data
 * for a file type recognized by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader.  It may fail with an InvalidMidiDataException
 * even for valid files if no compatible file reader is installed.  It
 * will also fail with an InvalidMidiDataException if a compatible file reader
 * is installed, but encounters errors while constructing the <code>Sequence</code>
 * object from the file data.
 *
 * @param file the <code>File</code> from which the <code>Sequence</code>
 * should be constructed
 * @return a <code>Sequence</code> object based on the MIDI file data
 * pointed to by the File
 * @throws InvalidMidiDataException if the File does not point to valid MIDI
 * file data recognized by the system
 * @throws IOException if an I/O exception occurs
 */
public static Sequence getSequence(File file)
    throws InvalidMidiDataException, IOException {

    List providers = getMidiFileReaders();
    Sequence sequence = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = (MidiFileReader) providers.get(i);
        try {
            sequence = reader.getSequence( file ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( sequence==null ) {
        throw new InvalidMidiDataException("could not get sequence from file");
    } else {
        return sequence;
    }
}
 

/**
 * Obtains the MIDI file format of the data in the specified URL.  The URL
 * must point to valid MIDI file data for a file type recognized
 * by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader.  It may fail with an InvalidMidiDataException
 * even for valid files if no compatible file reader is installed.  It
 * will also fail with an InvalidMidiDataException if a compatible file reader
 * is installed, but encounters errors while determining the file format.
 *
 * @param url the URL from which file format information should be
 * extracted
 * @return a <code>MidiFileFormat</code> object describing the MIDI file
 * format
 * @throws InvalidMidiDataException if the URL does not point to valid MIDI
 * file data recognized by the system
 * @throws IOException if an I/O exception occurs while accessing the URL
 *
 * @see #getMidiFileFormat(InputStream)
 * @see #getMidiFileFormat(File)
 */
public static MidiFileFormat getMidiFileFormat(URL url)
    throws InvalidMidiDataException, IOException {

    List providers = getMidiFileReaders();
    MidiFileFormat format = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = (MidiFileReader) providers.get(i);
        try {
            format = reader.getMidiFileFormat( url ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( format==null ) {
        throw new InvalidMidiDataException("url is not a supported file type");
    } else {
        return format;
    }
}
 

/**
 * Obtains the MIDI file format of the specified {@code File}. The
 * {@code File} must point to valid MIDI file data for a file type
 * recognized by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader. It may fail with an
 * {@code InvalidMidiDataException} even for valid files if no compatible
 * file reader is installed. It will also fail with an
 * {@code InvalidMidiDataException} if a compatible file reader is
 * installed, but encounters errors while determining the file format.
 *
 * @param  file the {@code File} from which file format information should
 *         be extracted
 * @return a {@code MidiFileFormat} object describing the MIDI file format
 * @throws InvalidMidiDataException if the {@code File} does not point to
 *         valid MIDI file data recognized by the system
 * @throws IOException if an I/O exception occurs while accessing the file
 * @throws NullPointerException if {@code file} is {@code null}
 * @see #getMidiFileFormat(InputStream)
 * @see #getMidiFileFormat(URL)
 */
public static MidiFileFormat getMidiFileFormat(final File file)
        throws InvalidMidiDataException, IOException {
    Objects.requireNonNull(file);

    List<MidiFileReader> providers = getMidiFileReaders();
    MidiFileFormat format = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = providers.get(i);
        try {
            format = reader.getMidiFileFormat( file ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( format==null ) {
        throw new InvalidMidiDataException("file is not a supported file type");
    } else {
        return format;
    }
}
 

/**
 * Obtains a MIDI sequence from the specified URL. The URL must point to
 * valid MIDI file data for a file type recognized by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader. It may fail with an
 * {@code InvalidMidiDataException} even for valid files if no compatible
 * file reader is installed. It will also fail with an
 * {@code InvalidMidiDataException} if a compatible file reader is
 * installed, but encounters errors while constructing the {@code Sequence}
 * object from the file data.
 *
 * @param  url the URL from which the {@code Sequence} should be constructed
 * @return a {@code Sequence} object based on the MIDI file data pointed to
 *         by the URL
 * @throws InvalidMidiDataException if the URL does not point to valid MIDI
 *         file data recognized by the system
 * @throws IOException if an I/O exception occurs while accessing the URL
 * @throws NullPointerException if {@code url} is {@code null}
 */
public static Sequence getSequence(final URL url)
        throws InvalidMidiDataException, IOException {
    Objects.requireNonNull(url);

    List<MidiFileReader> providers = getMidiFileReaders();
    Sequence sequence = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = providers.get(i);
        try {
            sequence = reader.getSequence( url ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( sequence==null ) {
        throw new InvalidMidiDataException("could not get sequence from URL");
    } else {
        return sequence;
    }
}
 

/**
 * Obtains the MIDI file format of the data in the specified URL.  The URL
 * must point to valid MIDI file data for a file type recognized
 * by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader.  It may fail with an InvalidMidiDataException
 * even for valid files if no compatible file reader is installed.  It
 * will also fail with an InvalidMidiDataException if a compatible file reader
 * is installed, but encounters errors while determining the file format.
 *
 * @param url the URL from which file format information should be
 * extracted
 * @return a <code>MidiFileFormat</code> object describing the MIDI file
 * format
 * @throws InvalidMidiDataException if the URL does not point to valid MIDI
 * file data recognized by the system
 * @throws IOException if an I/O exception occurs while accessing the URL
 *
 * @see #getMidiFileFormat(InputStream)
 * @see #getMidiFileFormat(File)
 */
public static MidiFileFormat getMidiFileFormat(URL url)
    throws InvalidMidiDataException, IOException {

    List providers = getMidiFileReaders();
    MidiFileFormat format = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = (MidiFileReader) providers.get(i);
        try {
            format = reader.getMidiFileFormat( url ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( format==null ) {
        throw new InvalidMidiDataException("url is not a supported file type");
    } else {
        return format;
    }
}
 

/**
 * Obtains the MIDI file format of the data in the specified URL.  The URL
 * must point to valid MIDI file data for a file type recognized
 * by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader.  It may fail with an InvalidMidiDataException
 * even for valid files if no compatible file reader is installed.  It
 * will also fail with an InvalidMidiDataException if a compatible file reader
 * is installed, but encounters errors while determining the file format.
 *
 * @param url the URL from which file format information should be
 * extracted
 * @return a <code>MidiFileFormat</code> object describing the MIDI file
 * format
 * @throws InvalidMidiDataException if the URL does not point to valid MIDI
 * file data recognized by the system
 * @throws IOException if an I/O exception occurs while accessing the URL
 *
 * @see #getMidiFileFormat(InputStream)
 * @see #getMidiFileFormat(File)
 */
public static MidiFileFormat getMidiFileFormat(URL url)
    throws InvalidMidiDataException, IOException {

    List providers = getMidiFileReaders();
    MidiFileFormat format = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = (MidiFileReader) providers.get(i);
        try {
            format = reader.getMidiFileFormat( url ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( format==null ) {
        throw new InvalidMidiDataException("url is not a supported file type");
    } else {
        return format;
    }
}
 

/**
 * Obtains a List containing installed instances of the providers for the
 * requested service. The returned List is immutable.
 *
 * @param serviceClass The type of providers requested. This should be one
 *                     of AudioFileReader.class, AudioFileWriter.class,
 *                     FormatConversionProvider.class, MixerProvider.class,
 *                     MidiDeviceProvider.class, MidiFileReader.class,
 *                     MidiFileWriter.class or SoundbankReader.class.
 *
 * @return A List of providers of the requested type. This List is
 *         immutable.
 */
public static List<?> getProviders(final Class<?> serviceClass) {
    final List<?> providers;
    if (!MixerProvider.class.equals(serviceClass)
            && !FormatConversionProvider.class.equals(serviceClass)
            && !AudioFileReader.class.equals(serviceClass)
            && !AudioFileWriter.class.equals(serviceClass)
            && !MidiDeviceProvider.class.equals(serviceClass)
            && !SoundbankReader.class.equals(serviceClass)
            && !MidiFileWriter.class.equals(serviceClass)
            && !MidiFileReader.class.equals(serviceClass)) {
        providers = new ArrayList<>(0);
    } else {
        providers = JSSecurityManager.getProviders(serviceClass);
    }
    return Collections.unmodifiableList(providers);
}
 

/**
 * Obtains the MIDI file format of the specified <code>File</code>.  The
 * <code>File</code> must point to valid MIDI file data for a file type
 * recognized by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader.  It may fail with an InvalidMidiDataException
 * even for valid files if no compatible file reader is installed.  It
 * will also fail with an InvalidMidiDataException if a compatible file reader
 * is installed, but encounters errors while determining the file format.
 *
 * @param file the <code>File</code> from which file format information
 * should be extracted
 * @return a <code>MidiFileFormat</code> object describing the MIDI file
 * format
 * @throws InvalidMidiDataException if the <code>File</code> does not point
 *  to valid MIDI file data recognized by the system
 * @throws IOException if an I/O exception occurs while accessing the file
 *
 * @see #getMidiFileFormat(InputStream)
 * @see #getMidiFileFormat(URL)
 */
public static MidiFileFormat getMidiFileFormat(File file)
    throws InvalidMidiDataException, IOException {

    List providers = getMidiFileReaders();
    MidiFileFormat format = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = (MidiFileReader) providers.get(i);
        try {
            format = reader.getMidiFileFormat( file ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( format==null ) {
        throw new InvalidMidiDataException("file is not a supported file type");
    } else {
        return format;
    }
}
 

/**
 * Obtains the MIDI file format of the specified <code>File</code>.  The
 * <code>File</code> must point to valid MIDI file data for a file type
 * recognized by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader.  It may fail with an InvalidMidiDataException
 * even for valid files if no compatible file reader is installed.  It
 * will also fail with an InvalidMidiDataException if a compatible file reader
 * is installed, but encounters errors while determining the file format.
 *
 * @param file the <code>File</code> from which file format information
 * should be extracted
 * @return a <code>MidiFileFormat</code> object describing the MIDI file
 * format
 * @throws InvalidMidiDataException if the <code>File</code> does not point
 *  to valid MIDI file data recognized by the system
 * @throws IOException if an I/O exception occurs while accessing the file
 *
 * @see #getMidiFileFormat(InputStream)
 * @see #getMidiFileFormat(URL)
 */
public static MidiFileFormat getMidiFileFormat(File file)
    throws InvalidMidiDataException, IOException {

    List providers = getMidiFileReaders();
    MidiFileFormat format = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = (MidiFileReader) providers.get(i);
        try {
            format = reader.getMidiFileFormat( file ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( format==null ) {
        throw new InvalidMidiDataException("file is not a supported file type");
    } else {
        return format;
    }
}
 

/**
 * Obtains a MIDI sequence from the specified <code>File</code>.
 * The <code>File</code> must point to valid MIDI file data
 * for a file type recognized by the system.
 * <p>
 * This operation can only succeed for files of a type which can be parsed
 * by an installed file reader.  It may fail with an InvalidMidiDataException
 * even for valid files if no compatible file reader is installed.  It
 * will also fail with an InvalidMidiDataException if a compatible file reader
 * is installed, but encounters errors while constructing the <code>Sequence</code>
 * object from the file data.
 *
 * @param file the <code>File</code> from which the <code>Sequence</code>
 * should be constructed
 * @return a <code>Sequence</code> object based on the MIDI file data
 * pointed to by the File
 * @throws InvalidMidiDataException if the File does not point to valid MIDI
 * file data recognized by the system
 * @throws IOException if an I/O exception occurs
 */
public static Sequence getSequence(File file)
    throws InvalidMidiDataException, IOException {

    List providers = getMidiFileReaders();
    Sequence sequence = null;

    for(int i = 0; i < providers.size(); i++) {
        MidiFileReader reader = (MidiFileReader) providers.get(i);
        try {
            sequence = reader.getSequence( file ); // throws IOException
            break;
        } catch (InvalidMidiDataException e) {
            continue;
        }
    }

    if( sequence==null ) {
        throw new InvalidMidiDataException("could not get sequence from file");
    } else {
        return sequence;
    }
}