Android音频编辑之音频转换PCM与WAV

//采样率 * 通道数 * 采样位数/8 * 秒数
8000 * 1 * 8/8 * 60 = 480000，大约480k

//采样率 * 通道数 * 采样位数/8 * 秒数
44100 * 2 * 16/8 * 60 = 10584000，大约10m

 /**
 * 将音乐文件解码
 *
 * @param musicfileurl 源文件路径
 * @param decodefileurl 解码文件路径
 * @param startmicroseconds 开始时间 微秒
 * @param endmicroseconds 结束时间 微秒
 * @param decodeoperateinterface 解码过程回调
 */
 private boolean decodemusicfile(string musicfileurl, string decodefileurl,
  long startmicroseconds, long endmicroseconds, decodeoperateinterface decodeoperateinterface) {

 //采样率，声道数，时长，音频文件类型
 int samplerate = 0;
 int channelcount = 0;
 long duration = 0;
 string mime = null;

 //mediaextractor, mediaformat, mediacodec
 mediaextractor mediaextractor = new mediaextractor();
 mediaformat mediaformat = null;
 mediacodec mediacodec = null;

 //给媒体信息提取器设置源音频文件路径
 try {
  mediaextractor.setdatasource(musicfileurl);
 }catch (exception ex){
  ex.printstacktrace();
  try {
  mediaextractor.setdatasource(new fileinputstream(musicfileurl).getfd());
  } catch (exception e) {
  e.printstacktrace();
  logutil.e("设置解码音频文件路径错误");
  }
 }

 //获取音频格式轨信息
 mediaformat = mediaextractor.gettrackformat(0);

 //从音频格式轨信息中读取 采样率，声道数，时长，音频文件类型
 samplerate = mediaformat.containskey(mediaformat.key_sample_rate) ? mediaformat.getinteger(
  mediaformat.key_sample_rate) : 44100;
 channelcount = mediaformat.containskey(mediaformat.key_channel_count) ? mediaformat.getinteger(
  mediaformat.key_channel_count) : 1;
 duration = mediaformat.containskey(mediaformat.key_duration) ? mediaformat.getlong(
  mediaformat.key_duration) : 0;
 mime = mediaformat.containskey(mediaformat.key_mime) ? mediaformat.getstring(mediaformat.key_mime)
   : "";

 logutil.i("歌曲信息track info: mime:"
  + mime
  + " 采样率samplerate:"
  + samplerate
  + " channels:"
  + channelcount
  + " duration:"
  + duration);

 if (textutils.isempty(mime) || !mime.startswith("audio/")) {
  logutil.e("解码文件不是音频文件mime:" + mime);
  return false;
 }

 if (mime.equals("audio/ffmpeg")) {
  mime = "audio/mpeg";
  mediaformat.setstring(mediaformat.key_mime, mime);
 }

 if (duration <= 0) {
  logutil.e("音频文件duration为" + duration);
  return false;
 }

 //解码的开始时间和结束时间
 startmicroseconds = math.max(startmicroseconds, 0);
 endmicroseconds = endmicroseconds < 0 ? duration : endmicroseconds;
 endmicroseconds = math.min(endmicroseconds, duration);

 if (startmicroseconds >= endmicroseconds) {
  return false;
 }

 //创建一个解码器
 try {
  mediacodec = mediacodec.createdecoderbytype(mime);

  mediacodec.configure(mediaformat, null, null, 0);
 } catch (exception e) {
  logutil.e("解码器configure出错");
  return false;
 }

 //得到输出pcm文件的路径
 decodefileurl = decodefileurl.substring(0, decodefileurl.lastindexof("."));
 string pcmfilepath = decodefileurl + ".pcm";

 //后续解码操作
 getdecodedata(mediaextractor, mediacodec, pcmfilepath, samplerate, channelcount,
  startmicroseconds, endmicroseconds, decodeoperateinterface);

 return true;
 }

 /**
 * 解码数据
 */
 private void getdecodedata(mediaextractor mediaextractor, mediacodec mediacodec,
  string decodefileurl, int samplerate, int channelcount, final long startmicroseconds,
  final long endmicroseconds, final decodeoperateinterface decodeoperateinterface) {

 //初始化解码状态，未解析完成
 boolean decodeinputend = false;
 boolean decodeoutputend = false;

 //当前读取采样数据的大小
 int sampledatasize;
 //当前输入数据的bytebuffer序号，当前输出数据的bytebuffer序号
 int inputbufferindex;
 int outputbufferindex;
 //音频文件的采样位数字节数，= 采样位数/8
 int bytenumber;

 //上一次的解码操作时间，当前解码操作时间，用于通知回调接口
 long decodenoticetime = system.currenttimemillis();
 long decodetime;

 //当前采样的音频时间，比如在当前音频的第40秒的时候
 long presentationtimeus = 0;

 //定义编解码的超时时间
 final long timeoutus = 100;

 //存储输入数据的bytebuffer数组，输出数据的bytebuffer数组
 bytebuffer[] inputbuffers;
 bytebuffer[] outputbuffers;

 //当前编解码器操作的 输入数据bytebuffer 和 输出数据bytebuffer，可以从targetbuffer中获取解码后的pcm数据
 bytebuffer sourcebuffer;
 bytebuffer targetbuffer;

 //获取输出音频的媒体格式信息
 mediaformat outputformat = mediacodec.getoutputformat();

 mediacodec.bufferinfo bufferinfo;

 bytenumber = (outputformat.containskey("bit-width") ? outputformat.getinteger("bit-width") : 0) / 8;

 //开始解码操作
 mediacodec.start();

 //获取存储输入数据的bytebuffer数组，输出数据的bytebuffer数组
 inputbuffers = mediacodec.getinputbuffers();
 outputbuffers = mediacodec.getoutputbuffers();

 mediaextractor.selecttrack(0);

 //当前解码的缓存信息，里面的有效数据在offset和offset+size之间
 bufferinfo = new mediacodec.bufferinfo();

 //获取解码后文件的输出流
 bufferedoutputstream bufferedoutputstream =
  filefunction.getbufferedoutputstreamfromfile(decodefileurl);

 //开始进入循环解码操作，判断读入源音频数据是否完成，输出解码音频数据是否完成
 while (!decodeoutputend) {
  if (decodeinputend) {
  return;
  }

  decodetime = system.currenttimemillis();

  //间隔1秒通知解码进度
  if (decodetime - decodenoticetime > constant.onesecond) {
  final int decodeprogress =
   (int) ((presentationtimeus - startmicroseconds) * constant.normalmaxprogress
    / endmicroseconds);

  if (decodeprogress > 0) {
   notifyprogress(decodeoperateinterface, decodeprogress);
  }

  decodenoticetime = decodetime;
  }

  try {

  //操作解码输入数据

  //从队列中获取当前解码器处理输入数据的bytebuffer序号
  inputbufferindex = mediacodec.dequeueinputbuffer(timeoutus);

  if (inputbufferindex >= 0) {
   //取得当前解码器处理输入数据的bytebuffer
   sourcebuffer = inputbuffers[inputbufferindex];
   //获取当前bytebuffer，编解码器读取了多少采样数据
   sampledatasize = mediaextractor.readsampledata(sourcebuffer, 0);

   //如果当前读取的采样数据<0，说明已经完成了读取操作
   if (sampledatasize < 0) {
   decodeinputend = true;
   sampledatasize = 0;
   } else {
   presentationtimeus = mediaextractor.getsampletime();
   }

   //然后将当前bytebuffer重新加入到队列中交给编解码器做下一步读取操作
   mediacodec.queueinputbuffer(inputbufferindex, 0, sampledatasize, presentationtimeus,
    decodeinputend ? mediacodec.buffer_flag_end_of_stream : 0);

   //前进到下一段采样数据
   if (!decodeinputend) {
   mediaextractor.advance();
   }

  } else {
   //logutil.e("inputbufferindex" + inputbufferindex);
  }

  //操作解码输出数据

  //从队列中获取当前解码器处理输出数据的bytebuffer序号
  outputbufferindex = mediacodec.dequeueoutputbuffer(bufferinfo, timeoutus);

  if (outputbufferindex < 0) {
   //输出bytebuffer序号<0，可能是输出缓存变化了，输出格式信息变化了
   switch (outputbufferindex) {
   case mediacodec.info_output_buffers_changed:
    outputbuffers = mediacodec.getoutputbuffers();
    logutil.e(
     "mediacodec.info_output_buffers_changed [audiodecoder]output buffers have changed.");
    break;
   case mediacodec.info_output_format_changed:
    outputformat = mediacodec.getoutputformat();

    samplerate =
     outputformat.containskey(mediaformat.key_sample_rate) ? outputformat.getinteger(
      mediaformat.key_sample_rate) : samplerate;
    channelcount =
     outputformat.containskey(mediaformat.key_channel_count) ? outputformat.getinteger(
      mediaformat.key_channel_count) : channelcount;
    bytenumber =
     (outputformat.containskey("bit-width") ? outputformat.getinteger("bit-width") : 0)
      / 8;

    logutil.e(
     "mediacodec.info_output_format_changed [audiodecoder]output format has changed to "
      + mediacodec.getoutputformat());
    break;
   default:
    //logutil.e("error [audiodecoder] dequeueoutputbuffer returned " + outputbufferindex);
    break;
   }
   continue;
  }

  //取得当前解码器处理输出数据的bytebuffer
  targetbuffer = outputbuffers[outputbufferindex];

  byte[] sourcebytearray = new byte[bufferinfo.size];

  //将解码后的targetbuffer中的数据复制到sourcebytearray中
  targetbuffer.get(sourcebytearray);
  targetbuffer.clear();

  //释放当前的输出缓存
  mediacodec.releaseoutputbuffer(outputbufferindex, false);

  //判断当前是否解码数据全部结束了
  if ((bufferinfo.flags & mediacodec.buffer_flag_end_of_stream) != 0) {
   decodeoutputend = true;
  }

  //sourcebytearray就是最终解码后的采样数据
  //接下来可以对这些数据进行采样位数，声道的转换，但这是可选的，默认是和源音频一样的声道和采样位数
  if (sourcebytearray.length > 0 && bufferedoutputstream != null) {
   if (presentationtimeus < startmicroseconds) {
   continue;
   }

   //采样位数转换，按自己需要是否实现
   byte[] convertbytenumberbytearray =
    convertbytenumber(bytenumber, constant.exportbytenumber, sourcebytearray);

   //声道转换，按自己需要是否实现
   byte[] resultbytearray = convertchannelnumber(channelcount, constant.exportchannelnumber,
    constant.exportbytenumber, convertbytenumberbytearray);

   //将解码后的pcm数据写入到pcm文件
   try {
   bufferedoutputstream.write(resultbytearray);
   } catch (exception e) {
   logutil.e("输出解压音频数据异常" + e);
   }
  }

  if (presentationtimeus > endmicroseconds) {
   break;
  }
  } catch (exception e) {
  logutil.e("getdecodedata异常" + e);
  }
 }

 if (bufferedoutputstream != null) {
  try {
  bufferedoutputstream.close();
  } catch (ioexception e) {
  logutil.e("关闭bufferedoutputstream异常" + e);
  }
 }

 //重置采样率，按自己需要是否实现
 if (samplerate != constant.exportsamplerate) {
  resample(samplerate, decodefileurl);
 }

 notifyprogress(decodeoperateinterface, 100);

 //释放mediacodec 和 mediaextractor
 if (mediacodec != null) {
  mediacodec.stop();
  mediacodec.release();
 }

 if (mediaextractor != null) {
  mediaextractor.release();
 }
 }

 /**
 * pcm文件转wav文件
 * @param inpcmfilepath 输入pcm文件路径
 * @param outwavfilepath 输出wav文件路径
 * @param samplerate 采样率，例如44100
 * @param channels 声道数 单声道：1或双声道：2
 * @param bitnum 采样位数，8或16
 */
 public static void convertpcm2wav(string inpcmfilepath, string outwavfilepath, int samplerate,
  int channels, int bitnum) {

 fileinputstream in = null;
 fileoutputstream out = null;
 byte[] data = new byte[1024];

 try {
  //采样字节byte率
  long byterate = samplerate * channels * bitnum / 8;

  in = new fileinputstream(inpcmfilepath);
  out = new fileoutputstream(outwavfilepath);

  //pcm文件大小
  long totalaudiolen = in.getchannel().size();

  //总大小，由于不包括riff和wav，所以是44 - 8 = 36，在加上pcm文件大小
  long totaldatalen = totalaudiolen + 36;

  writewavefileheader(out, totalaudiolen, totaldatalen, samplerate, channels, byterate);

  int length = 0;
  while ((length = in.read(data)) > 0) {
  out.write(data, 0, length);
  }
 } catch (exception e) {
  e.printstacktrace();
 } finally {
  if (in != null) {
  try {
   in.close();
  } catch (ioexception e) {
   e.printstacktrace();
  }
  }
  if (out != null) {
  try {
   out.close();
  } catch (ioexception e) {
   e.printstacktrace();
  }
  }
 }
 }


 /**
 * 输出wav文件
 * @param out wav输出文件流
 * @param totalaudiolen 整个音频pcm数据大小
 * @param totaldatalen 整个数据大小
 * @param samplerate 采样率
 * @param channels 声道数
 * @param byterate 采样字节byte率
 * @throws ioexception
 */
 private static void writewavefileheader(fileoutputstream out, long totalaudiolen,
  long totaldatalen, int samplerate, int channels, long byterate) throws ioexception {
 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);
 out.write(header, 0, 44);
 }