实例解析使用Java实现基本的音频播放器的编写要点

更新时间：2016年01月07日 17:25:37 作者：cping

这篇文章主要介绍了使用Java实现基本的音频播放器的代码要点实例分享,包括音频文件的循环播放等功能实现的关键点,需要的朋友可以参考下

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.framework.game.net;

import org.loon.framework.game.helper.StreamHelper;

/** *//**
 * <p>
 * Title: LoonFramework
 * </p>
 * <p>
 * Description:Loonframework专用uri(统一资源标识符)
 * </p>
 * <p>
 * Copyright: Copyright (c) 2007
 * </p>
 * <p>
 * Company: LoonFramework
 * </p>
 * 
 * @author chenpeng
 * @email：ceponline@yahoo.com.cn
 * @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.framework.game.net.URI;

/** *//**
 * <p>
 * Title: LoonFramework
 * </p>
 * <p>
 * Description:用以获得并缓存声音文件数据（更进一步内容操作请见Loonframework-game框架）
 * </p>
 * <p>
 * Copyright: Copyright (c) 2007
 * </p>
 * <p>
 * Company: LoonFramework
 * </p>
 * 
 * @author chenpeng
 * @email：ceponline@yahoo.com.cn
 * @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.framework.game.net.URI;

/** *//**
 * <p>
 * Title: LoonFramework
 * </p>
 * <p>
 * Description:用以进行声音文件操作(仅为Loonframework中部分方法，更详细请参见Loonframework-game框架)
 * </p>
 * <p>
 * Copyright: Copyright (c) 2007
 * </p>
 * <p>
 * Company: LoonFramework
 * </p>
 * 
 * @author chenpeng
 * @email：ceponline@yahoo.com.cn
 * @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.framework.game.net.URI;
import org.loon.framework.game.sound.SoundData;
import org.loon.framework.game.sound.SoundPlay;

/** *//**
 * <p>Title: LoonFramework</p>
 * <p>Description:SoundPlay播放测试</p>
 * <p>Copyright: Copyright (c) 2007</p>
 * <p>Company: LoonFramework</p>
 * @author chenpeng 
 * @email：ceponline@yahoo.com.cn 
 * @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("http://looframework.sourceforge.net/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) ...{
      }
    }

您可能感兴趣的文章:

Java
音频

spring中@ComponentScan自动扫描并指定扫描规则
本文主要介绍了spring中@ComponentScan自动扫描并指定扫描规则，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2023-04-04
浅聊一下Spring中Bean的配置细节
我们知道，当写完一个普通的 Java 类后，想让 Spring IoC 容器在创建类的实例对象时使用构造方法完成实例对象的依赖注入，那么就需要在配置元数据中写好类的 Bean 定义，包括各种标签的属性。所以本文我们来说说这其中的配置细节,需要的朋友可以参考下
2023-07-07
使用Mybatis的Batch Insert Support 实现批量插入
这篇文章主要介绍了使用Mybatis的Batch Insert Support 实现批量插入。具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2022-07-07
SpringBoot中请求参数绑定及使用详解
这篇文章主要介绍了SpringBoot中请求参数绑定及使用详解,在Web应用程序中，请求参数绑定是非常重要的操作,Spring Boot框架使得请求参数绑定变得非常简单，通过使用注解和预定义的类可以轻松地实现此操作,需要的朋友可以参考下
2023-08-08
解析分别用递归与循环的方式求斐波那契数列的实现方法
本篇文章是对分别用递归与循环的方式求斐波那契数列的方法进行了详细的分析介绍，需要的朋友参考下
2013-06-06
Java实现扫雷游戏详细代码讲解
windows自带的游戏《扫雷》是陪伴了无数人的经典游戏，本文将利用Java语言实现这一经典的游戏，文中的示例代码讲解详细，感兴趣的可以学习一下
2022-05-05
spring boot打包成可执行jar包
本篇文章主要介绍了spring boot打包成可执行jar包，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-10-10
SpringBoot下载文件遇到文件损坏等问题解决方案
调用接口下载spring boot工程的resources目录下的excel模板文件,非常常见的一个文件下载功能,但是却容易遇到很多坑,下面总结记录下
2023-10-10
SpringBoot中Controller的传参方式详细讲解
这篇文章主要介绍了SpringBoot在Controller层接收参数的常用方法，Controller接收参数的常用方式总体可以分为三类，第一类是Get请求通过拼接url进行传递，第二类是Post请求通过请求体进行传递，第三类是通过请求头部进行参数传递，下面我们来详细看看
2023-01-01
页面的缓存与不缓存设置及html页面中meta的作用
这篇文章主要介绍了页面的缓存与不缓存设置及html页面中meta的作用的相关资料,需要的朋友可以参考下
2016-05-05

实例解析使用Java实现基本的音频播放器的编写要点

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具