public AudioSample getAudioSample(String filename, int bufferSize) { AudioInputStream ais = getAudioInputStream(filename); if (ais != null) { AudioMetaData meta = null; AudioFormat format = ais.getFormat(); FloatSampleBuffer samples = null; if (format instanceof MpegAudioFormat) { AudioFormat baseFormat = format; format = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, baseFormat.getSampleRate(), 16, baseFormat.getChannels(), baseFormat.getChannels() * 2, baseFormat.getSampleRate(), false); // converts the stream to PCM audio from mp3 audio ais = getAudioInputStream(format, ais); // get a map of properties so we can find out how long it is Map<String, Object> props = getID3Tags(filename); // there is a property called mp3.length.bytes, but that is // the length in bytes of the mp3 file, which will of course // be much shorter than the decoded version. so we use the // duration of the file to figure out how many bytes the // decoded file will be. long dur = ((Long) props.get("duration")).longValue(); int toRead = (int) AudioUtils.millis2Bytes(dur / 1000, format); samples = loadFloatAudio(ais, toRead); meta = new MP3MetaData(filename, dur / 1000, props); } else { samples = loadFloatAudio(ais, (int) ais.getFrameLength() * format.getFrameSize()); long length = AudioUtils.frames2Millis(samples.getSampleCount(), format); meta = new BasicMetaData(filename, length); } AudioSynthesizer out = getAudioSynthesizer( format.getChannels(), bufferSize, format.getSampleRate(), format.getSampleSizeInBits()); if (out != null) { SampleSignal ssig = new SampleSignal(samples); out.setAudioSignal(ssig); return new JSAudioSample(meta, ssig, out); } else { error("Couldn't acquire an output."); } } return null; }
public AudioInputStream getAudioInputStream( AudioFormat.Encoding targetEncoding, AudioInputStream sourceStream) { AudioFormat sourceFormat = sourceStream.getFormat(); AudioFormat.Encoding sourceEncoding = sourceFormat.getEncoding(); if (sourceEncoding.equals(targetEncoding)) { return sourceStream; } else { AudioFormat targetFormat = null; if (!isConversionSupported(targetEncoding, sourceStream.getFormat())) { throw new IllegalArgumentException( "Unsupported conversion: " + sourceStream.getFormat().toString() + " to " + targetEncoding.toString()); } if (AudioFormat.Encoding.ULAW.equals(sourceEncoding) && AudioFormat.Encoding.PCM_SIGNED.equals(targetEncoding)) { targetFormat = new AudioFormat( targetEncoding, sourceFormat.getSampleRate(), 16, sourceFormat.getChannels(), 2 * sourceFormat.getChannels(), sourceFormat.getSampleRate(), sourceFormat.isBigEndian()); } else if (AudioFormat.Encoding.PCM_SIGNED.equals(sourceEncoding) && AudioFormat.Encoding.ULAW.equals(targetEncoding)) { targetFormat = new AudioFormat( targetEncoding, sourceFormat.getSampleRate(), 8, sourceFormat.getChannels(), sourceFormat.getChannels(), sourceFormat.getSampleRate(), false); } else { throw new IllegalArgumentException( "Unsupported conversion: " + sourceStream.getFormat().toString() + " to " + targetEncoding.toString()); } return getAudioInputStream(targetFormat, sourceStream); } }
/* public AudioFormat[] getOutputFormats(AudioFormat inputFormat) { */ private AudioFormat[] getOutputFormats(AudioFormat inputFormat) { Vector formats = new Vector(); AudioFormat format; if ((inputFormat.getSampleSizeInBits() == 16) && AudioFormat.Encoding.PCM_SIGNED.equals(inputFormat.getEncoding())) { format = new AudioFormat( AudioFormat.Encoding.ULAW, inputFormat.getSampleRate(), 8, inputFormat.getChannels(), inputFormat.getChannels(), inputFormat.getSampleRate(), false); formats.addElement(format); } if (AudioFormat.Encoding.ULAW.equals(inputFormat.getEncoding())) { format = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, inputFormat.getSampleRate(), 16, inputFormat.getChannels(), inputFormat.getChannels() * 2, inputFormat.getSampleRate(), false); formats.addElement(format); format = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, inputFormat.getSampleRate(), 16, inputFormat.getChannels(), inputFormat.getChannels() * 2, inputFormat.getSampleRate(), true); formats.addElement(format); } AudioFormat[] formatArray = new AudioFormat[formats.size()]; for (int i = 0; i < formatArray.length; i++) { formatArray[i] = (AudioFormat) (formats.elementAt(i)); } return formatArray; }
/** * Construct a RawAudioFormat from an AudioFormat, assuming a WAV header of size WAV_HEADER_SIZE * (44) bytes. * * @param af AudioFormat (e.g. from AudioSystem.getAudioFileFormat(File). */ public RawAudioFormat(AudioFormat af) throws IOException { sr = (int) af.getFrameRate(); br = af.getSampleSizeInBits(); fs = br / 8; if (af.getChannels() > 1) throw new IOException("multi-channel files are not supported"); if (af.getEncoding() == AudioFormat.Encoding.PCM_SIGNED) { signed = true; alaw = false; ulaw = false; hs = WAV_HEADER_SIZE; } if (af.getEncoding() == AudioFormat.Encoding.PCM_UNSIGNED) { signed = false; alaw = false; ulaw = false; hs = WAV_HEADER_SIZE; } if (af.getEncoding() == AudioFormat.Encoding.ALAW) { alaw = true; signed = true; ulaw = false; hs = WAV_HEADER_SIZE2; } if (af.getEncoding() == AudioFormat.Encoding.ULAW) { ulaw = true; signed = true; alaw = false; hs = WAV_HEADER_SIZE2; } }
private static boolean checkConversion( AudioFormat srcFormat, AudioFormat.Encoding targetEncoding, boolean neg) { AudioInputStream srcStream = new AudioInputStream(new ByteArrayInputStream(new byte[0]), srcFormat, -1); boolean couldConvert = true; try { AudioInputStream targetStream = AudioSystem.getAudioInputStream(targetEncoding, srcStream); // always a failure if src bits != target bits, or src channels != // target channels AudioFormat targetFormat = targetStream.getFormat(); if (!isSameBitsChannelSampleRate(srcFormat, targetFormat)) { System.out.println("ERROR"); System.out.println( " converted stream has " + targetFormat.getChannels() + " channels, " + targetFormat.getSampleSizeInBits() + " bits, and " + targetFormat.getSampleRate() + "Hz, " + " but source stream had " + srcFormat.getChannels() + " channels, " + srcFormat.getSampleSizeInBits() + " bits, and " + srcFormat.getSampleRate() + "Hz"); return false; } } catch (Exception e) { couldConvert = false; } if (couldConvert == neg) { System.out.println("ERROR"); System.out.println( " can" + ((!couldConvert) ? "not" : "") + " convert from " + srcFormat + " to " + targetEncoding); return false; } System.out.println("OK"); return true; }
/** * Test method for {@link net.sourceforge.gjtapi.protocols.JavaSoundParser#parse(java.net.URL)} . * * @exception Exception test failed. */ @Test public void testParse() throws Exception { final URL url = new URL("playback://audio?rate=8000&channels=2&encoding=pcm"); AudioFormat format = JavaSoundParser.parse(url); Assert.assertEquals(new Float(8000.0), new Float(format.getSampleRate())); Assert.assertEquals(2, format.getChannels()); Assert.assertEquals(AudioFormat.Encoding.PCM_SIGNED, format.getEncoding()); }
public AudioRecordingStream getAudioRecordingStream(String filename, int bufferSize) { AudioRecordingStream mstream = null; if (getAudioInputStream(filename) == null) debug("Reading from " + getAudioInputStream(filename).getClass().toString()); if (getAudioInputStream(filename) != null) { debug("File format is: " + getAudioInputStream(filename).getFormat().toString()); AudioFormat format = getAudioInputStream(filename).getFormat(); // special handling for mp3 files because // they need to be converted to PCM if (format instanceof MpegAudioFormat) { AudioFormat baseFormat = format; format = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, baseFormat.getSampleRate(), 16, baseFormat.getChannels(), baseFormat.getChannels() * 2, baseFormat.getSampleRate(), false); // converts the stream to PCM audio from mp3 audio AudioInputStream decAis = getAudioInputStream(format, getAudioInputStream(filename)); // source data line is for sending the file audio out to the // speakers SourceDataLine line = getSourceDataLine(format, bufferSize); if (decAis != null && line != null) { Map<String, Object> props = getID3Tags(filename); long lengthInMillis = -1; if (props.containsKey("duration")) { Long dur = (Long) props.get("duration"); if (dur.longValue() > 0) { lengthInMillis = dur.longValue() / 1000; } } MP3MetaData meta = new MP3MetaData(filename, lengthInMillis, props); mstream = new JSMPEGAudioRecordingStream( this, meta, getAudioInputStream(filename), decAis, line, bufferSize); } } // format instanceof MpegAudioFormat else { // source data line is for sending the file audio out to the // speakers SourceDataLine line = getSourceDataLine(format, bufferSize); if (line != null) { long length = AudioUtils.frames2Millis(getAudioInputStream(filename).getFrameLength(), format); BasicMetaData meta = new BasicMetaData(filename, length); mstream = new JSPCMAudioRecordingStream( this, meta, getAudioInputStream(filename), line, bufferSize); } } // else } // ais != null return mstream; }
private static boolean checkDirect(AudioFormat srcFormat, boolean neg) { AudioFormat targetFormat = new AudioFormat( srcFormat.getSampleRate(), srcFormat.getSampleSizeInBits(), srcFormat.getChannels(), true, false); return checkConversion(srcFormat, targetFormat, neg); }
/** * Store an AudioFormat * * @param audioFormat */ public AudioFormatTransport(AudioFormat audioFormat) { _channels = audioFormat.getChannels(); _encoding = audioFormat.getEncoding().toString(); _frameRate = audioFormat.getFrameRate(); _frameSize = audioFormat.getFrameSize(); _sampleRate = audioFormat.getSampleRate(); _sampleSizeInBits = audioFormat.getSampleSizeInBits(); _isBigEndian = audioFormat.isBigEndian(); _properties = audioFormat.properties(); }
public static Clip loadClip(URL url) { Clip clip = null; String fnm = "" + url; try { AudioInputStream stream = AudioSystem.getAudioInputStream(url); AudioFormat format = stream.getFormat(); if ((format.getEncoding() == AudioFormat.Encoding.ULAW) || (format.getEncoding() == AudioFormat.Encoding.ALAW)) { AudioFormat newFormat = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, format.getSampleRate(), format.getSampleSizeInBits() * 2, format.getChannels(), format.getFrameSize() * 2, format.getFrameRate(), true); // big endian stream = AudioSystem.getAudioInputStream(newFormat, stream); // System.out.println("Converted Audio format: " + newFormat); format = newFormat; } DataLine.Info info = new DataLine.Info(Clip.class, format); // make sure sound system supports data line if (!AudioSystem.isLineSupported(info)) { System.out.println("Unsupported Clip File: " + fnm); return null; } // get clip line resource clip = (Clip) AudioSystem.getLine(info); clip.open(stream); // open the sound file as a clip stream.close(); // we're done with the input stream // duration (in secs) of the clip double duration = clip.getMicrosecondLength() / 1000000.0; // new if (duration <= 1.0) { System.out.println("WARNING. Duration <= 1 sec : " + duration + " secs"); System.out.println( " The clip in " + fnm + " may not play in J2SE 1.5 -- make it longer"); } // else // System.out.println(fnm + ": Duration: " + duration + " secs"); } // end of try block catch (UnsupportedAudioFileException audioException) { System.out.println("Unsupported audio file: " + fnm); } catch (LineUnavailableException noLineException) { System.out.println("No audio line available for : " + fnm); } catch (IOException ioException) { System.out.println("Could not read: " + fnm); } catch (Exception e) { System.out.println("Problem with " + fnm); } return clip; } // end of loadClip()
public void open(AudioInputStream stream) throws IOException, LineUnavailableException { AudioInputStream is1; format = stream.getFormat(); if (format.getEncoding() != AudioFormat.Encoding.PCM_SIGNED) { is1 = AudioSystem.getAudioInputStream(AudioFormat.Encoding.PCM_SIGNED, stream); } else { is1 = stream; } format = is1.getFormat(); InputStream is2; if (parent != null) { ProgressMonitorInputStream pmis = new ProgressMonitorInputStream(parent, "Loading track..", is1); pmis.getProgressMonitor().setMillisToPopup(0); is2 = pmis; } else { is2 = is1; } byte[] buf = new byte[2 ^ 16]; int totalRead = 0; int numRead = 0; ByteArrayOutputStream baos = new ByteArrayOutputStream(); numRead = is2.read(buf); while (numRead > -1) { baos.write(buf, 0, numRead); numRead = is2.read(buf, 0, buf.length); totalRead += numRead; } is2.close(); audioData = baos.toByteArray(); AudioFormat afTemp; if (format.getChannels() < 2) { afTemp = new AudioFormat( format.getEncoding(), format.getSampleRate(), format.getSampleSizeInBits(), 2, format.getSampleSizeInBits() * 2 / 8, // calculate // frame // size format.getFrameRate(), format.isBigEndian()); } else { afTemp = format; } setLoopPoints(0, audioData.length); dataLine = AudioSystem.getSourceDataLine(afTemp); dataLine.open(); inputStream = new ByteArrayInputStream(audioData); }
// http://stackoverflow.com/questions/13789063/get-sound-from-a-url-with-java private void playMP3(final String url) { try { // Create the JavaFX Panel for the WebView JFXPanel fxPanel = new JFXPanel(); fxPanel.setLocation(new Point(0, 0)); // Initialize the webView in a JavaFX-Thread Platform.runLater( new Runnable() { public void run() { MediaPlayer player = new MediaPlayer(new Media(url)); player.play(); } }); if (true) return; AudioInputStream in = AudioSystem.getAudioInputStream(new URL(url)); AudioFormat baseFormat = in.getFormat(); AudioFormat decodedFormat = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, baseFormat.getSampleRate(), 16, baseFormat.getChannels(), baseFormat.getChannels() * 2, baseFormat.getSampleRate(), false); AudioInputStream din = AudioSystem.getAudioInputStream(decodedFormat, in); DataLine.Info info = new DataLine.Info(SourceDataLine.class, decodedFormat); SourceDataLine line = (SourceDataLine) AudioSystem.getLine(info); if (line != null) { line.open(decodedFormat); byte[] data = new byte[4096]; // Start line.start(); int nBytesRead; while ((nBytesRead = din.read(data, 0, data.length)) != -1) { line.write(data, 0, nBytesRead); } // Stop line.drain(); line.stop(); line.close(); din.close(); } } catch (Exception e) { App.debug("playing MP3 failed " + url + " " + e.toString()); } }
private AudioInputStream toLittleEndian(AudioInputStream ais) { AudioFormat format = ais.getFormat(); AudioFormat targetFormat = new AudioFormat( format.getEncoding(), format.getSampleRate(), format.getSampleSizeInBits(), format.getChannels(), format.getFrameSize(), format.getFrameRate(), false); return AudioSystem.getAudioInputStream(targetFormat, ais); }
private void adjustConfigurations(AudioFormat format) { int sampleRate = (int) format.getSampleRate(); int sampleSize = (int) format.getSampleSizeInBits(); int channels = (int) format.getChannels(); // int blockSize = sc.getMaxBlockSize(); /* * sc = new StreamConfiguration(channels, blockSize, blockSize, * sampleRate, sampleSize); */ sc.setSampleRate(sampleRate); sc.setBitsPerSample(sampleSize); sc.setChannelCount(channels); }
/** * Inits a DateLine.<br> * We check if the line supports Gain and Pan controls. * * <p>From the AudioInputStream, i.e. from the sound file, we fetch information about the format * of the audio data. These information include the sampling frequency, the number of channels and * the size of the samples. There information are needed to ask JavaSound for a suitable output * line for this audio file. Furthermore, we have to give JavaSound a hint about how big the * internal buffer for the line should be. Here, we say AudioSystem.NOT_SPECIFIED, signaling that * we don't care about the exact size. JavaSound will use some default value for the buffer size. */ protected void createLine() throws LineUnavailableException { log.info("Create Line"); if (m_line == null) { AudioFormat sourceFormat = m_audioInputStream.getFormat(); log.info("Create Line : Source format : " + sourceFormat.toString()); int nSampleSizeInBits = sourceFormat.getSampleSizeInBits(); if (nSampleSizeInBits <= 0) { nSampleSizeInBits = 16; } if ((sourceFormat.getEncoding() == AudioFormat.Encoding.ULAW) || (sourceFormat.getEncoding() == AudioFormat.Encoding.ALAW)) { nSampleSizeInBits = 16; } if (nSampleSizeInBits != 8) { nSampleSizeInBits = 16; } AudioFormat targetFormat = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, sourceFormat.getSampleRate(), nSampleSizeInBits, sourceFormat.getChannels(), sourceFormat.getChannels() * (nSampleSizeInBits / 8), sourceFormat.getSampleRate(), false); log.info("Create Line : Target format: " + targetFormat); // Keep a reference on encoded stream to progress notification. m_encodedaudioInputStream = m_audioInputStream; try { // Get total length in bytes of the encoded stream. encodedLength = m_encodedaudioInputStream.available(); } catch (IOException e) { log.log(Level.SEVERE, "Cannot get m_encodedaudioInputStream.available()", e); } // Create decoded stream. m_audioInputStream = AudioSystem.getAudioInputStream(targetFormat, m_audioInputStream); AudioFormat audioFormat = m_audioInputStream.getFormat(); DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat, -1); Mixer mixer = getMixer(m_mixerName); if (mixer != null) { log.info("Mixer : " + mixer.getMixerInfo().toString()); m_line = (SourceDataLine) mixer.getLine(info); } else { m_line = (SourceDataLine) AudioSystem.getLine(info); m_mixerName = null; } log.info("Line : " + m_line.toString()); log.info("Line Info : " + m_line.getLineInfo().toString()); log.info("Line AudioFormat: " + m_line.getFormat().toString()); } }
/** * Numbers used here are verbatim from Javazoom * * @param baseFormat * @return */ private AudioFormat getDecodedFormat(AudioFormat baseFormat) { // Do we need to "decode" the base format? if (AudioFormat.Encoding.PCM_SIGNED.equals(baseFormat.getEncoding()) || AudioFormat.Encoding.PCM_UNSIGNED.equals(baseFormat.getEncoding())) { return baseFormat; } return new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, baseFormat.getSampleRate(), 16, baseFormat.getChannels(), baseFormat.getChannels() * 2, baseFormat.getSampleRate(), false); }
public AudioRecording getAudioRecordingClip(String filename) { Clip clip = null; AudioMetaData meta = null; AudioInputStream ais = getAudioInputStream(filename); if (ais != null) { AudioFormat format = ais.getFormat(); if (format instanceof MpegAudioFormat) { AudioFormat baseFormat = format; format = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, baseFormat.getSampleRate(), 16, baseFormat.getChannels(), baseFormat.getChannels() * 2, baseFormat.getSampleRate(), false); // converts the stream to PCM audio from mp3 audio ais = getAudioInputStream(format, ais); } DataLine.Info info = new DataLine.Info(Clip.class, ais.getFormat()); if (AudioSystem.isLineSupported(info)) { // Obtain and open the line. try { clip = (Clip) AudioSystem.getLine(info); clip.open(ais); } catch (Exception e) { error("Error obtaining Javasound Clip: " + e.getMessage()); return null; } Map<String, Object> props = getID3Tags(filename); long lengthInMillis = -1; if (props.containsKey("duration")) { Long dur = (Long) props.get("duration"); lengthInMillis = dur.longValue() / 1000; } meta = new MP3MetaData(filename, lengthInMillis, props); } else { error("File format not supported."); return null; } } if (meta == null) { // this means we're dealing with not-an-mp3 meta = new BasicMetaData(filename, clip.getMicrosecondLength() / 1000); } return new JSAudioRecordingClip(clip, meta); }
public boolean load(File file) { this.file = file; if (file != null && file.isFile()) { try { errStr = null; audioInputStream = AudioSystem.getAudioInputStream(file); fileName = file.getName(); format = audioInputStream.getFormat(); } catch (Exception ex) { reportStatus(ex.toString()); return false; } } else { reportStatus("Audio file required."); return false; } numChannels = format.getChannels(); sampleRate = (double) format.getSampleRate(); sampleBitSize = format.getSampleSizeInBits(); long frameLength = audioInputStream.getFrameLength(); long milliseconds = (long) ((frameLength * 1000) / audioInputStream.getFormat().getFrameRate()); double audioFileDuration = milliseconds / 1000.0; if (audioFileDuration > MAX_AUDIO_DURATION) duration = MAX_AUDIO_DURATION; else duration = audioFileDuration; frameLength = (int) Math.floor((duration / audioFileDuration) * (double) frameLength); try { audioBytes = new byte[(int) frameLength * format.getFrameSize()]; audioInputStream.read(audioBytes); } catch (Exception ex) { reportStatus(ex.toString()); return false; } getAudioData(); return true; }
public void write(AudioInputStream stream, RIFFWriter writer) throws IOException { RIFFWriter fmt_chunk = writer.writeChunk("fmt "); AudioFormat format = stream.getFormat(); fmt_chunk.writeUnsignedShort(3); // WAVE_FORMAT_IEEE_FLOAT fmt_chunk.writeUnsignedShort(format.getChannels()); fmt_chunk.writeUnsignedInt((int) format.getSampleRate()); fmt_chunk.writeUnsignedInt(((int) format.getFrameRate()) * format.getFrameSize()); fmt_chunk.writeUnsignedShort(format.getFrameSize()); fmt_chunk.writeUnsignedShort(format.getSampleSizeInBits()); fmt_chunk.close(); RIFFWriter data_chunk = writer.writeChunk("data"); byte[] buff = new byte[1024]; int len; while ((len = stream.read(buff, 0, buff.length)) != -1) data_chunk.write(buff, 0, len); data_chunk.close(); }
private static WAVData readFromStream(AudioInputStream aIn) throws UnsupportedAudioFileException, IOException { ReadableByteChannel aChannel = Channels.newChannel(aIn); AudioFormat fmt = aIn.getFormat(); int numChannels = fmt.getChannels(); int bits = fmt.getSampleSizeInBits(); int format = AL_FORMAT_MONO8; if ((bits == 8) && (numChannels == 1)) { format = AL_FORMAT_MONO8; } else if ((bits == 16) && (numChannels == 1)) { format = AL_FORMAT_MONO16; } else if ((bits == 8) && (numChannels == 2)) { format = AL_FORMAT_STEREO8; } else if ((bits == 16) && (numChannels == 2)) { format = AL_FORMAT_STEREO16; } int freq = Math.round(fmt.getSampleRate()); int size = aIn.available(); ByteBuffer buffer = ByteBuffer.allocateDirect(size); while (buffer.remaining() > 0) { aChannel.read(buffer); } buffer.rewind(); // Must byte swap on big endian platforms // Thanks to swpalmer on javagaming.org forums for hint at fix if ((bits == 16) && (ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN)) { int len = buffer.remaining(); for (int i = 0; i < len; i += 2) { byte a = buffer.get(i); byte b = buffer.get(i + 1); buffer.put(i, b); buffer.put(i + 1, a); } } WAVData result = new WAVData(buffer, format, size, freq, false); aIn.close(); return result; }
public AudioRecording getAudioRecording(String filename) { AudioMetaData meta = null; AudioInputStream ais = getAudioInputStream(filename); byte[] samples; if (ais != null) { AudioFormat format = ais.getFormat(); if (format instanceof MpegAudioFormat) { AudioFormat baseFormat = format; format = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, baseFormat.getSampleRate(), 16, baseFormat.getChannels(), baseFormat.getChannels() * 2, baseFormat.getSampleRate(), false); // converts the stream to PCM audio from mp3 audio ais = getAudioInputStream(format, ais); // get a map of properties so we can find out how long it is Map<String, Object> props = getID3Tags(filename); // there is a property called mp3.length.bytes, but that is // the length in bytes of the mp3 file, which will of course // be much shorter than the decoded version. so we use the // duration of the file to figure out how many bytes the // decoded file will be. long dur = ((Long) props.get("duration")).longValue(); int toRead = (int) AudioUtils.millis2Bytes(dur / 1000, format); samples = loadByteAudio(ais, toRead); meta = new MP3MetaData(filename, dur / 1000, props); } else { samples = loadByteAudio(ais, (int) ais.getFrameLength() * format.getFrameSize()); long length = AudioUtils.bytes2Millis(samples.length, format); meta = new BasicMetaData(filename, length); } SourceDataLine line = getSourceDataLine(format, 2048); if (line != null) { return new JSAudioRecording(this, samples, line, meta); } } return null; }
/** Convert javax.sound.sampled.AudioFormat to javax.media.format.AudioFormat. */ public static AudioFormat convertFormat(javax.sound.sampled.AudioFormat format) { Encoding encoding = format.getEncoding(); int channels = format.getChannels(); float frameRate = format.getFrameRate(); int frameSize = format.getFrameSize() < 0 ? format.getFrameSize() : (format.getFrameSize() * 8); float sampleRate = format.getSampleRate(); int sampleSize = format.getSampleSizeInBits(); int endian = format.isBigEndian() ? AudioFormat.BIG_ENDIAN : AudioFormat.LITTLE_ENDIAN; int signed = AudioFormat.NOT_SPECIFIED; String encodingString = AudioFormat.LINEAR; if (encoding == Encoding.PCM_SIGNED) { signed = AudioFormat.SIGNED; encodingString = AudioFormat.LINEAR; } else if (encoding == Encoding.PCM_UNSIGNED) { signed = AudioFormat.UNSIGNED; encodingString = AudioFormat.LINEAR; } else if (encoding == Encoding.ALAW) { encodingString = AudioFormat.ALAW; } else if (encoding == Encoding.ULAW) { encodingString = AudioFormat.ULAW; } else { encodingString = encoding.toString(); } AudioFormat jmfFormat = new AudioFormat( encodingString, (double) sampleRate, sampleSize, channels, endian, signed, frameSize, frameRate, AudioFormat.byteArray); return jmfFormat; }
/** * Private method to load audio file * * @throws LineUnavailableException * @throws LineUnavailableException * @throws IOException * @throws UnsupportedAudioFileException */ private void load() throws LineUnavailableException, UnsupportedAudioFileException, IOException { // From URL audioStream = AudioSystem.getAudioInputStream(audioURL); // At present, ALAW and ULAW encodings must be converted // to PCM_SIGNED before it can be played AudioFormat audioFormat = audioStream.getFormat(); DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat, AudioSystem.NOT_SPECIFIED); if (!AudioSystem.isLineSupported(info)) { AudioFormat sourceFormat = audioFormat; AudioFormat targetFormat = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, sourceFormat.getSampleRate(), 16, sourceFormat.getChannels(), sourceFormat.getChannels() * (16 / 8), sourceFormat.getSampleRate(), false); audioStream = AudioSystem.getAudioInputStream(targetFormat, audioStream); audioFormat = audioStream.getFormat(); } // Create the clip info = new DataLine.Info( Clip.class, audioFormat, ((int) audioStream.getFrameLength() * audioFormat.getFrameSize())); audioClip = (Clip) AudioSystem.getLine(info); // Add a listener for line events audioClip.addLineListener(this); // This method does not return until the audio file is completely // loaded audioClip.open(audioStream); }
private void initializeOggStream() throws IOException { vorbis_info vorbisInfo = new vorbis_info(); vorbisenc encoder = new vorbisenc(); if (!encoder.vorbis_encode_init_vbr( vorbisInfo, audioFormat.getChannels(), (int) audioFormat.getSampleRate(), HIGH_QUALITY_256_KB)) { throw new IOException("Failed to initialize Vorbis encoder."); } vorbis_comment vorbisComment = new vorbis_comment(); vorbisComment.vorbis_comment_add_tag(ENCODER_TAG_NAME, ENCODER_TAG_CONTENT); vorbisDspState = new vorbis_dsp_state(); if (!vorbisDspState.vorbis_analysis_init(vorbisInfo)) { throw new IOException("Failed to initialize Vorbis DSP state."); } vorbisBlock = new vorbis_block(vorbisDspState); java.util.Random generator = new java.util.Random(); // need to randomize seed oggStreamState = new ogg_stream_state(generator.nextInt(256)); ogg_packet header = new ogg_packet(); ogg_packet header_comm = new ogg_packet(); ogg_packet header_code = new ogg_packet(); vorbisDspState.vorbis_analysis_headerout(vorbisComment, header, header_comm, header_code); oggStreamState.ogg_stream_packetin(header); // automatically placed in its own page oggStreamState.ogg_stream_packetin(header_comm); oggStreamState.ogg_stream_packetin(header_code); }
private static Clip loadFile(String path) { try { path = ClassLoader.getSystemResource(path).getPath(); path = path.substring(1, path.length()).replaceAll("%20", " "); InputStream in = new FileInputStream(path); InputStream bin = new BufferedInputStream(in); AudioInputStream ais = AudioSystem.getAudioInputStream(bin); AudioFormat baseFormat = ais.getFormat(); AudioFormat decodeFormat = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, baseFormat.getSampleRate(), 16, baseFormat.getChannels(), baseFormat.getChannels() * 2, baseFormat.getSampleRate(), false); AudioInputStream dais = AudioSystem.getAudioInputStream(decodeFormat, ais); return AudioSystem.getClip(); } catch (Exception ex) { System.out.println(ex); } return null; }
public int millisecondsToBytes(AudioFormat fmt, int time) { return (int) (time * (fmt.getSampleRate() * fmt.getChannels() * fmt.getSampleSizeInBits()) / 8000.0); }
public long getLongFramePosition() { return dataLine.getLongFramePosition() * 2 / format.getChannels(); }
private InputStream getFileStream(WaveFileFormat waveFileFormat, InputStream audioStream) throws IOException { // private method ... assumes audioFileFormat is a supported file type // WAVE header fields AudioFormat audioFormat = waveFileFormat.getFormat(); int headerLength = waveFileFormat.getHeaderSize(); int riffMagic = WaveFileFormat.RIFF_MAGIC; int waveMagic = WaveFileFormat.WAVE_MAGIC; int fmtMagic = WaveFileFormat.FMT_MAGIC; int fmtLength = WaveFileFormat.getFmtChunkSize(waveFileFormat.getWaveType()); short wav_type = (short) waveFileFormat.getWaveType(); short channels = (short) audioFormat.getChannels(); short sampleSizeInBits = (short) audioFormat.getSampleSizeInBits(); int sampleRate = (int) audioFormat.getSampleRate(); int frameSizeInBytes = audioFormat.getFrameSize(); int frameRate = (int) audioFormat.getFrameRate(); int avgBytesPerSec = channels * sampleSizeInBits * sampleRate / 8; short blockAlign = (short) ((sampleSizeInBits / 8) * channels); int dataMagic = WaveFileFormat.DATA_MAGIC; int dataLength = waveFileFormat.getFrameLength() * frameSizeInBytes; int length = waveFileFormat.getByteLength(); int riffLength = dataLength + headerLength - 8; byte header[] = null; ByteArrayInputStream headerStream = null; ByteArrayOutputStream baos = null; DataOutputStream dos = null; SequenceInputStream waveStream = null; AudioFormat audioStreamFormat = null; AudioFormat.Encoding encoding = null; InputStream codedAudioStream = audioStream; // if audioStream is an AudioInputStream and we need to convert, do it here... if (audioStream instanceof AudioInputStream) { audioStreamFormat = ((AudioInputStream) audioStream).getFormat(); encoding = audioStreamFormat.getEncoding(); if (AudioFormat.Encoding.PCM_SIGNED.equals(encoding)) { if (sampleSizeInBits == 8) { wav_type = WaveFileFormat.WAVE_FORMAT_PCM; // plug in the transcoder to convert from PCM_SIGNED to PCM_UNSIGNED codedAudioStream = AudioSystem.getAudioInputStream( new AudioFormat( AudioFormat.Encoding.PCM_UNSIGNED, audioStreamFormat.getSampleRate(), audioStreamFormat.getSampleSizeInBits(), audioStreamFormat.getChannels(), audioStreamFormat.getFrameSize(), audioStreamFormat.getFrameRate(), false), (AudioInputStream) audioStream); } } if ((AudioFormat.Encoding.PCM_SIGNED.equals(encoding) && audioStreamFormat.isBigEndian()) || (AudioFormat.Encoding.PCM_UNSIGNED.equals(encoding) && !audioStreamFormat.isBigEndian()) || (AudioFormat.Encoding.PCM_UNSIGNED.equals(encoding) && audioStreamFormat.isBigEndian())) { if (sampleSizeInBits != 8) { wav_type = WaveFileFormat.WAVE_FORMAT_PCM; // plug in the transcoder to convert to PCM_SIGNED_LITTLE_ENDIAN codedAudioStream = AudioSystem.getAudioInputStream( new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, audioStreamFormat.getSampleRate(), audioStreamFormat.getSampleSizeInBits(), audioStreamFormat.getChannels(), audioStreamFormat.getFrameSize(), audioStreamFormat.getFrameRate(), false), (AudioInputStream) audioStream); } } } // Now push the header into a stream, concat, and return the new SequenceInputStream baos = new ByteArrayOutputStream(); dos = new DataOutputStream(baos); // we write in littleendian... dos.writeInt(riffMagic); dos.writeInt(big2little(riffLength)); dos.writeInt(waveMagic); dos.writeInt(fmtMagic); dos.writeInt(big2little(fmtLength)); dos.writeShort(big2littleShort(wav_type)); dos.writeShort(big2littleShort(channels)); dos.writeInt(big2little(sampleRate)); dos.writeInt(big2little(avgBytesPerSec)); dos.writeShort(big2littleShort(blockAlign)); dos.writeShort(big2littleShort(sampleSizeInBits)); // $$fb 2002-04-16: Fix for 4636355: RIFF audio headers could be _more_ spec compliant if (wav_type != WaveFileFormat.WAVE_FORMAT_PCM) { // add length 0 for "codec specific data length" dos.writeShort(0); } dos.writeInt(dataMagic); dos.writeInt(big2little(dataLength)); dos.close(); header = baos.toByteArray(); headerStream = new ByteArrayInputStream(header); waveStream = new SequenceInputStream(headerStream, new NoCloseInputStream(codedAudioStream)); return waveStream; }
/** * Inits AudioInputStream and AudioFileFormat from the data source. * * @throws BasicPlayerException */ protected void initAudioInputStream() throws BasicPlayerException { try { reset(); notifyEvent(BasicPlayerEvent.OPENING, getEncodedStreamPosition(), -1, m_dataSource); if (m_dataSource instanceof URL) { initAudioInputStream((URL) m_dataSource); } else if (m_dataSource instanceof File) { initAudioInputStream((File) m_dataSource); } else if (m_dataSource instanceof InputStream) { initAudioInputStream((InputStream) m_dataSource); } createLine(); // Notify listeners with AudioFileFormat properties. Map properties = null; if (m_audioFileFormat instanceof TAudioFileFormat) { // Tritonus SPI compliant audio file format. properties = ((TAudioFileFormat) m_audioFileFormat).properties(); // Clone the Map because it is not mutable. properties = deepCopy(properties); } else { properties = new HashMap(); } // Add JavaSound properties. if (m_audioFileFormat.getByteLength() > 0) { properties.put("audio.length.bytes", new Integer(m_audioFileFormat.getByteLength())); } if (m_audioFileFormat.getFrameLength() > 0) { properties.put("audio.length.frames", new Integer(m_audioFileFormat.getFrameLength())); } if (m_audioFileFormat.getType() != null) { properties.put("audio.type", (m_audioFileFormat.getType().toString())); } // Audio format. AudioFormat audioFormat = m_audioFileFormat.getFormat(); if (audioFormat.getFrameRate() > 0) { properties.put("audio.framerate.fps", new Float(audioFormat.getFrameRate())); } if (audioFormat.getFrameSize() > 0) { properties.put("audio.framesize.bytes", new Integer(audioFormat.getFrameSize())); } if (audioFormat.getSampleRate() > 0) { properties.put("audio.samplerate.hz", new Float(audioFormat.getSampleRate())); } if (audioFormat.getSampleSizeInBits() > 0) { properties.put("audio.samplesize.bits", new Integer(audioFormat.getSampleSizeInBits())); } if (audioFormat.getChannels() > 0) { properties.put("audio.channels", new Integer(audioFormat.getChannels())); } if (audioFormat instanceof TAudioFormat) { // Tritonus SPI compliant audio format. Map addproperties = ((TAudioFormat) audioFormat).properties(); properties.putAll(addproperties); } // Add SourceDataLine properties.put("basicplayer.sourcedataline", m_line); Iterator<BasicPlayerListener> it = laucher.getBasicPlayerListeners().iterator(); while (it.hasNext()) { BasicPlayerListener bpl = it.next(); bpl.opened(m_dataSource, properties); } m_status = OPENED; notifyEvent(BasicPlayerEvent.OPENED, getEncodedStreamPosition(), -1, null); } catch (LineUnavailableException e) { throw new BasicPlayerException(e); } catch (UnsupportedAudioFileException e) { throw new BasicPlayerException(e); } catch (IOException e) { throw new BasicPlayerException(e); } }
public static final ALoad create(File f) throws AudioException { try { // stream AudioInputStream ais = AudioSystem.getAudioInputStream(f); // make difference between encoded and non-encoded streams, because mp3 // doesn't give streamlength information :-( boolean isEncoded = !ais.getFormat().getEncoding().equals(AudioFormat.Encoding.PCM_UNSIGNED) && !ais.getFormat().getEncoding().equals(AudioFormat.Encoding.PCM_SIGNED) && !ais.getFormat().getEncoding().equals(AudioFormat.Encoding.ALAW) && !ais.getFormat().getEncoding().equals(AudioFormat.Encoding.ULAW); AudioFormat.Encoding targetEncoding = AudioFormat.Encoding.PCM_SIGNED; if (isEncoded) { ais = AudioSystem.getAudioInputStream(targetEncoding, ais); // this is required for mp3 } AudioFormat af = ais.getFormat(); // count size... int sl = 0; if (isEncoded) // if (false) { int st = 0; byte a[] = new byte[4096]; try { while ((st = ais.read(a, 0, a.length - 1)) >= 0) { sl += st; } sl /= ais.getFormat().getChannels() * ais.getFormat().getSampleSizeInBits() / 8; } catch (IOException ioe) { ioe.printStackTrace(); } } else { sl = (int) (ais.getFrameLength() * af.getFrameSize() / af.getChannels() / (af.getSampleSizeInBits() >> 3)); } // stream for data loading ais = AudioSystem.getAudioInputStream(f); targetEncoding = AudioFormat.Encoding.PCM_SIGNED; if (isEncoded) { ais = AudioSystem.getAudioInputStream(targetEncoding, ais); // this is required for mp3 } af = ais.getFormat(); Debug.println(3, "audioformat = " + af.toString()); // search the correct loader... for (int i = 0; i < classList.size(); i++) { ALoad l = classList.get(i); if (l.supports(af)) { l = l.duplicate(); l.setAudioInputStream(ais, sl); l.setFile(f); return l; } } Debug.println(3, "unsupported audioformat = " + af.toString()); throw new AudioException("unsupportedAudioFormat"); } catch (UnsupportedAudioFileException uafe) { Debug.printStackTrace(5, uafe); throw new AudioException("unsupportedAudioFormat"); } catch (IOException ioe) { Debug.printStackTrace(5, ioe); throw new AudioException("unsupportedAudioFormat"); } }