react-native-compressor 1.7.2 → 1.8.0

package/src/utils/Uploader.tsx

@@ -0,0 +1,78 @@
+import { NativeEventEmitter, Platform } from 'react-native';
+import type { NativeEventSubscription } from 'react-native';
+import { Compressor } from '../Main';
+const CompressEventEmitter = new NativeEventEmitter(Compressor);
+import { uuidv4 } from '.';
+export declare enum FileSystemUploadType {
+  BINARY_CONTENT = 0,
+  MULTIPART = 1,
+}
+
+export declare enum FileSystemSessionType {
+  BACKGROUND = 0,
+  FOREGROUND = 1,
+}
+
+export declare type HTTPResponse = {
+  status: number;
+  headers: Record<string, string>;
+  body: string;
+};
+
+export declare type FileSystemAcceptedUploadHttpMethod =
+  | 'POST'
+  | 'PUT'
+  | 'PATCH';
+
+export declare type FileSystemUploadOptions = (
+  | {
+      uploadType?: FileSystemUploadType.BINARY_CONTENT;
+    }
+  | {
+      uploadType: FileSystemUploadType.MULTIPART;
+      fieldName?: string;
+      mimeType?: string;
+      parameters?: Record<string, string>;
+    }
+) & {
+  headers?: Record<string, string>;
+  httpMethod?: FileSystemAcceptedUploadHttpMethod;
+  sessionType?: FileSystemSessionType;
+};
+
+export const backgroundUpload = async (
+  url: string,
+  fileUrl: string,
+  options: FileSystemUploadOptions,
+  onProgress?: (writtem: number, total: number) => void
+): Promise<any> => {
+  const uuid = uuidv4();
+  let subscription: NativeEventSubscription;
+  try {
+    if (onProgress) {
+      subscription = CompressEventEmitter.addListener(
+        'uploadProgress',
+        (event: any) => {
+          if (event.uuid === uuid) {
+            onProgress(event.data.written, event.data.total);
+          }
+        }
+      );
+    }
+    if (Platform.OS === 'android' && fileUrl.includes('file://')) {
+      fileUrl = fileUrl.replace('file://', '');
+    }
+    const result = await Compressor.upload(fileUrl, {
+      uuid,
+      method: options.httpMethod,
+      headers: options.headers,
+      url,
+    });
+    return result;
+  } finally {
+    // @ts-ignore
+    if (subscription) {
+      subscription.remove();
+    }
+  }
+};

package/src/utils/index.tsx

@@ -186,3 +186,5 @@ export const uuidv4 = () => {
     return v.toString(16);
   });
 };
+export * from './Downloader';
+export * from './Uploader';

package/android/src/main/java/com/reactnativecompressor/Audio/AudioCompressor.java

@@ -1,605 +0,0 @@
-package com.reactnativecompressor.Audio;
-
-import android.annotation.SuppressLint;
-import android.media.MediaCodecList;
-import android.media.MediaMetadataRetriever;
-import android.util.Log;
-
-import android.media.MediaCodec;
-import android.media.MediaCodecInfo;
-import android.media.MediaExtractor;
-import android.media.MediaFormat;
-import android.media.MediaMuxer;
-import android.os.Build;
-
-import androidx.annotation.RequiresApi;
-
-import numan.dev.videocompressor.codecinputsurface.CodecInputSurface;
-import java.io.File;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-
-
-public class AudioCompressor {
-  private static final String TAG = "AudioCompressor";
-  private static final boolean VERBOSE = true;           // lots of logging
-  public String path;
-  private String outputPath;
-  public final static String MIME_TYPE = MediaFormat.MIMETYPE_AUDIO_AAC;
-  private MediaCodec.BufferInfo mBufferInfo;
-  private MediaMuxer mMuxer;
-  private MediaCodec mEncoder;
-  private MediaCodec mDecoder;
-  private int mTrackIndex;
-  private CodecInputSurface mInputSurface;
-  // bit rate, in bits per second
-  private int mBitRate = -1;
-  private static final int MEDIATYPE_NOT_AUDIO_VIDEO = -233;
-  private final int TIMEOUT_USEC = 2500;
-
-  /***
-   * trans video and audio  by mediacodec
-   *
-   * */
-  @SuppressLint("LongLogTag")
-  @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
-  public boolean CompressAudio(final String sourcePath, String destinationPath, int nbitrate) {
-
-    this.path = sourcePath;
-    this.outputPath = destinationPath;
-
-    if (checkParmsError(sourcePath, destinationPath, nbitrate)) {
-      return false;
-    }
-
-    //get origin video info
-    MediaMetadataRetriever retriever = new MediaMetadataRetriever();
-    retriever.setDataSource(path);
-    //  String framecount = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_FRAME_COUNT);
-    long duration = Long.valueOf(retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)) * 1000;
-
-    long startTime = -1;
-    long endTime = -1;
-
-
-
-    mBitRate = nbitrate;
-    // NUM_FRAMES = Integer.getInteger(framecount);
-    //IFRAME_INTERVAL = Integer.valueOf(retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION));
-
-
-    boolean error = false;
-    long videoStartTime = -1;
-
-    long time = System.currentTimeMillis();
-
-    File cacheFile = new File(destinationPath);
-    File inputFile = new File(path);
-    if (!inputFile.canRead()) {
-
-      return false;
-    }
-
-    MediaExtractor extractor = null;
-    MediaExtractor mAudioExtractor = null;
-
-    try {
-      // video MediaExtractor
-      extractor = new MediaExtractor();
-      extractor.setDataSource(inputFile.toString());
-
-      // audio MediaExtractor
-      mAudioExtractor = new MediaExtractor();
-      mAudioExtractor.setDataSource(inputFile.toString());
-      try {
-        mMuxer = new MediaMuxer(outputPath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);
-      } catch (IOException ioe) {
-
-
-        throw new RuntimeException("MediaMuxer creation failed", ioe);
-      }
-
-      int muxerAudioTrackIndex = 0;
-
-
-      int audioIndex = selectTrack(mAudioExtractor, true);
-      if (audioIndex >= 0) {
-        mAudioExtractor.selectTrack(audioIndex);
-        mAudioExtractor.seekTo(0, MediaExtractor.SEEK_TO_PREVIOUS_SYNC);
-        MediaFormat trackFormat = mAudioExtractor.getTrackFormat(audioIndex);
-//        muxerAudioTrackIndex = mMuxer.addTrack(trackFormat);
-
-        // extractor.unselectTrack(muxerAudioTrackIndex);
-      }
-
-      /**
-       * mediacodec + surface + opengl
-       * */
-        Log.d("CompressAudio", "CompressAudio: ");
-        int videoIndex = selectTrack(extractor, true);
-
-        if (videoIndex >= 0) {
-
-          long videoTime = -1;
-          boolean outputDone = false;
-          boolean inputDone = false;
-          boolean decoderDone = false;
-          int swapUV = 0;
-          int videoTrackIndex = MEDIATYPE_NOT_AUDIO_VIDEO;
-
-
-          extractor.selectTrack(videoIndex);
-          if (startTime > 0) {
-            extractor.seekTo(startTime, MediaExtractor.SEEK_TO_PREVIOUS_SYNC);
-          } else {
-            extractor.seekTo(0, MediaExtractor.SEEK_TO_PREVIOUS_SYNC);
-          }
-          MediaFormat inputFormat = extractor.getTrackFormat(videoIndex);
-
-
-          /**
-           ** init mediacodec  / encoder and decoder
-           **/
-          prepareEncoder(inputFormat);
-
-
-          ByteBuffer[] decoderInputBuffers = null;
-          ByteBuffer[] encoderOutputBuffers = null;
-
-
-          decoderInputBuffers = mDecoder.getInputBuffers();
-          encoderOutputBuffers = mEncoder.getOutputBuffers();
-
-
-          while (!outputDone) {
-            if (!inputDone) {
-              boolean eof = false;
-              int index = extractor.getSampleTrackIndex();
-              if (index == videoIndex) {
-                int inputBufIndex = mDecoder.dequeueInputBuffer(TIMEOUT_USEC);
-                if (inputBufIndex >= 0) {
-                  ByteBuffer inputBuf;
-                  if (Build.VERSION.SDK_INT < 21) {
-                    inputBuf = decoderInputBuffers[inputBufIndex];
-                  } else {
-                    inputBuf = mDecoder.getInputBuffer(inputBufIndex);
-                  }
-                  int chunkSize = extractor.readSampleData(inputBuf, 0);
-                  if (chunkSize < 0) {
-                    mDecoder.queueInputBuffer(inputBufIndex, 0, 0, 0L, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
-                    inputDone = true;
-                  } else {
-                    mDecoder.queueInputBuffer(inputBufIndex, 0, chunkSize, extractor.getSampleTime(), 0);
-                    extractor.advance();
-                  }
-                }
-              } else if (index == -1) {
-                eof = true;
-              }
-              if (eof) {
-                int inputBufIndex = mDecoder.dequeueInputBuffer(TIMEOUT_USEC);
-                if (inputBufIndex >= 0) {
-                  mDecoder.queueInputBuffer(inputBufIndex, 0, 0, 0L, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
-                  inputDone = true;
-                }
-              }
-            }
-
-            boolean decoderOutputAvailable = !decoderDone;
-            boolean encoderOutputAvailable = true;
-
-            while (decoderOutputAvailable || encoderOutputAvailable) {
-
-                int encoderStatus = mEncoder.dequeueOutputBuffer(mBufferInfo, TIMEOUT_USEC);
-              if (encoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER) {
-                encoderOutputAvailable = false;
-              } else if (encoderStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
-                if (Build.VERSION.SDK_INT < 21) {
-                  encoderOutputBuffers = mEncoder.getOutputBuffers();
-                }
-              } else if (encoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
-                MediaFormat newFormat = mEncoder.getOutputFormat();
-                if (videoTrackIndex == MEDIATYPE_NOT_AUDIO_VIDEO) {
-                  videoTrackIndex = mMuxer.addTrack(newFormat);
-                  mTrackIndex = videoTrackIndex;
-                  mMuxer.start();
-                }
-              } else if (encoderStatus < 0) {
-                throw new RuntimeException("unexpected result from mEncoder.dequeueOutputBuffer: " + encoderStatus);
-              } else {
-                ByteBuffer encodedData;
-                if (Build.VERSION.SDK_INT < 21) {
-                  encodedData = encoderOutputBuffers[encoderStatus];
-                } else {
-                  encodedData = mEncoder.getOutputBuffer(encoderStatus);
-                }
-                if (encodedData == null) {
-                  throw new RuntimeException("encoderOutputBuffer " + encoderStatus + " was null");
-                }
-                if (mBufferInfo.size > 1) {
-                  if ((mBufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) == 0) {
-                    mMuxer.writeSampleData(videoTrackIndex, encodedData, mBufferInfo);
-                  } else if (videoTrackIndex == MEDIATYPE_NOT_AUDIO_VIDEO) {
-                    byte[] csd = new byte[mBufferInfo.size];
-                    encodedData.limit(mBufferInfo.offset + mBufferInfo.size);
-                    encodedData.position(mBufferInfo.offset);
-                    encodedData.get(csd);
-                    ByteBuffer sps = null;
-                    ByteBuffer pps = null;
-                    for (int a = mBufferInfo.size - 1; a >= 0; a--) {
-                      if (a > 3) {
-                        if (csd[a] == 1 && csd[a - 1] == 0 && csd[a - 2] == 0 && csd[a - 3] == 0) {
-                          sps = ByteBuffer.allocate(a - 3);
-                          pps = ByteBuffer.allocate(mBufferInfo.size - (a - 3));
-                          sps.put(csd, 0, a - 3).position(0);
-                          pps.put(csd, a - 3, mBufferInfo.size - (a - 3)).position(0);
-                          break;
-                        }
-                      } else {
-                        break;
-                      }
-                    }
-
-                    MediaFormat newFormat = MediaFormat.createAudioFormat(MIME_TYPE, nbitrate, 1);
-                    if (sps != null && pps != null) {
-                      newFormat.setByteBuffer("csd-0", sps);
-                      newFormat.setByteBuffer("csd-1", pps);
-                    }
-                    videoTrackIndex = mMuxer.addTrack(newFormat);
-                    mMuxer.start();
-                  }
-                }
-                outputDone = (mBufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0;
-                mEncoder.releaseOutputBuffer(encoderStatus, false);
-              }
-              if (encoderStatus != MediaCodec.INFO_TRY_AGAIN_LATER) {
-                continue;
-              }
-
-              if (!decoderDone) {
-                int decoderStatus = mDecoder.dequeueOutputBuffer(mBufferInfo, TIMEOUT_USEC);
-                if (decoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER) {
-                  decoderOutputAvailable = false;
-                } else if (decoderStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
-
-                } else if (decoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
-                  MediaFormat newFormat = mDecoder.getOutputFormat();
-                  Log.e(TAG, "newFormat = " + newFormat);
-                } else if (decoderStatus < 0) {
-                  throw new RuntimeException("unexpected result from mDecoder.dequeueOutputBuffer: " + decoderStatus);
-                } else {
-                  boolean doRender = false;
-
-                  doRender = mBufferInfo.size != 0;
-
-                  if (endTime > 0 && mBufferInfo.presentationTimeUs >= endTime) {
-                    inputDone = true;
-                    decoderDone = true;
-                    doRender = false;
-                    mBufferInfo.flags |= MediaCodec.BUFFER_FLAG_END_OF_STREAM;
-                  }
-                  if (startTime > 0 && videoTime == -1) {
-                    if (mBufferInfo.presentationTimeUs < startTime) {
-                      doRender = false;
-                      Log.e(TAG, "drop frame startTime = " + startTime + " present time = " + mBufferInfo.presentationTimeUs);
-                    } else {
-                      videoTime = mBufferInfo.presentationTimeUs;
-                    }
-                  }
-                  mDecoder.releaseOutputBuffer(decoderStatus, doRender);
-                  if ((mBufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
-                      decoderOutputAvailable = false;
-                    outputDone=true;
-                    Log.e(TAG, "decoder stream end");
-                  }
-                }
-              }
-            }
-          }
-        }
-
-        extractor.unselectTrack(videoIndex);
-
-
-      writeAudioTrack(mAudioExtractor, mMuxer, mBufferInfo, cacheFile, muxerAudioTrackIndex);
-
-    } catch (Exception e) {
-      error = true;
-      Log.e(TAG, e.getMessage());
-    } finally {
-      if (extractor != null) {
-        extractor.release();
-        extractor = null;
-      }
-
-
-      if (mAudioExtractor != null) {
-        mAudioExtractor.release();
-        mAudioExtractor = null;
-      }
-      Log.e(TAG, "time = " + (System.currentTimeMillis() - time));
-    }
-
-
-    Log.e(TAG+" Path", path + "");
-    Log.e(TAG+" Path", cacheFile.getPath() + "");
-    Log.e(TAG+" Path", inputFile.getPath() + "");
-
-
-
-    releaseCoder();
-
-    if(error)
-      return  false;
-    else
-      return true;
-  }
-
-
-  private boolean checkParmsError(String sourcePath, String destinationPath, int nbitrate) {
-
-
-    if (nbitrate <= 0)
-      return true;
-    else
-      return false;
-
-  }
-
-
-  @SuppressLint("WrongConstant")
-  @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
-  private long simpleReadAndWriteTrack(MediaExtractor extractor, MediaMuxer mediaMuxer, MediaCodec.BufferInfo info, long start, long end, File file, boolean isAudio) throws Exception {
-    int trackIndex = selectTrack(extractor, isAudio);
-    if (trackIndex >= 0) {
-      extractor.selectTrack(trackIndex);
-      MediaFormat trackFormat = extractor.getTrackFormat(trackIndex);
-      int muxerTrackIndex = mediaMuxer.addTrack(trackFormat);
-
-      if(!isAudio)
-        mediaMuxer.start();
-
-      int maxBufferSize = trackFormat.getInteger(MediaFormat.KEY_MAX_INPUT_SIZE);
-      boolean inputDone = false;
-      if (start > 0) {
-        extractor.seekTo(start, MediaExtractor.SEEK_TO_PREVIOUS_SYNC);
-      } else {
-        extractor.seekTo(0, MediaExtractor.SEEK_TO_PREVIOUS_SYNC);
-      }
-      ByteBuffer buffer = ByteBuffer.allocateDirect(maxBufferSize);
-      long startTime = -1;
-
-      while (!inputDone) {
-
-        boolean eof = false;
-        int index = extractor.getSampleTrackIndex();
-        if (index == trackIndex) {
-          info.size = extractor.readSampleData(buffer, 0);
-
-          if (info.size < 0) {
-            info.size = 0;
-            eof = true;
-          } else {
-            info.presentationTimeUs = extractor.getSampleTime();
-            if (start > 0 && startTime == -1) {
-              startTime = info.presentationTimeUs;
-            }
-            if (end < 0 || info.presentationTimeUs < end) {
-              info.offset = 0;
-              info.flags = extractor.getSampleFlags();
-              mediaMuxer.writeSampleData(muxerTrackIndex, buffer, info);
-              extractor.advance();
-            } else {
-              eof = true;
-            }
-          }
-        } else if (index == -1) {
-          eof = true;
-        }
-        if (eof) {
-          inputDone = true;
-        }
-      }
-
-      extractor.unselectTrack(trackIndex);
-      return startTime;
-    }
-    return -1;
-  }
-
-  @SuppressLint("WrongConstant")
-  @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
-  private long writeAudioTrack(MediaExtractor extractor, MediaMuxer mediaMuxer, MediaCodec.BufferInfo info, File file, int muxerTrackIndex ) throws Exception {
-    int trackIndex = selectTrack(extractor, true);
-    if (trackIndex >= 0) {
-
-      MediaFormat trackFormat = extractor.getTrackFormat(trackIndex);
-      int maxBufferSize = info.size;
-      ByteBuffer byteBuffer = ByteBuffer.allocate(maxBufferSize);
-
-      long audioPresentationTimeUs = 0;
-      MediaCodec.BufferInfo audioBufferInfo = new MediaCodec.BufferInfo();
-      extractor.selectTrack(mTrackIndex);
-      /*
-       * the last audio presentation time.
-       */
-      long lastEndAudioTimeUs = 0;
-      while (true) {
-        int readAudioSampleSize = extractor.readSampleData(byteBuffer, 0);
-        if (readAudioSampleSize < 0) {
-          //if end of the stream, unselect
-          extractor.unselectTrack(mTrackIndex);
-          if (audioPresentationTimeUs >= 0) {
-            //if has reach the end of the video time ,just exit
-            break;
-          } else {
-            //if not the end of the video time, just repeat.
-            lastEndAudioTimeUs += audioPresentationTimeUs;
-            extractor.selectTrack(trackIndex);
-            continue;
-          }
-        }
-
-        long audioSampleTime = extractor.getSampleTime();
-        audioBufferInfo.size = readAudioSampleSize;
-        audioBufferInfo.presentationTimeUs = audioSampleTime + lastEndAudioTimeUs;
-        if (audioBufferInfo.presentationTimeUs > 0) {
-          extractor.unselectTrack(trackIndex);
-          break;
-        }
-        audioPresentationTimeUs = 0;
-        audioBufferInfo.offset = 0;
-        audioBufferInfo.flags = extractor.getSampleFlags();
-        mediaMuxer.writeSampleData(trackIndex, byteBuffer, audioBufferInfo);
-        extractor.advance();
-      }
-      //
-
-
-
-//      boolean inputDone = false;
-//      if (start > 0) {
-//        extractor.seekTo(start, MediaExtractor.SEEK_TO_PREVIOUS_SYNC);
-//      } else {
-//        extractor.seekTo(0, MediaExtractor.SEEK_TO_PREVIOUS_SYNC);
-//      }
-//      ByteBuffer buffer = ByteBuffer.allocateDirect(maxBufferSize);
-//      long startTime = -1;
-//
-//      while (!inputDone) {
-//
-//        boolean eof = false;
-//        int index = extractor.getSampleTrackIndex();
-//        if (index == trackIndex) {
-//          info.size = extractor.readSampleData(buffer, 0);
-//
-//          if (info.size < 0) {
-//            info.size = 0;
-//            eof = true;
-//          } else {
-//            info.presentationTimeUs = extractor.getSampleTime();
-//            if (start > 0 && startTime == -1) {
-//              startTime = info.presentationTimeUs;
-//            }
-//            if (end < 0 || info.presentationTimeUs < end) {
-//              info.offset = 0;
-//              info.flags = extractor.getSampleFlags();
-//              mediaMuxer.writeSampleData(muxerTrackIndex, buffer, info);
-//              extractor.advance();
-//            } else {
-//              eof = true;
-//            }
-//          }
-//        } else if (index == -1) {
-//          eof = true;
-//        }
-//        if (eof) {
-//          inputDone = true;
-//        }
-//      }
-//
-//      extractor.unselectTrack(trackIndex);
-//      return startTime;
-    }
-    return -1;
-  }
-
-
-  private int selectTrack(MediaExtractor extractor, boolean audio) {
-    int numTracks = extractor.getTrackCount();
-    for (int i = 0; i < numTracks; i++) {
-      MediaFormat format = extractor.getTrackFormat(i);
-      String mime = format.getString(MediaFormat.KEY_MIME);
-      if (audio) {
-        if (mime.startsWith("audio/")) {
-          return i;
-        }
-      } else {
-        if (mime.startsWith("video/")) {
-          return i;
-        }
-      }
-    }
-    return MEDIATYPE_NOT_AUDIO_VIDEO;
-  }
-
-  private String selectEncoder(String mime) {
-    for (int index = 0; index < MediaCodecList.getCodecCount(); index++) {
-      MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(index);
-
-      if (!codecInfo.isEncoder()) {
-        continue;
-      }
-
-      for (String type : codecInfo.getSupportedTypes()) {
-        if (type.equalsIgnoreCase(mime)) {
-          return MIME_TYPE;
-        }
-      }
-    }
-    return null;
-  }
-
-
-  /**
-   * Configures encoder and muxer state, and prepares the input Surface.
-   */
-  @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
-  private void prepareEncoder(MediaFormat format) {
-    mBufferInfo = new MediaCodec.BufferInfo();
-
-    MediaFormat mAudioFormat = MediaFormat.createAudioFormat(MIME_TYPE, mBitRate, 1);
-    if (VERBOSE) Log.d(TAG, "format: " + mAudioFormat);
-    mAudioFormat.setInteger(MediaFormat.KEY_SAMPLE_RATE, format.getInteger(MediaFormat.KEY_SAMPLE_RATE));
-    mAudioFormat.setInteger(MediaFormat.KEY_BIT_RATE, format.getInteger(MediaFormat.KEY_BIT_RATE));
-    mAudioFormat.setInteger(MediaFormat.KEY_CHANNEL_COUNT, format.getInteger(MediaFormat.KEY_CHANNEL_COUNT));
-    mAudioFormat.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC);
-    mAudioFormat.setString(MediaFormat.KEY_MIME, MIME_TYPE);
-    mAudioFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 10 * 1024);
-    try {
-      mEncoder = MediaCodec.createEncoderByType(MIME_TYPE);
-      mEncoder.configure(mAudioFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
-      mEncoder.start();
-      Log.d(TAG, "prepareEncoder...");
-    } catch (IOException e) {
-      e.printStackTrace();
-    }
-
-    try {
-      mDecoder = MediaCodec.createDecoderByType(format.getString(MediaFormat.KEY_MIME));
-    } catch (IOException e) {
-      e.printStackTrace();
-    }
-    mDecoder.configure(format, null, null, 0);
-    mDecoder.start();
-//    mTrackIndex = -1;
-  }
-
-  /**
-   * Releases encoder resources.  May be called after partial / failed initialization.
-   */
-  @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
-  private void releaseCoder() {
-    if (VERBOSE) Log.d(TAG, "releasing encoder objects");
-    if (mEncoder != null) {
-      mEncoder.stop();
-      mEncoder.release();
-      mEncoder = null;
-    }
-    if (mDecoder != null) {
-      mDecoder.stop();
-      mDecoder.release();
-      mDecoder = null;
-    }
-    if (mInputSurface != null) {
-      mInputSurface.release();
-      mInputSurface = null;
-    }
-    if (mMuxer != null) {
-      mMuxer.stop();
-      mMuxer.release();
-      mMuxer = null;
-    }
-  }
-
-}