//采樣率 * 通道數 * 采樣位數/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);
 }