MediaMuxer WAV to AAC

放在前面的图

mediamuxer wav to aac 速度很快 带百分比直接上代码

public void wav2Aac(String input_file, String output_file) {
    int COMPRESSED_AUDIO_FILE_BIT_RATE = 64000; // 64kbps
    int SAMPLING_RATE = 16000;
    int BUFFER_SIZE = 48000;
    int CODEC_TIMEOUT_IN_MS = 5000;
    String COMPRESSED_AUDIO_FILE_MIME_TYPE = "audio/mp4a-latm";
    String LOGTAG = "WAV编码AAC";
    new Thread() {
      @Override
      public void run() {
        try {
          Runtime.getRuntime().gc();
          android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND);
          File inputFile = new File(input_file);
          FileInputStream fis = new FileInputStream(inputFile);

          File outputFile = new File(output_file);
          if (outputFile.exists()) outputFile.delete();
          MediaMuxer mux = new MediaMuxer(outputFile.getAbsolutePath(), MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);
          MediaFormat outputFormat = MediaFormat.createAudioFormat(COMPRESSED_AUDIO_FILE_MIME_TYPE, SAMPLING_RATE, 1);
          outputFormat.setInteger(MediaFormat.KEY_AAC_PROFILE,     MediaCodecInfo.CodecProfileLevel.AACObjectLC);
          outputFormat.setInteger(MediaFormat.KEY_BIT_RATE, COMPRESSED_AUDIO_FILE_BIT_RATE);
          outputFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 16384);

          MediaCodec codec = MediaCodec.createEncoderByType(COMPRESSED_AUDIO_FILE_MIME_TYPE);
          codec.configure(outputFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
          codec.start();

          ByteBuffer[] codecInputBuffers = codec.getInputBuffers(); // Note: Array of buffers
          ByteBuffer[] codecOutputBuffers = codec.getOutputBuffers();

          MediaCodec.BufferInfo outBuffInfo = new MediaCodec.BufferInfo();
          byte[] tempBuffer = new byte[BUFFER_SIZE];
          boolean hasMoreData = true;
          double presentationTimeUs = 0;
          int audioTrackIdx = 0;
          int totalBytesRead = 0;
          int percentComplete = 0;
          do {
            int inputBufIndex = 0;
            while (inputBufIndex != -1 && hasMoreData) {
              inputBufIndex = codec.dequeueInputBuffer(CODEC_TIMEOUT_IN_MS);
              if (inputBufIndex >= 0) {
                ByteBuffer dstBuf = codecInputBuffers[inputBufIndex];
                dstBuf.clear();
                int bytesRead = fis.read(tempBuffer, 0, dstBuf.limit());// Log.e("bytesRead", "Readed " + bytesRead);
                if (bytesRead == -1) { // -1 implies EOS
                  hasMoreData = false;
                  codec.queueInputBuffer(inputBufIndex, 0, 0, (long) presentationTimeUs, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
                } else {
                  totalBytesRead += bytesRead;
                  dstBuf.put(tempBuffer, 0, bytesRead);
                  codec.queueInputBuffer(inputBufIndex, 0, bytesRead, (long) presentationTimeUs, 0);
                  presentationTimeUs = 1000000l * (totalBytesRead / 2) / SAMPLING_RATE;
                }
              }
            }
            // Drain audio
            int outputBufIndex = 0;
            while (outputBufIndex != MediaCodec.INFO_TRY_AGAIN_LATER) {
              outputBufIndex = codec.dequeueOutputBuffer(outBuffInfo, CODEC_TIMEOUT_IN_MS);
              if (outputBufIndex >= 0) {
                ByteBuffer encodedData = codecOutputBuffers[outputBufIndex];
                encodedData.position(outBuffInfo.offset);
                encodedData.limit(outBuffInfo.offset + outBuffInfo.size);
                if ((outBuffInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0 && outBuffInfo.size != 0) {
                  codec.releaseOutputBuffer(outputBufIndex, false);
                } else {
                  mux.writeSampleData(audioTrackIdx, codecOutputBuffers[outputBufIndex], outBuffInfo);
                  codec.releaseOutputBuffer(outputBufIndex, false);
                }
              } else if (outputBufIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
                outputFormat = codec.getOutputFormat();
                Log.v(LOGTAG, "Output format changed - " + outputFormat);
                audioTrackIdx = mux.addTrack(outputFormat);
                mux.start();
              } else if (outputBufIndex == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
                Log.e(LOGTAG, "Output buffers changed during encode!");
              } else if (outputBufIndex == MediaCodec.INFO_TRY_AGAIN_LATER) {
                // NO OP
              } else {
                Log.e(LOGTAG, "Unknown return code from dequeueOutputBuffer - " + outputBufIndex);
              }
            }
            percentComplete = (int) Math.round(((float) totalBytesRead / (float) inputFile.length()) * 100.0);
            sendMessage(onProgressing, percentComplete);
          } while (outBuffInfo.flags != MediaCodec.BUFFER_FLAG_END_OF_STREAM);
          fis.close();
          mux.stop();
          mux.release();
          Runtime.getRuntime().gc();
        } catch (FileNotFoundException e) {
          sendMessage(TransferformatError, e);
        } catch (IOException e) {
          sendMessage(TransferformatError, e);
        }
      }
    }.start();
  }

private Handler mHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
      switch (msg.what) {
        case onProgressing:
          transferformatListener.onProgress(msg.arg1);
          if (msg.arg1 == 100)
            transferformatListener.Finish();
          break;
        case Finish:
          transferformatListener.Finish();
          break;
        case TransferformatError:
          transferformatListener.TransferformatError((Exception) msg.obj);
          break;
        default:
          break;
      }
    }
  };

  private final int onProgressing = 0;
  private final int Finish = 1;
  private final int TransferformatError = 2;

  private void sendMessage(int what, Object obj) {
    Message msg = mHandler.obtainMessage();
    switch (what) {
      case onProgressing:
        msg.arg1 = (int) obj;
        break;
      case TransferformatError:
        msg.obj = obj;
        break;
      default:
        break;
    }
    msg.what = what;
    mHandler.sendMessage(msg);
  }


  private TransferformatListener transferformatListener;

  public interface TransferformatListener {
    void onProgress(int progress);

    void Finish();

    void TransferformatError(Exception e);
  }

  public void setTransferformatListener(TransferformatListener listener) {
    this.transferformatListener = listener;
  }