android中如何实现音频裁剪

这篇文章给大家分享的是有关android中如何实现音频裁剪的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。

成都创新互联公司专业为企业提供虎林网站建设、虎林做网站、虎林网站设计、虎林网站制作等企业网站建设、网页设计与制作、虎林企业网站模板建站服务，十年虎林做网站经验，不只是建网站，更提供有价值的思路和整体网络服务。

下面是音频裁剪效果图：

音频编辑项目的整体结构

该音频测试项目的结构其实很简单，大致就是以Fragment为基础的各个界面，以IntentService为基础的后台服务，以及最重要的音频编辑工具类实现。大致结构如下：

1. CutFragment，裁剪页面。选择音频，裁剪音频，播放裁剪后的音频，同时注册了EventBus以便接受后台音频编辑操作发送的消息进行更新。

2. AudioTaskService，音频编辑服务Service。继承自IntentService，可以在后台任务的线程中执行耗时音频编辑操作。

3. AudioTaskCreator，音频编辑任务命令发送器。通过它可以启动音频编辑服务AudioTaskService，并发送具体的编辑操作给它。

4. AudioTaskHandler，音频编辑任务处理器。AudioTaskService接受到的intent任务都交给它去处理。这里具体处理裁剪，合成等操作。

5. AudioEditUtil， 音频编辑工具类。提供裁剪，合成等音频编辑的方法。

6. 另外还有其他相关的音频工具类。

现在我们看看它们之间的主要流程实现：

CutFragment发起音频裁剪任务，同时接收更新音频编辑消息

public class CutFragment extends Fragment {

 ...

 /**
  * 裁剪音频
  */
 private void cutAudio() {

  String path2 = tvAudioPath2.getText().toString();

  if(TextUtils.isEmpty(path2)){
   ToastUtil.showToast("音频路径为空");
   return;
  }

  float startTime = Float.valueOf(etStartTime.getText().toString());
  float endTime = Float.valueOf(etEndTime.getText().toString());

  if(startTime <= 0){
   ToastUtil.showToast("时间不对");
   return;
  }
  if(endTime <= 0){
   ToastUtil.showToast("时间不对");
   return;
  }
  if(startTime >= endTime){
   ToastUtil.showToast("时间不对");
   return;
  }

  //调用AudioTaskCreator发起音频裁剪任务
  AudioTaskCreator.createCutAudioTask(getContext(), path2, startTime, endTime);
 }
 
 /**
  * 接收并更新裁剪消息
  */
 @Subscribe(threadMode = ThreadMode.MAIN) public void onReceiveAudioMsg(AudioMsg msg) {
  if(msg != null && !TextUtils.isEmpty(msg.msg)){
   tvMsgInfo.setText(msg.msg);
   mCurPath = msg.path;
  }
 }

}

AudioTaskCreator启动音频裁剪任务AudioTaskService

public class AudioTaskCreator {
 ...
 /**
  * 启动音频裁剪任务
  * @param context
  * @param path
  */
 public static void createCutAudioTask(Context context, String path, float startTime, float endTime){

  Intent intent = new Intent(context, AudioTaskService.class);
  intent.setAction(ACTION_AUDIO_CUT);
  intent.putExtra(PATH_1, path);
  intent.putExtra(START_TIME, startTime);
  intent.putExtra(END_TIME, endTime);

  context.startService(intent);
 }

}

AudioTaskService服务将接受的Intent任务交给AudioTaskHandler处理

/**
 * 执行后台任务的服务
 */
public class AudioTaskService extends IntentService {

 private AudioTaskHandler mTaskHandler;

 public AudioTaskService() {
  super("AudioTaskService");
 }

 @Override public void onCreate() {
  super.onCreate();

  mTaskHandler = new AudioTaskHandler();
 }

 /**
  * 实现异步任务的方法
  *
  * @param intent Activity传递过来的Intent,数据封装在intent中
  */
 @Override protected void onHandleIntent(Intent intent) {

  if (mTaskHandler != null) {
   mTaskHandler.handleIntent(intent);
  }
 }
}

AudioTaskService服务将接受的Intent任务交给AudioTaskHandler处理，根据不同的Intent action，调用不同的处理方法

/**
 * 
 */
public class AudioTaskHandler {
 public void handleIntent(Intent intent){
  if(intent == null){
   return;
  }

  String action = intent.getAction();

  switch (action){
   case AudioTaskCreator.ACTION_AUDIO_CUT:

   {
    //裁剪
    String path = intent.getStringExtra(AudioTaskCreator.PATH_1);
    float startTime = intent.getFloatExtra(AudioTaskCreator.START_TIME, 0);
    float endTime = intent.getFloatExtra(AudioTaskCreator.END_TIME, 0);
    cutAudio(path, startTime, endTime);
   }
    break;
    
    //其他编辑任务
    ...
    
   default:
   break;
  }
 }
 /**
  * 裁剪音频
  * @param srcPath 源音频路径
  * @param startTime 裁剪开始时间
  * @param endTime 裁剪结束时间
  */
 private void cutAudio(String srcPath, float startTime, float endTime){
  //具体裁剪操作
 } 
}

音频裁剪方法的实现

接下来是音频裁剪的具体操作。还记得上一篇文章说的，音频的裁剪操作都是要基于PCM文件或者WAV文件上进行的，所以对于一般的音频文件都是需要先解码得到PCM文件或者WAV文件，才能进行具体的音频编辑操作。因此音频裁剪操作需要经历以下步骤：

1. 计算解码后的wav音频路径

2. 对源音频进行解码，得到解码后源WAV文件

3. 创建源wav文件和目标WAV音频频的RandomAccessFile，以便对它们后面对它们进行读写操作

4. 根据采样率，声道数，采样位数，和当前时间，计算开始时间和结束时间对应到源文件的具体位置

5. 根据采样率，声道数，采样位数，裁剪音频数据大小等，计算得到wav head文件头byte数据

6. 将wav head文件头byte数据写入到目标文件中

7. 将源文件的开始位置到结束位置的数据复制到目标文件中

8. 删除源wav文件，重命名目标wav文件为源wav文件，即得到最终裁剪后的wav文件

如下，对源音频进行解码，得到解码后的音频文件，然后根据解码音频文件得到Audio音频相关信息，里面记录音频相关的信息如采样率，声道数，采样位数等。

/**
 * 
 */
public class AudioTaskHandler {

 /**
  * 裁剪音频
  * @param srcPath 源音频路径
  * @param startTime 裁剪开始时间
  * @param endTime 裁剪结束时间
  */
 private void cutAudio(String srcPath, float startTime, float endTime){
  String fileName = new File(srcPath).getName();
  String nameNoSuffix = fileName.substring(0, fileName.lastIndexOf('.'));
  fileName = nameNoSuffix + Constant.SUFFIX_WAV;
  String outName = nameNoSuffix + "_cut.wav";

  //裁剪后音频的路径
  String destPath = FileUtils.getAudioEditStorageDirectory() + File.separator + outName;

  //解码源音频，得到解码后的文件
  decodeAudio(srcPath, destPath);

  if(!FileUtils.checkFileExist(destPath)){
   ToastUtil.showToast("解码失败" + destPath);
   return;
  }

  //获取根据解码后的文件得到audio数据
  Audio audio = getAudioFromPath(destPath);

  //裁剪操作
  if(audio != null){
   AudioEditUtil.cutAudio(audio, startTime, endTime);
  }

  //裁剪完成，通知消息
  String msg = "裁剪完成";
  EventBus.getDefault().post(new AudioMsg(AudioTaskCreator.ACTION_AUDIO_CUT, destPath, msg));
 }
 
 /**
  * 获取根据解码后的文件得到audio数据
  * @param path
  * @return
  */
 private Audio getAudioFromPath(String path){
  if(!FileUtils.checkFileExist(path)){
   return null;
  }

  if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN) {
   try {
    Audio audio = Audio.createAudioFromFile(new File(path));
    return audio;
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
  return null;
 } 
}

获取音频文件相关信息

而获取Audio信息其实就是解码时获取MediaFormat，然后获取音频相关的信息的。

/**
 * 音频信息
 */
public class Audio {
  private String path;
  private String name;
  private float volume = 1f;
  private int channel = 2;
  private int sampleRate = 44100;
  private int bitNum = 16;
  private int timeMillis;

  ...

  @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN) public static Audio createAudioFromFile(File inputFile) throws Exception {
    MediaExtractor extractor = new MediaExtractor();
    MediaFormat format = null;
    int i;

    try {
      extractor.setDataSource(inputFile.getPath());
    }catch (Exception ex){
      ex.printStackTrace();
      extractor.setDataSource(new FileInputStream(inputFile).getFD());
    }

    int numTracks = extractor.getTrackCount();
    for (i = 0; i < numTracks; i++) {
      format = extractor.getTrackFormat(i);
      if (format.getString(MediaFormat.KEY_MIME).startsWith("audio/")) {
        extractor.selectTrack(i);
        break;
      }
    }
    if (i == numTracks) {
      throw new Exception("No audio track found in " + inputFile);
    }

    Audio audio = new Audio();
    audio.name = inputFile.getName();
    audio.path = inputFile.getAbsolutePath();
    audio.sampleRate = format.containsKey(MediaFormat.KEY_SAMPLE_RATE) ? format.getInteger(MediaFormat.KEY_SAMPLE_RATE) : 44100;
    audio.channel = format.containsKey(MediaFormat.KEY_CHANNEL_COUNT) ? format.getInteger(MediaFormat.KEY_CHANNEL_COUNT) : 1;
    audio.timeMillis = (int) ((format.getLong(MediaFormat.KEY_DURATION) / 1000.f));

    //根据pcmEncoding编码格式，得到采样精度，MediaFormat.KEY_PCM_ENCODING这个值不一定有
    int pcmEncoding = format.containsKey(MediaFormat.KEY_PCM_ENCODING) ? format.getInteger(MediaFormat.KEY_PCM_ENCODING) : AudioFormat.ENCODING_PCM_16BIT;
    switch (pcmEncoding){
      case AudioFormat.ENCODING_PCM_FLOAT:
        audio.bitNum = 32;
        break;
      case AudioFormat.ENCODING_PCM_8BIT:
        audio.bitNum = 8;
        break;
      case AudioFormat.ENCODING_PCM_16BIT:
      default:
        audio.bitNum = 16;
        break;
    }

    extractor.release();

    return audio;
  }
}

这里要注意，通过MediaFormat获取音频信息的时候，获取采样位数是要先查找MediaFormat.KEY_PCM_ENCODING这个key对应的值，如果是AudioFormat.ENCODING_PCM_8BIT，则是8位采样精度，如果是AudioFormat.ENCODING_PCM_16BIT，则是16位采样精度，如果是AudioFormat.ENCODING_PCM_FLOAT（android 5.0 版本新增的类型），则是32位采样精度。当然可能MediaFormat中没有包含MediaFormat.KEY_PCM_ENCODING这个key信息，这时就使用默认的AudioFormat.ENCODING_PCM_16BIT，即默认的16位采样精度（也可以说2个字节作为一个采样点编码）。

接下来就是真正的裁剪操作了。根据audio中的音频信息得到将要写入的wav文件头信息字节数据，创建随机读写文件，写入文件头数据，然后源随机读写文件移动到指定的开始时间开始读取，目标随机读写文件将读取的数据写入，知道源随机文件读到指定的结束时间停止，这样就完成了音频文件的裁剪操作。

public class AudioEditUtil {
 /**
  * 裁剪音频
  * @param audio 音频信息
  * @param cutStartTime 裁剪开始时间
  * @param cutEndTime 裁剪结束时间
  */
 public static void cutAudio(Audio audio, float cutStartTime, float cutEndTime){
  if(cutStartTime == 0 && cutEndTime == audio.getTimeMillis() / 1000f){
   return;
  }
  if(cutStartTime >= cutEndTime){
   return;
  }

  String srcWavePath = audio.getPath();
  int sampleRate = audio.getSampleRate();
  int channels = audio.getChannel();
  int bitNum = audio.getBitNum();
  RandomAccessFile srcFis = null;
  RandomAccessFile newFos = null;
  String tempOutPath = srcWavePath + ".temp";
  try {

   //创建输入流
   srcFis = new RandomAccessFile(srcWavePath, "rw");
   newFos = new RandomAccessFile(tempOutPath, "rw");

   //源文件开始读取位置，结束读取文件，读取数据的大小
   final int cutStartPos = getPositionFromWave(cutStartTime, sampleRate, channels, bitNum);
   final int cutEndPos = getPositionFromWave(cutEndTime, sampleRate, channels, bitNum);
   final int contentSize = cutEndPos - cutStartPos;

   //复制wav head 字节数据
   byte[] headerData = AudioEncodeUtil.getWaveHeader(contentSize, sampleRate, channels, bitNum);
   copyHeadData(headerData, newFos);

   //移动到文件开始读取处
   srcFis.seek(WAVE_HEAD_SIZE + cutStartPos);

   //复制裁剪的音频数据
   copyData(srcFis, newFos, contentSize);

  } catch (Exception e) {
   e.printStackTrace();

   return;

  }finally {
   //关闭输入流
   if(srcFis != null){
    try {
     srcFis.close();
    } catch (IOException e) {
     e.printStackTrace();
    }
   }
   if(newFos != null){
    try {
     newFos.close();
    } catch (IOException e) {
     e.printStackTrace();
    }
   }
  }

  // 删除源文件,
  new File(srcWavePath).delete();
  //重命名为源文件
  FileUtils.renameFile(new File(tempOutPath), audio.getPath());
 }
}

计算裁剪时间点对应文件中数据的位置

需要注意的是根据时间计算在文件中的位置，它是这么实现的：

 /**
  * 获取wave文件某个时间对应的数据位置
  * @param time 时间
  * @param sampleRate 采样率
  * @param channels 声道数
  * @param bitNum 采样位数
  * @return
  */
 private static int getPositionFromWave(float time, int sampleRate, int channels, int bitNum) {
  int byteNum = bitNum / 8;
  int position = (int) (time * sampleRate * channels * byteNum);

  //这里要特别注意，要取整（byteNum * channels）的倍数
  position = position / (byteNum * channels) * (byteNum * channels);

  return position;
 }

这里要特别注意，因为time是个float的数，所以计算后的position取整它并不一定是（byteNum * channels）的倍数，而position的位置必须要是（byteNum * channels）的倍数，否则后面的音频数据就全部乱了，那么在播放时就是撒撒撒撒的噪音，而不是原来的声音了。原因是音频数据是按照一个个采样点来计算的，一个采样点的大小就是（byteNum * channels），所以要取（byteNum * channels）的整数倍。

写入wav文件头信息

接着看看往新文件写入wav文件头是怎么实现的，这个在上一篇中也是有讲过的，不过还是列出来吧：

/**
  * 获取Wav header 字节数据
  * @param totalAudioLen 整个音频PCM数据大小
  * @param sampleRate 采样率
  * @param channels 声道数
  * @param bitNum 采样位数
  * @throws IOException
  */
 public static byte[] getWaveHeader(long totalAudioLen, int sampleRate, int channels, int bitNum) throws IOException {

  //总大小，由于不包括RIFF和WAV，所以是44 - 8 = 36，在加上PCM文件大小
  long totalDataLen = totalAudioLen + 36;
  //采样字节byte率
  long byteRate = sampleRate * channels * bitNum / 8;

  byte[] header = new byte[44];
  header[0] = 'R'; // RIFF
  header[1] = 'I';
  header[2] = 'F';
  header[3] = 'F';
  header[4] = (byte) (totalDataLen & 0xff);//数据大小
  header[5] = (byte) ((totalDataLen >> 8) & 0xff);
  header[6] = (byte) ((totalDataLen >> 16) & 0xff);
  header[7] = (byte) ((totalDataLen >> 24) & 0xff);
  header[8] = 'W';//WAVE
  header[9] = 'A';
  header[10] = 'V';
  header[11] = 'E';
  //FMT Chunk
  header[12] = 'f'; // 'fmt '
  header[13] = 'm';
  header[14] = 't';
  header[15] = ' ';//过渡字节
  //数据大小
  header[16] = 16; // 4 bytes: size of 'fmt ' chunk
  header[17] = 0;
  header[18] = 0;
  header[19] = 0;
  //编码方式 10H为PCM编码格式
  header[20] = 1; // format = 1
  header[21] = 0;
  //通道数
  header[22] = (byte) channels;
  header[23] = 0;
  //采样率，每个通道的播放速度
  header[24] = (byte) (sampleRate & 0xff);
  header[25] = (byte) ((sampleRate >> 8) & 0xff);
  header[26] = (byte) ((sampleRate >> 16) & 0xff);
  header[27] = (byte) ((sampleRate >> 24) & 0xff);
  //音频数据传送速率,采样率*通道数*采样深度/8
  header[28] = (byte) (byteRate & 0xff);
  header[29] = (byte) ((byteRate >> 8) & 0xff);
  header[30] = (byte) ((byteRate >> 16) & 0xff);
  header[31] = (byte) ((byteRate >> 24) & 0xff);
  // 确定系统一次要处理多少个这样字节的数据，确定缓冲区，通道数*采样位数
  header[32] = (byte) (channels * 16 / 8);
  header[33] = 0;
  //每个样本的数据位数
  header[34] = 16;
  header[35] = 0;
  //Data chunk
  header[36] = 'd';//data
  header[37] = 'a';
  header[38] = 't';
  header[39] = 'a';
  header[40] = (byte) (totalAudioLen & 0xff);
  header[41] = (byte) ((totalAudioLen >> 8) & 0xff);
  header[42] = (byte) ((totalAudioLen >> 16) & 0xff);
  header[43] = (byte) ((totalAudioLen >> 24) & 0xff);

  return header;
 }

这里比上一篇中精简了一些，只要传入音频数据大小，采样率，声道数，采样位数这四个参数，就可以得到wav文件头信息了，然后再将它写入到wav文件开始处。

/**
  * 复制wav header 数据
  *
  * @param headerData wav header 数据
  * @param fos 目标输出流
  */
 private static void copyHeadData(byte[] headerData, RandomAccessFile fos) {
  try {
   fos.seek(0);
   fos.write(headerData);
  } catch (Exception ex) {
   ex.printStackTrace();
  }
 }

写入wav文件裁剪部分的音频数据

接下来就是将裁剪部分的音频数据写入到文件中了。这里要先移动源文件的读取位置到裁剪起始处，即

//移动到文件开始读取处
srcFis.seek(WAVE_HEAD_SIZE + cutStartPos);

这样就可以从源文件读取裁剪处的数据了

 /**
  * 复制数据
  *
  * @param fis 源输入流
  * @param fos 目标输出流
  * @param cooySize 复制大小
  */
 private static void copyData(RandomAccessFile fis, RandomAccessFile fos, final int cooySize) {

  byte[] buffer = new byte[2048];
  int length;
  int totalReadLength = 0;

  try {

   while ((length = fis.read(buffer)) != -1) {

    fos.write(buffer, 0, length);

    totalReadLength += length;

    int remainSize = cooySize - totalReadLength;
    if (remainSize <= 0) {
     //读取指定位置完成
     break;
    } else if (remainSize < buffer.length) {
     //离指定位置的大小小于buffer的大小,换remainSize的buffer
     buffer = new byte[remainSize];
    }
   }
  } catch (Exception ex) {
   ex.printStackTrace();
  }
 }

上面代码目的就是读取startPos开始，到startPos+copySize之间的数据。

感谢各位的阅读！关于“android中如何实现音频裁剪”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，让大家可以学到更多知识，如果觉得文章不错，可以把它分享出去让更多的人看到吧！