Java音频播放，因为必须依赖到本地环境，所以JAVA在音频处理方面优势不大,或者说打从Java体系开发时就没太多的考虑音频播放因素，要知道最早的Java 1.1版本中，没有后来的javax.sound包，音频只能通过Applet包调取……
遗憾的是，在图形程序开发中，我们的程序却又难免要使用到背景音乐、效果音等配合图像操作，哎，这实在是Sun大神给我们开的一个不打不小的玩笑。万幸后来Sun大神开眼，提供了javax.sound包，才解救我们于水深火热当中~
但是继之而来的问题是，在javax.sound包的使用中，如同Java多媒体工具类的通病般，并没有提供十分完善的释放机制。如果我们做Windows 开发，调用MediaPlayer反复N次可能没也什么大碍，但在Java中，如果音频程序反复运行的话,极容易出现内存累计损耗的情况,以至于最后抛出一个java.lang.OutOfMemoryError,然后……程序就挂了，用户就傻了，我们就疯了……
这已经是“是可忍孰不可忍 ”的问题了，有鉴于此，所以在本人的Loonframework框架开发中，二次整合了sound下的相关方法，力求以最简单的代码，做出最完善的音频控制类。在Loonframework-game还没有大成的现在，先摘录一部分方法，以供各位看官——拍砖！
对应网络资源调用，在Loonframework中建立了自己的uri用类，基本内容如下：
(其中StreamHelper为Loonframework自己的流媒体控制类,getHttpStream方法请自行替换。)
package org.loon.;
import org.loon.framework.game.helper.StreamHelper;
/** *//**
*
* Title: LoonFramework
*
*
* Description:Loonframework专用uri(统一资源标识符)
*
*
* Copyright: Copyright (c)
*
*
* Company: LoonFramework
*
*
* @author chenpeng
* @email：ceponline@
* @version 0.1
*/
public class URI ...{
//传输协议类型
public static final int _L_URI_HTTP = 1;
public static final int _L_URI_UDP = 2;
private String _uri;
private int _type;
/** *//**
* 析构函数，用于注入uri和type
*
* @param uri
* @param type
*/
public URI(String uri, int type) ...{
_uri = new String(uri);
_type = type;
}
/** *//**
* 析构函数，用于注入uri
*
* @param uri
*/
public URI(String uri) ...{
_uri = new String(uri);
_type = URI._L_URI_HTTP;
}
/** *//**
* 返回uri所在位置资源的byte数组。
*
* @return
*/
public byte[] getData() ...{
if (_uri == null) ...{
return null;
}
return StreamHelper.getHttpStream(_uri);
}
public String getURI() ...{
return _uri;
}
public int getType() ...{
return _type;
}
}
在Loonframework框架中,定制了一个基础的SoundData类,用以统一管理音频数据源。
package org.loon.framework.game.sound;
import org.loon.framework.game.helper.StreamHelper;
import org.loon..URI;
/** *//**
*
* Title: LoonFramework
*
*
* Description:用以获得并缓存声音文件数据(更进一步内容操作请见Loonframework-game框架)
*
*
* Copyright: Copyright (c)
*
*
* Company: LoonFramework
*
*
* @author chenpeng
* @email：ceponline@
* @version 0.1
*/
public class SoundData ...{
private byte[] _data;
private boolean _loop;
private int _type;
public static final int _L_SOUNDTYPE_MIDI = 1;
public static final int _L_SOUNDTYPE_WAV = 2;
/** *//**
* 析构函数，用以注入uri,type,loop
*
* @param uri
* @param type
* @param loop
*/
public SoundData(URI uri, int type, boolean loop) ...{
if (uri != null) ...{
_data = uri.getData();
}
_type = type;
_loop = loop;
}
/** *//**
* 析构函数，用以注入data,type,loop
*
* @param data
* @param type
* @param loop
*/
public SoundData(byte[] data, int type, boolean loop) ...{
if (data != null && data.length > 0) ...{
_data = new byte[data.length];
// 直接copy byte数组
System.arraycopy(data, 0, _data, 0, _data.length);
}
_type = type;
_loop = loop;
}
/** *//**
* 析构函数，用以注入限定位置的resName,type,loop
* @param resName
* @param type
* @param loop
*/
public SoundData(String resName, int type, boolean loop) ...{
this(StreamHelper.GetDataSource(resName),type,loop);
}
public byte[] getData() ...{
return _data;
}
public boolean getLoop() ...{
return _loop;
}
public void setLoop(boolean loop) ...{
_loop = loop;
}
public int getType() ...{
return _type;
}
}
Loonframework将音频播放相关方法，封装与SoundPlay之中，程序员可以不必理会javax.sound内部细节，而直接调用SoundPlay完成相关操作。
package org.loon.framework.game.sound;
import java.io.ByteArrayInputStream;
import javax.sound.midi.MetaEventListener;
import javax.sound.midi.MetaMessage;
import javax.sound.midi.MidiSystem;
import javax.sound.midi.Sequence;
import javax.sound.midi.Sequencer;
import javax.sound.sampled.AudioFileFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.sound.sampled.DataLine;
import org.loon..URI;
/** *//**
*
* Title: LoonFramework
*
*
* Description:用以进行声音文件操作(仅为Loonframework中部分方法，更详细请参见Loonframework-game框架)
*
*
* Copyright: Copyright (c)
*
*
* Company: LoonFramework
*
*
* @author chenpeng
* @email：ceponline@
* @version 0.1
*/
public class SoundPlay implements MetaEventListener, Runnable ...{
private int _sleepTime;
private Clip _audio;
private Sequencer _midi;
private boolean _loop;
private int _soundType;
private boolean _playing;
private Thread _thread = null;
private boolean _isRun = false;
/** *//**
* 析构函数，初始化SoundPlay
*
*/
public SoundPlay() ...{
_loop = false;
_soundType = 0;
_sleepTime = 1000;
_playing = false;
}
// 载入声音文件
public boolean load(SoundData data) ...{
reset();
if (data == null || data.getData() == null) ...{
return false;
}
return init(data.getData(), data.getType(), data.getLoop());
}
/** *//**
* 直接播放url文件
*
* @param uri
* @param ftype
* @param loop
* @return
*/
public boolean load(URI uri, int ftype, boolean loop) ...{
// 刷新数据
reset();
if (uri == null) ...{
return false;
}
// 获得SoundData
SoundData data = new SoundData(uri, ftype, loop);
if (data == null || data.getData() == null) ...{
return false;
}
return init(data.getData(), data.getType(), data.getLoop());
}
/** *//**
* 初始化sound相关数据
*
* @param data
* @param ftype
* @param loop
* @return
*/
private boolean init(byte[] data, int ftype, boolean loop) ...{
boolean result = false;
ByteArrayInputStream bis = null;
try ...{
bis = new ByteArrayInputStream(data);
} catch (Exception e) ...{
bis = null;
}
if (bis == null) ...{
return false;
}
// 判断类型
switch (ftype) ...{
// MIDI
case SoundData._L_SOUNDTYPE_MIDI:
// 当MIDI不存在时
if (_midi == null) ...{
try ...{
// 获得Sequencer
_midi = MidiSystem.getSequencer();
_midi.open();
} catch (Exception ex) ...{
_midi = null;
}
if (_midi != null) ...{
_midi.addMetaEventListener(this);
}
}
// 当MIDI依旧未获得时
if (_midi != null) ...{
// 重新创建Sequence
Sequence sc = null;
try ...{
sc = MidiSystem.getSequence(bis);
} catch (Exception e) ...{
sc = null;
}
if (sc != null) ...{
try ...{
_midi.setSequence(sc);
// 获得是否循环播放
_loop = loop;
// 获得是否载入
result = true;
} catch (Exception ee) ...{
}
// 获得声音类型
_soundType = SoundData._L_SOUNDTYPE_MIDI;
}
}
try ...{
bis.close();
} catch (Exception ee) ...{
}
break;
// Wav
case SoundData._L_SOUNDTYPE_WAV:
AudioFileFormat type = null;
// 获得Audio
try ...{
type = AudioSystem.getAudioFileFormat(bis);
} catch (Exception e) ...{
type = null;
}
// 关闭流
try ...{
bis.close();
} catch (Exception ex) ...{
}
if (type == null) ...{
return false;
}
// 根据指定信息构造数据行的信息对象
DataLine.Info di = new DataLine.Info(Clip.class, type.getFormat());
// 转为Clip
try ...{
_audio = (Clip) AudioSystem.getLine(di);
} catch (Exception e) ...{
}
// 播放文件
try ...{
_audio.open(type.getFormat(), data, 0, data.length);
_loop = loop;
result = true;
} catch (Exception e) ...{
}
// 获得文件类型
_soundType = SoundData._L_SOUNDTYPE_WAV;
break;
}
return result;
}
public boolean play(SoundData data) ...{
if (!load(data)) ...{
return false;
}
return play();
}
public boolean play() ...{
switch (_soundType) ...{
case SoundData._L_SOUNDTYPE_MIDI:
try ...{
_midi.start();
_playing = true;
_soundType = SoundData._L_SOUNDTYPE_MIDI;
} catch (Exception ee) ...{
}
break;
case SoundData._L_SOUNDTYPE_WAV:
if (_audio != null) ...{
if (_loop) ...{
// 设定循环
_audio.setLoopPoints(0, -1);
_audio.setFramePosition(0);
_audio.loop(Clip.LOOP_CONTINUOUSLY);
} else ...{
// 强制设定播放位置至0
_audio.setFramePosition(0);
_audio.start();
}
_playing = true;
}
break;
}
return _playing;
}
/** *//**
* 自动播放，循环停止后结束。
*
* @param data
* @return
*/
public boolean AutoPlay(SoundData data) ...{
if (!load(data)) ...{
return false;
}
return AutoPlay();
}
/** *//**
* 自动播放，循环停止后结束。
*
* @return
*/
public boolean AutoPlay() ...{
_isRun = true;
_thread = new Thread(this);
_thread.start();
return _playing;
}
/** *//**
* 停止播放
*/
public void stop() ...{
if (_audio != null && _audio.isActive()) ...{
try ...{
_audio.stop();
} catch (Exception e) ...{
}
}
if (_midi != null) ...{
_midi.stop();
}
_playing = false;
_isRun = false;
}
/** *//**
* 释放数据
*
*/
public void reset() ...{
stop();
_loop = false;
_soundType = 0;
if (_midi != null) ...{
_midi.close();
_midi = null;
}
if (_audio != null && _audio.isOpen()) ...{
_audio.close();
_audio = null;
}
_isRun = false;
_thread = null;
}
/** *//**
* 设定MetaMessage
*/
public void meta(MetaMessage meta) ...{
// 判断是否循环播放MIDI
if (_loop && _soundType == SoundData._L_SOUNDTYPE_MIDI
&& meta.getType() == 47) ...{
if (_midi != null && _midi.isOpen()) ...{
_midi.setMicrosecondPosition(0);
_midi.start();
}
}
}
public void run() ...{
while (_isRun) ...{
play();
// 因为播放类型唯一，所以只会返回一个_playing结果,以此判定。
if (_midi != null) ...{
_playing = _midi.isRunning();
}
if (_audio != null) ...{
_playing = _audio.isRunning();
}
// 当播放停止
if (!_playing) ...{
// 释放
reset();
}
try ...{
Thread.sleep(_sleepTime);
} catch (InterruptedException e) ...{
e.printStackTrace();
}
}
}
public int getSleepTime() ...{
return _sleepTime;
}
/** *//**
* 设定AutoPlay线程循环时间。
*
* @param time
*/
public void setSleepTime(int time) ...{
_sleepTime = time;
}
}
这时我们需要面对的，仅是封装为实体的SoundData数据和SoundPlay操作，而不必和繁复的javax.sound再打交道。
调用方法如下：
package org.test;
import org.loon.framework.game.helper.StreamHelper;
import org.loon..URI;
import org.loon.framework.game.sound.SoundData;
import org.loon.framework.game.sound.SoundPlay;
/** *//**
*
Title: LoonFramework
*
Description:SoundPlay播放测试
*
Copyright: Copyright (c)
*
Company: LoonFramework
* @author chenpeng
* @email：ceponline@
* @version 0.1
*/
public class SoundPlayTest ...{
static void selectPlay(int ftype)...{
SoundData data=null;
switch(ftype)...{
//通过loonframework下uri从网络播放音乐
case 0:
data=new SoundData(new URI("/midi/谁是大英雄.mid"),SoundData._L_SOUNDTYPE_MIDI,false);
break;
//通过本地资源下音乐文件的byte[]对象播放音乐
case 1:
byte[] bytes=StreamHelper.GetResourceData("/midi/谁是大英雄.mid");
data=new SoundData(bytes,SoundData._L_SOUNDTYPE_MIDI,false);
break;
//通过音乐文件路径播放音乐
case 2:
data=new SoundData("C:/谁是大英雄.mid",SoundData._L_SOUNDTYPE_MIDI,false);
break;
}
SoundPlay play=new SoundPlay();
//AutoPlay与Play方法的区别在于,AutoPlay播放完毕会自动停止并释放资源，play需手动中止。
//play.play(data);
play.AutoPlay(data);
}
public static void main(String[]args)...{
selectPlay(2);
}
}
更详细方法，会待Loonframework-game完全公布后，再进行解释。
另：由于StreamHelper关联其他Loonframework中方法，暂不给出，inputStream转byte[]可用如下写法：
//is为获得的inputStream
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
//用于承接byte[]
byte[] arrayByte = null;
try ...{
// 每次传输大小为4096
byte[] bytes = new byte[4096];
bytes = new byte[is.available()];
int read;
while ((read = is.read(bytes)) >= 0) ...{
byteArrayOutputStream.write(bytes, 0, read);
}
arrayByte = byteArrayOutputStream.toByteArray();
} catch (IOException e) ...{
return null;
} finally ...{
try ...{
if (byteArrayOutputStream != null) ...{
byteArrayOutputStream.close();
byteArrayOutputStream = null;
}
if (is != null) ...{
is.close();
is = null;
}
} catch (IOException e) ...{
}
}
