/** * 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 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</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 <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 * {@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 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; } }
