dependencies {
    compile files('libs/pldroid-shortvideo-x.y.z.jar')
    compile 'com.qiniu:qiniu-android-sdk:8.4.3'
}

<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />

PLShortVideoEnv.init(getApplicationContext());

PLShortVideoRecorder mShortVideoRecorder = new PLShortVideoRecorder();
mShortVideoRecorder.setRecordStateListener(this);

// 摄像头采集选项
PLCameraSetting cameraSetting = new PLCameraSetting();
cameraSetting.setCameraId(PLCameraSetting.CAMERA_FACING_ID.CAMERA_FACING_FRONT);
cameraSetting.setCameraPreviewSizeRatio(PLCameraSetting.CAMERA_PREVIEW_SIZE_RATIO.RATIO_4_3);
cameraSetting.setCameraPreviewSizeLevel(PLCameraSetting.CAMERA_PREVIEW_SIZE_LEVEL.PREVIEW_SIZE_LEVEL_480P);

// 麦克风采集选项
PLMicrophoneSetting microphoneSetting = new PLMicrophoneSetting();

// 视频编码选项
PLVideoEncodeSetting videoEncodeSetting = new PLVideoEncodeSetting();
videoEncodeSetting.setEncodingSizeLevel(PLVideoEncodeSetting.VIDEO_ENCODING_SIZE_LEVEL.VIDEO_ENCODING_SIZE_LEVEL_480P_1); // 480x480
videoEncodeSetting.setEncodingBitrate(1000*1024); // 1000kbps
videoEncodeSetting.setEncodingFps(25);
videoEncodeSetting.setHWCodecEnabled(true); // true:硬编 false:软编

// 音频编码选项
PLAudioEncodeSetting audioEncodeSetting = new PLAudioEncodeSetting();
audioEncodeSetting.setHWCodecEnabled(true); // true:硬编 false:软编

// 美颜选项
PLFaceBeautySetting faceBeautySetting = new PLFaceBeautySetting(1.0f, 0.5f, 0.5f);

// 录制选项
PLRecordSetting recordSetting = new PLRecordSetting();
recordSetting.setMaxRecordDuration(10*1000); // 10s
recordSetting.setVideoCacheDir("/sdcard");
recordSetting.setVideoFilepath("/sdcard/record.mp4");

// 设置录制速度 (默认为 1.0)
PLShortVideoRecorder.setRecordSpeed(1.0);

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mShortVideoRecorder.prepare(glSurfaceView, cameraSetting, microphoneSetting,
            videoEncodeSetting, audioEncodeSetting, faceBeautySetting, recordSetting);     
}

@Override
protected void onResume() {
    super.onResume();
    mShortVideoRecorder.resume();
}

@Override
protected void onPause() {
    super.onPause();
    mShortVideoRecorder.pause();
}

@Override
protected void onDestroy() {
    super.onDestroy();
    mShortVideoRecorder.destroy();
}

// 开始一段视频
PLShortVideoRecorder.beginSection();
// 结束一段视频
PLShortVideoRecorder.endSection();
// 回删上一段视频
PLShortVideoRecorder.deleteLastSection();
// 回删所有录制的视频
PLShortVideoRecorder.deleteAllSections();
// 合成和保存所有的视频片段
PLShortVideoRecorder.concatSections();

// 设置 sdCard 上的音乐文件
PLShortVideoRecorder.setMusicFile(String filePath);
// 设置 Assets 下的音乐文件
PLShortVideoRecorder.setMusicAsset(AssetFileDescriptor afd);
// 设置音乐文件的播放起始位置
PLShortVideoRecorder.setMusicPosition(int position);
// 获取音乐文件当前的播放位置
PLShortVideoRecorder.getMusicPosition();
// 设置是否循环背景音乐
PLShortVideoRecorder.setMusicLoop(boolean musicLoop);

PLWatermarkSetting mWatermarkSetting = new PLWatermarkSetting();
mWatermarkSetting.setResourceId(R.drawable.qiniu_logo);
mWatermarkSetting.setPosition(0.01f, 0.75f);
mWatermarkSetting.setAlpha(128);
PLShortVideoRecorder.setWatermark(mWatermarkSetting);

// 保存草稿
PLShortVideoRecorder.saveToDraftBox("My Draft Title");

// 恢复草稿
PLDraft draft = PLDraftBox.getInstance(this).getDraftByTag("My Draft Title");
PLShortVideoRecorder.recoverFromDraft(draft);

PLScreenRecorder mScreenRecorder = new PLScreenRecorder(this);
mScreenRecorder.setRecordStateListener(this);

// 屏幕采集选项
public static final String SCREEN_RECORD_FILE_PATH = VIDEO_STORAGE_DIR + "/screen_record.mp4";
DisplayMetrics metrics = getResources().getDisplayMetrics();
int width = metrics.widthPixels;
int height = metrics.heightPixels;
int dpi = metrics.densityDpi;
mScreenRecorder = new PLScreenRecorder();
PLScreenRecorderSetting screenSetting = new PLScreenRecorderSetting();
screenSetting.setRecordFile(SCREEN_RECORD_FILE_PATH)
                .setInputAudioEnabled(false)
                .setSize(width, height)
                .setDpi(dpi);

// 音频（麦克风／外部导入）参数信息
PLMicrophoneSetting microphoneSetting = new PLMicrophoneSetting();

mScreenRecorder.prepare(screenSetting, microphoneSetting);

mScreenRecorder.requestScreenRecord();

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == PLScreenRecorder.REQUEST_CODE) {
        if (data == null) {
            String tip = "录屏申请启动失败！";
            mScreenRecorder.stop();
            mScreenRecorder = null;
            return;
        }
        
        mScreenRecorder.onActivityResult(requestCode, resultCode, data);
    }
}

public void onReady() {
    mScreenRecorder.start();
}

mScreenRecorder.stop();

PLVideoEditSetting setting = new PLVideoEditSetting();
// 视频源文件路径
setting.setSourceFilepath(videopath);
// 编辑后保存的目标文件路径
setting.setDestFilepath(outputpath);
// 编辑保存后，是否保留源文件
setting.setKeepOriginFile(true);

// glSurfaceView 用于渲染视频编辑后的效果
mShortVideoEditor = new PLShortVideoEditor(glSurfaceView, setting);

mShortVideoEditor.getBuiltinFilterList();

mShortVideoEditor.setBuildinFilter(String filterName);

mShortVideoEditor.setExternalFilter(String filterFilePath);

PLWatermarkSetting mWatermarkSetting = new PLWatermarkSetting();
mWatermarkSetting.setResourceId(R.drawable.qiniu_logo);
mWatermarkSetting.setPosition(0.01f, 0.75f);
mWatermarkSetting.setAlpha(128);
mShortVideoEditor.setWatermark(mWatermarkSetting);

PLWatermarkSetting mPreviewWatermarkSetting = new PLWatermarkSetting();
mPreviewWatermarkSetting.setResourceId(R.drawable.qiniu_logo);
//更新了预览视频的水印位置
mPreviewWatermarkSetting.setPosition(0.5f, 1f);
mPreviewWatermarkSetting.setAlpha(128);
mShortVideoEditor.updatePreviewWatermark(mPreviewWatermarkSetting);

PLWatermarkSetting mSaveWatermarkSetting = new PLWatermarkSetting();
mSaveWatermarkSetting.setResourceId(R.drawable.qiniu_logo);
//更新了保存的视频的水印位置
mSaveWatermarkSetting.setPosition(0.5f, 1f);
mSaveWatermarkSetting.setAlpha(128);
mShortVideoEditor.updateSaveWatermark(mSaveWatermarkSetting);

// 开始播放
mShortVideoEditor.startPlayback();
// 恢复播放
mShortVideoEditor.resumePlayback();
// 暂停播放
mShortVideoEditor.pausePlayback();
// 结束播放
mShortVideoEditor.stopPlayback();
// 跳到 msec 处播放
mShortVideoEditor.seekTo(int msec);
// 获取当前播放时间
mShortVideoEditor.getCurrentPosition();

// 设置混音文件（本地音频文件）
mShortVideoEditor.setAudioMixFile(String filePath);
// 设置混音文件（assets 下的音频文件）
mShortVideoEditor.setAudioMixAsset(AssetFileDescriptor afd);
// 设置原音(前景)和混音文件(背景)的音量 [0-1.0f]
mShortVideoEditor.setAudioMixVolume(float fgVolume, float bgVolume);
// 设置混音的起始和结束位置
mShortVideoEditor.setAudioMixFileRange(long beginTime, long endTime);
// 设置混音是否循环
mShortVideoEditor.setAudioMixLooping(false);

// 设置视频的速度（默认速度为 1.0）
mShortVideoEditor.setSpeed(1.0);
// 设置需要保存的视频时间段为 0 到 6000 毫秒（默认为整个视频）
mShortVideoEditor.setVideoRange(0, 6000)
// 监听保存状态和结果
mShortVideoEditor.setVideoSaveListener(this);
// 执行保存操作
mShortVideoEditor.save();

// 创建文字特效控件
PLTextView textView = new PLTextView(this);
// 设置文字内容，字体大小，字体颜色，透明度等一系列属性
textView.setText("点击输入文字");
textView.setTextSize(40);
textView.setTextColor(Color.RED);
textView.setAlpha(0.8f);
// 添加文字特效
mShortVideoEditor.addTextView(textView);
// 设置文字特效的显示时间段为 0 到 3000 毫秒
mShortVideoEditor.setViewTimeline(textView, 0, 3000);
// 删除文字特效
mShortVideoEditor.removeTextView(textView);

// 添加MV特效
// 注：mvFilePath 为MV视频文件路径，maskFilePath 为蒙版文件路径
mShortVideoEditor.setMVEffect(mvFilePath, maskFilePath);

PLImageView imageView = new PLImageView(this);
Bitmap bitmap = BitmapFactory.decodeFile(imagePath);
imageView.setImageBitmap(bitmap);
// 添加贴图
mShortVideoEditor.addImageView(imageView);
// 设置贴图的显示时间段为 0 到 3000 毫秒
mShortVideoEditor.setViewTimeline(imageView, 0, 3000);
// 删除贴图
mShortVideoEditor.removeImageView(imageView);

PLPaintView paintView = new PLPaintView(this, width, height);
//设置画笔颜色
paintView.setPaintColor(color);
//设置画笔尺寸
paintView.setPaintSize(size);
//撤销上一步操作
paintView.undo();
//清除所绘制的涂鸦
paintView.clear();
//设置画笔是否可绘制
paintView.setPaintEnable(false);
//添加涂鸦
mShortVideoEditor.addPaintView(paintView);
//设置涂鸦的显示时间段为 0 到 3000 毫秒
mShortVideoEditor.setViewTimeline(paintView, 0, 3000);
//删除涂鸦
mShortVideoEditor.removePaintView(paintView);

//设置主音频文件
PLMixAudioFile mainMixAudioFile = new PLMixAudioFile(mMp4path);
mShortVideoEditor.addMixAudioFile(mainMixAudioFile);
//添加第一个混音音频文件
PLMixAudioFile audioFile1 = new PLMixAudioFile(audioPath1);
audioFile1.setOffsetInVideo(firstMixingOffsetMs * 1000);//视频中开始混音的起始位置
audioFile1.setDurationInVideo(firstMixingDurationMs * 1000);//视频中混音时长
audioFile1.setVolume(0.5);//混音音量
mShortVideoEditor.addMixAudioFile(audioFile1);
//添加第二个混音音频文件
PLMixAudioFile audioFile2 = new PLMixAudioFile(audioPath2);
audioFile2.setOffsetInVideo(secondMixingOffsetMs * 1000);//视频中开始混音的起始位置
audioFile2.setDurationInVideo(secondMixingDurationMs * 1000);//视频中混音时长
audioFile2.setVolume(0.8);//混音音量
mShortVideoEditor.addMixAudioFile(audioFile2);
//删除第二个混音音频文件
mShortVideoEditor.removeMixAudioFile(audioFile2);

mShortVideoTrimmer = new PLShortVideoTrimmer(getApplicationContext(), videoPath, outputpath);

// true 限定为关键帧，false 为所有视频帧
boolean keyFrame = false;

// 获取视频帧总数
mShortVideoTrimmer.getVideoFrameCount(keyFrame);

// 通过索引获取视频帧
mShortVideoTrimmer.getVideoFrameByIndex(index, keyFrame);

// 通过时间戳获取视频帧
mShortVideoTrimmer.getVideoFrameByTime(timestampInMs, keyFrame);

// beginMs 和 endMs 可参考 从 getKeyFrame() 返回的 PLVideoFrame 中的时间戳
mShortVideoTrimmer.trim(beginMs, endMs, saveListener);

// beginMs 和 endMs 可参考 从 getKeyFrame() 返回的 PLVideoFrame 中的时间戳
mShortVideoTrimmer.trim(beginMs, endMs, TRIM_MODE.FAST, saveListener);

mShortVideoTranscoder = new PLShortVideoTranscoder(getApplicationContext(), videoPath, outputpath);

// 获取源视频宽度
mShortVideoTranscoder.getSrcWidth();
// 获取源视频高度
mShortVideoTranscoder.getSrcHeight();
// 获取源视频码率
mShortVideoTranscoder.getSrcBitrate();

mShortVideoTranscoder.transcode(dstWidth, dstHeight, dstBitrate, saveListener);

mShortVideoTranscoder.transcode(dstWidth, dstHeight, dstBitrate, true, saveListener);

mShortVideoTranscoder.transcode(dstWidth, dstHeight, dstBitrate, rotateBy, isReverse, saveListener);

mShortVideoTranscoder.setMaxFrameRate(maxFrameRate);

mShortVideoTranscoder.setClipArea(originPtrX, originPtrY, width, height)；

mShortVideoTranscoder.setHwDecodeEnabled(false);

mShortVideoComposer = new PLShortVideoComposer(context);

ArrayList<Bitmap> bitmaps = new ArraryList<Bitmap>();
bitmaps.add(bitmap1);
bitmaps.add(bitmap2);
bitmaps.add(bitmap3);
int frameDelayMs = 500; //GIF 中每帧的持续时间
boolean isLoop = true; //GIF 是否循环播放
mShortVideoComposer.composeToGIF(bitmaps, frameDelayMs, isLoop, saveListener);

// 场景一：顺序拼接每段视频

// 添加视频文件
List<String> videoList = new ArrayList<>();
videoList.add(videopath1);
videoList.add(videopath2);
// 编码配置，用于设置拼接后的视频文件的编码参数
// 注：多个视频拼接后，带角度的视频，最终会旋转为正向（0 度）
PLVideoEncodeSetting setting = new PLVideoEncodeSetting(this);
setting.setEncodingSizeLevel(VIDEO_ENCODING_SIZE_LEVEL.VIDEO_ENCODING_SIZE_LEVEL_480P_1);
setting.setEncodingBitrate(1000 * 1000);
// 开始合成视频
mShortVideoComposer.composeVideos(videoList, "/sdcard/composed.mp4", setting, saveListener);
// 取消视频合成
mShortVideoComposer.cancelComposeVideos();

// 场景二：顺序选取每段视频的一个时间段进行拼接

List<PLVideoRange> videoList = new ArrayList<>();
PLVideoRange videoRange1 = new PLVideoRange(videopath1);
// 选取第一段视频的 3 到 5 秒进行拼接
videoRange1.setStartTime(3000);
videoRange1.setEndTime(5000);
videoList.add(videoRange1);

PLVideoRange videoRange2 = new PLVideoRange(videopath2);
// 选取第二段视频的 6 到 9 秒进行拼接
videoRange2.setStartTime(6000);
videoRange2.setEndTime(9000);
videoList.add(videoRange2);

// 编码配置，用于设置拼接后的视频文件的编码参数
// 注：多个视频拼接后，带角度的视频，最终会旋转为正向（0 度）
PLVideoEncodeSetting setting = new PLVideoEncodeSetting(this);
setting.setEncodingSizeLevel(VIDEO_ENCODING_SIZE_LEVEL.VIDEO_ENCODING_SIZE_LEVEL_480P_1);
setting.setEncodingBitrate(1000 * 1000);
// 开始合成视频
mShortVideoComposer.composeVideoRanges(videoList, "/sdcard/composed.mp4", setting, saveListener);
// 取消视频合成
mShortVideoComposer.cancelComposeVideos();

// 配置每张图片在视频中的显示时间和转场效果时间
PLComposeItem item1 = new PLComposeItem(imagePath);
item1.setDurationMs(durationTime);
item1.setTransitionTimeMs(transTime);
// 添加每张图片等合成信息
List<PLComposeItem> itemList = new ArrayList<>();
itemList.add(item1);
itemList.add(item2);
// 编码配置，用于设置合成后的视频文件的编码参数
PLVideoEncodeSetting setting = new PLVideoEncodeSetting(this);
setting.setEncodingSizeLevel(VIDEO_ENCODING_SIZE_LEVEL.VIDEO_ENCODING_SIZE_LEVEL_480P_1);  setting.setEncodingBitrate(1000 * 1000);
// 开始合成
mShortVideoComposer.composeImages(itemList, "/sdcard/music.mp3", true, "/sdcard/image_composed.mp4", setting, saveListener);

// 从视频导出 GIF 动图。依次传入输入视频路径、开始时间、结束时间、总输出帧数、输出宽度、输出高度、是否循环标志、输出文件路径、监听器对象；
 mShortVideoComposer.extractVideoToGIF("/sdcard/input.mp4", startTimeMs, endTimeMs, totalFrameCount, outputWidth, outputHeight, true, "/sdcard/output.gif", saveListener);

// 配置图片拼接信息
PLComposeItem imageItem = new PLComposeItem(imagePath);
imageItem.setItemType(PLComposeItem.ItemType.IMAGE);
imageItem.setDurationMs(5000); // 设置图片总时长为 5000 ms
imageItem.setTransitionTimeMs(1000); //设置过度动画为 1000 ms

// 配置 GIF 拼接信息
PLComposeItem gifItem = new PLComposeItem(gifPath);
gifItem.setItemType(PLComposeItem.ItemType.GIF);
gifItem.setDurationMs(5000); // 设置 GIF 总时长为 5000 ms
gifItem.setTransitionTimeMs(1000); //设置 GIF 过度动画为 1000 ms

// 配置视频拼接信息，视频拼接不需要 setDurationMs ，其总时长即为视频时长
PLComposeItem videoItem = new PLComposeItem(videoPath);
videoItem.setItemType(PLComposeItem.ItemType.VIDEO);
videoItem.setTransitionTimeMs(1000); //设置过度动画为 1000 ms

List<PLComposeItem> itemList = new ArrayList<>();
itemList.add(imageItem);
itemList.add(gifItem);
itemList.add(videoItem);

// 编码配置，用于设置拼接后的视频文件的编码参数
PLVideoEncodeSetting setting = new PLVideoEncodeSetting(this);
setting.setEncodingSizeLevel(VIDEO_ENCODING_SIZE_LEVEL.VIDEO_ENCODING_SIZE_LEVEL_480P_1);
setting.setEncodingBitrate(1000 * 1000);
setting.setEncodingFps(25);

// 开始拼接
mShortVideoComposer.composeItems(itemList, "/sdcard/image_composed.mp4", setting, "/sdcard/music.mp3", 1, 1, mVideoSaveListener)

PLUploadSetting uploadSetting = new PLUploadSetting();
uploadSetting.setChunkSize(chunkSize)           // 分片上传时，每片的大小，默认 2M
             .setPutThreshhold(putthreshhold)   // 启用分片上传阀值，默认 4M
             .setConnectTimeout(connectTimeout) // 链接超时，默认10秒
             .setResponseTimeout(responseTimeout) // 服务器响应超时，默认60秒
             .setZone(plUploadZone)  // 设置区域，指定不同区域的上传域名、备用域名、备用IP
             .setHttpsEnabled(true)    // 是否启用 https 上传，默认不启用
             .setParams(params);   // 配置上传自定义变量

mShortVideoUploader = new PLShortVideoUploader(getApplicationContext(), uploadSetting);
mShortVideoUploader.setUploadProgressListener(this);
mShortVideoUploader.setUploadResultListener(this);

/**
 * 上传   默认返回文件的哈希值作为 key
 * @filepath 即将上传的文件的路径
 * @token 上传的凭证，客户端在上传前，需要先从服务端获取上传凭证
 */
PLShortVideoUploader.startUpload(String filepath, String token);
/**
 * 上传
 * @filepath 即将上传的文件的路径
 * @key 指定上传后的 key 值
 * @token 上传的凭证，客户端在上传前，需要先从服务端获取上传凭证
 */
PLShortVideoUploader.startUpload(String filePath, String key, String token)
/**
 * 取消上传
 */
PLShortVideoUploader.cancelUpload();

PLShortAudioRecorder mShortAudioRecorder = new PLShortAudioRecorder();
mShortAudioRecorder.setRecordStateListener(this);

// 麦克风采集选项
PLMicrophoneSetting microphoneSetting = new PLMicrophoneSetting();

// 音频编码选项
PLAudioEncodeSetting audioEncodeSetting = new PLAudioEncodeSetting();

// 录制选项
PLRecordSetting recordSetting = new PLRecordSetting();
recordSetting.setMaxRecordDuration(10*1000); // 10s
recordSetting.setVideoCacheDir("/sdcard");
recordSetting.setVideoFilepath("/sdcard/audio_record.m4a");

@Override
protected void onResume() {
    super.onResume();
    mShortAudioRecorder.resume();
}

@Override
protected void onPause() {
    super.onPause();
    mShortAudioRecorder.pause();
}

@Override
protected void onDestroy() {
    super.onDestroy();
    mShortAudioRecorder.destroy();
}

// 开始一段音频
PLShortAudioRecorder.beginSection();
// 结束一段音频
PLShortAudioRecorder.endSection();
// 回删上一段音频
PLShortAudioRecorder.deleteLastSection();
// 回删所有录制的音频
PLShortAudioRecorder.deleteAllSections();
// 合成和保存所有的音频片段
PLShortAudioRecorder.concatSections();

// 编码配置，用于设置生成的视频文件的编码参数
PLVideoEncodeSetting setting = new PLVideoEncodeSetting(this);
setting.setEncodingSizeLevel(VIDEO_ENCODING_SIZE_LEVEL.VIDEO_ENCODING_SIZE_LEVEL_720P_3);
setting.setEncodingBitrate(1000 * 1000);
// 构造函数所需参数为 ViewGroup 和 PLVideoEncodeSetting 对象
mTransitionMaker = new PLTransitionMaker(mViewGroup, setting);

// 创建文字控件
PLTextView title = new PLTextView(mContext);
// 设置文字内容，颜色，大小等一系列属性
title.setText("标题");
title.setPadding(0, 0, 0, 0);
title.setTextColor(Color.parseColor("#FFCC99"));
title.setTextSize(14);
// 添加创建的文字
mTransitionMaker.addText(title);

// 创建图片控件
PLImageView imageView = new PLImageView(mContext);
// 设置图片内容
imageView.setImageDrawable(mContext.getResources().getDrawable(R.drawable.pink_line));
// 添加创建的图片
mTransitionMaker.addText(imageView);

// 创建透明度动画，延迟时间为 0, 持续时间为 3000 毫秒，透明度变化从 0 到 1
PLFadeTransition fadeTransition = new PLFadeTransition(0, 3000, 0, 1);
// 把创建的透明度动画添加到相应的控件上
mTransitionMaker.addTransition(title, fadeTransition);

// 创建位移动画，延迟时间为 0，持续时间为 3000 毫秒，位移变化从 (0,0) 到 (100,100)
PLPositionTransition positionTransition = new PLPositionTransition(0, 3000, 0, 0, 100, 100);
// 把创建的位移动画添加到相应的控件上
mTransitionMaker.addTransition(title, positionTransition);

mTransitionMaker.play()

mTransitionMaker.save(dstFilePath, saveListener);

mTransitionMaker.destroy();

PLExternalMediaRecorder externalMediaRecorder = new PLExternalMediaRecorder(this);

// 创建视频编码配置
PLVideoEncodeSetting videoEncodeSetting = new PLVideoEncodeSetting(this);
// 设置视频编码尺寸（编码尺寸需要和导入视频的宽高一致）
videoEncodeSetting.setPreferredEncodingSize(videoWidth, videoHeight);
// 设置视频编码帧率（编码帧率需要和导入视频的帧率一致）
videoEncodeSetting.setEncodingFps(videoFrameRate);
// 设置视频关键帧间隔（I 帧间隔最好和导入视频的间隔一致）
videoEncodeSetting.setIFrameInterval(interval);
// 设置视频编码码率（编码码率最好大于或等于导入视频的码率）
videoEncodeSetting.setEncodingBitrate(videoBitrate);

// 设置音频编码配置
PLAudioEncodeSetting audioEncodeSetting = new PLAudioEncodeSetting();
// 设置音频编码采样率（采样率需要和导入的音频采样率一致）
audioEncodeSetting.setSampleRate(sampleRate);
// 设置音频声道数（声道数需要和导入的音频声道数一致）
audioEncodeSetting.setChannels(channels);
// 设置音频编码码率（编码码率最好大于或等于导入音频的码率）
audioEncodeSetting.setBitrate(audioBitrate)

PLRecordSetting recordSetting = new PLRecordSetting();
// 设置生成视频的保存路径
recordSetting.setVideoFilepath(OUTPUT_VIDEO_PATH);
// 设置视频的最大时长（单位：ms）
recordSetting.setMaxRecordDuration(duration);

externalMediaRecorder.prepare(videoEncodeSetting, audioEncodeSetting, recordSetting);

externalMediaRecorder.start();

// 导入视频数据
externalMediaRecorder.inputVideoFrame(data, width, height, rotation, timestampNs)；
// 导入音频数据
externalMediaRecorder.inputAudioFrame(data, size, timestampNs)；

externalMediaRecorder.stop();

PLShortVideoMixRecorder shortVideoMixRecorder = new PLShortVideoMixRecorder(this);
shortVideoMixRecorder.setRecordStateListener(this);

//样本视频宽高比为 9:16
float sampleRatio = 9 / 16;
//固定宽度
int sampleRectWidth = VIDEO_MIX_ENCODE_WIDTH / 2;
//高度根据长宽比来计算，防止拉伸
int sampleRectHeight = (int) (sampleRectWidth / sampleRatio);
//顶部坐标
int sampleRectTop = (VIDEO_MIX_ENCODE_HEIGHT - sampleRectHeight) / 2;
//底部坐标
int sampleRectBottom = sampleRectTop + sampleRectHeight;
//样本视频在最后画面的矩形区域
Rect sampleVideoRect = new Rect(VIDEO_MIX_ENCODE_WIDTH / 2, sampleRectTop, VIDEO_MIX_ENCODE_WIDTH, sampleRectBottom);

//录制视频宽高比为 9:16
float cameraRatio = 9 / 16;
//固定宽度
int cameraRectWidth = VIDEO_MIX_ENCODE_WIDTH / 2;
//高度根据长宽比来计算，防止拉伸
int cameraRectHeight = (int) (cameraRectWidth * cameraRatio);
//顶部坐标
int cameraRectTop = (VIDEO_MIX_ENCODE_HEIGHT - cameraRectHeight) / 2;
//底部坐标
int cameraRectBottom = cameraRectTop + cameraRectHeight;
//摄像机录制的视频在最后画面的矩形区域
Rect cameraVideoRect = new Rect(0, cameraRectTop, VIDEO_MIX_ENCODE_WIDTH / 2, cameraRectBottom);

//设置样本视频路径
String sampleVideoPath = "/sdcard/sample.mp4"
//设置摄像机录制的片段最后拼接的缓存视频的路径，它用于和样本视频最后进行合成
String cameraRecodCachePath = "/sdcard/ShortVideo/mix_camera_cache.mp4"

//创建合拍配置
PLVideoMixSetting mixSetting = new PLVideoMixSetting(cameraVideoRect, sampleVideoRect, sampleVideoPath, cameraRecodCachePath);
//如果需要指定合拍层级或者样本视频的显示模式，也可以用以下方式来创建合拍配置：
PLVideoMixSetting mixSetting = new PLVideoMixSetting(cameraVideoRect, sampleVideoRect, sampleVideoPath, sampleDisplayMode, cameraAboveSample, cameraRecodCachePath);

//mCameraPreview 为拍摄预览窗口（GLSurfaceView），mSamplePreview 为样本预览窗口（GLSurfaceView）
mMixRecorder.prepare(mCameraPreview, mSamplePreview, mixSetting, mCameraSetting, mMicrophoneSetting, mVideoEncodeSetting, mAudioEncodeSetting, mFaceBeautySetting, mRecordSetting);

//场景一：把样本的音频作为最终的音频

//设置麦克风采集静音
mMixRecorder.muteMicrophone(true);
//设置样本视频不静音
mMixRecorder.muteSampleVideo(false);

//场景二：把麦克风采集的人声作为最终的音频

//设置麦克风采集静音
mMixRecorder.muteMicrophone(false);
//设置样本视频不静音
mMixRecorder.muteSampleVideo(true);

//场景三：扬声器模式，把人声和样本音频同时采集进来作为最终的音频

//当麦克风采集和样本视频都不静音时，默认为 SPEAKERPHONE_MODE ，无需单独设置
//设置麦克风采集不静音
mMixRecorder.muteMicrophone(false);
//设置样本视频不静音
mMixRecorder.muteSampleVideo(false);

//场景四：耳机模式，通过耳机，只采集到人声，然后和样本音频进行混音作为最终的音频

//设置麦克风采集不静音
mMixRecorder.muteMicrophone(false);
//设置样本视频不静音
mMixRecorder.muteSampleVideo(false);
//设置为耳机模式
mMixRecorder.setAudioMixMode(PLAudioMixMode.EARPHONE_MODE);
//耳机模式下可以设置麦克风采集音量和样本音量
mMixRecorder.setAudioMixVolume(1.0f,1.0f);

// 开始一段视频
PLShortVideoMixRecorder.beginSection();
// 结束一段视频
PLShortVideoMixRecorder.endSection();
// 回删上一段视频
PLShortVideoMixRecorder.deleteLastSection();
// 回删所有录制的视频
PLShortVideoMixRecorder.deleteAllSections();
// 生成合拍视频并保存
PLShortVideoMixRecorder.save();

// 创建视频拼图对象，指定最后生成的视频路径和视频时长
PLShortVideoMixer shortVideoMixer = new PLShortVideoMixer(this, VIDEO_MIX_PATH, MAX_DURATION_MS);
// 创建视频编码配置
PLVideoEncodeSetting videoEncodeSetting = new PLVideoEncodeSetting(this);
videoEncodeSetting.setEncodingSizeLevel(PLVideoEncodeSetting.VIDEO_ENCODING_SIZE_LEVEL.VIDEO_ENCODING_SIZE_LEVEL_480P_1);
videoEncodeSetting.setEncodingBitrate(2000 * 1000);
videoEncodeSetting.setHWCodecEnabled(true);
videoEncodeSetting.setConstFrameRateEnabled(true);
// 指定编码参数配置
shortVideoMixer.setVideoEncodeSetting(videoEncodeSetting);

// 第一个拼图配置
videoMixItem1 = new PLVideoMixItem();
// 设置视频路径
videoMixItem1.setVideoPath(path);
// 设置视频的矩形区域 (需要和预览时一致)
videoMixItem1.setVideoRect(new Rect(0, 240, 480, 480));
// 设置视频的显示模式
videoMixItem1.setDisplayMode(PLDisplayMode.FIT);
// 设置该视频的开始播放时间
videoMixItem1.setStartTimeMs(0);
// 设置该视频的声音大小
videoMixItem1.setVolume(volume);

// 第二个拼图配置
videoMixItem2 = new PLVideoMixItem();
// 设置视频路径
videoMixItem2.setVideoPath(path);
// 设置视频的矩形区域 (需要和预览时一致)
videoMixItem2.setVideoRect(new Rect(0, 240, 480, 480));
// 设置视频的显示模式
videoMixItem2.setDisplayMode(PLDisplayMode.FIT);
// 设置该视频的开始播放时间
videoMixItem2.setStartTimeMs(0);
// 设置该视频的声音大小
videoMixItem2.setVolume(volume);

// 把创建的 PLVideoMixItem 放入 List
List<PLVideoMixItem> items = new LinkedList<>();
items.add(videoMixItem1);
items.add(videoMixItem2);
// 开始合成
shortVideoMixer.mix(items, saveListener)

shortVideoMixer.cancel();

// 创建图片合成对象
PLImageComposer mImageComposer = new PLImageComposer(getContext());

PLComposeItem item = new PLComposeItem(path);
// 设置显示时长
item.setDurationMs(3000);   
// 设置转场时长
item.setTransitionTimeMs(1000);
// 设置转场类型
item.setTransitionType(PLTransitionType.CIRCLE_CROP);  
// 添加图片 
mImageComposer.addItem(item); 
// 移除图片
// mImageComposer.removeItem(item);

// 设置预览 SurfaceTexture
mImageComposer.setPreviewTexture(surfaceTexture);
// 设置预览 Surface
// mImageComposer.setPreviewSurface(surface);
// 设置预览尺寸
mImageComposer.setPreviewSize(width, height);
// 设置监听
mImageComposer.setPreviewListener(new PLImageComposer.PLPreviewListener());
// 开始停止,预览
mImageComposer.startPreview();
mImageComposer.resumePreview();
mImageComposer.pausePreview();
mImageComposer.stopPreview();
// 设置 loop
mImageComposer.setPreviewLoop(true);
// seek 到 2 秒
mImageComposer.seekPreview(2_000);

// 保存视频
PLVideoEncodeSetting setting = new PLVideoEncodeSetting();
String outputPath = "..../test_image_composition.mp4";
// 保存视频
mImageComposer.save(outputPath, setting, new PLVideoSaveListener());
// 停止保存
mImageComposer.cancelSave();
// 释放
mImageComposer.release();

// 创建 PLShortVideoReader 实例
PLShortVideoReader mShortVideoReader = new PLShortVideoReader(getContext());
// 开始读取视频帧
mShortVideoReader.startRead(mPath, new PLVideoReadListener() {
    @Override
    public void onStart() {
        // 开始读取
    }

    @Override
    public void onDrawFrame(int texId, int texWidth, int texHeight, int rotation, long timestampNs, float[] transformMatrix) {
        // 视频纹理回调
    }

    @Override
    public void onFinish() {
        // 读取结束
    }

    @Override
    public void onCancel() {
        // 读取操作已取消
    }

    @Override
    public void onError(int error) {
        // 读取出错
    }
});

// 取消读取视频帧
mShortVideoReader.cancelRead();

/**
 * 构造 PLShortVideoRecorder 对象
 */
public PLShortVideoRecorder();

/**
 * 使 PLShortVideoRecorder 暂停工作，通常在 Activity#onPause 中调用
 */
public pause();

/**
 * 使 PLShortVideoRecorder 恢复工作，通常在 Activity#onResume 中调用
 */
public resume();

/**
 * 销毁 PLShortVideoRecorder 对象，通常在 Activity#onDestroy 中调用
 * 将删除已录制的片段
 */
public destory();

/**
 * 销毁 PLShortVideoRecorder 对象，通常在 Activity#onDestroy 中调用
 * @param clearSections 是否删除已录制的片段
 */
public destory(boolean clearSections);

/**
 * Prepare the recorder
 *
 * @param glSurfaceView      预览的 GLSurfaceView
 * @param cameraSetting      PLCameraSetting 对象
 * @param microphoneSetting  PLMicrophoneSetting 对象
 * @param videoEncodeSetting PLVideoEncodeSetting 对象
 * @param audioEncodeSetting PLAudioEncodeSetting 对象
 * @param faceBeautySetting  PLFaceBeautySetting 对象
 * @param recordSetting      PLRecordSetting 对象
 */
public void prepare(GLSurfaceView glSurfaceView,
                    PLCameraSetting cameraSetting,
                    PLMicrophoneSetting microphoneSetting,
                    PLVideoEncodeSetting videoEncodeSetting,
                    PLAudioEncodeSetting audioEncodeSetting,
                    PLFaceBeautySetting faceBeautySetting,
                    PLRecordSetting recordSetting);

/**
 * 手动对焦，在 prepare 里设置好的 GLSurfaceView 上指定对焦块大小以及相应的中央坐标
 * @param 对焦块的宽度
 * @param 对焦块的高度
 * @param 对焦块的中央X坐标
 * @param 对焦块的中央Y坐标
 */
public void manualFocus(int focusBlockWidth, int focusBlockHeight, int focusBlockCenterX, int focusBlockCenterY);

/**
 * 获取支持的对焦模式，每个摄像头可能不一样
 */
public List<String> getSupportFocusModes();

/**
 * 设置对焦模式，需要是当前摄像头支持的
 */
public boolean setFocusMode(String focusMode);

/**
 * 注册相机对焦监听器
 * @param 对焦监听器
 */
public void setFocusListener(PLFocusListener focusListener);

/**
 * 开始录制片段，需要收到 `onReady` 回调之后执行
 */
public boolean beginSection();

/**
 * 开始录制片段，需要收到 `onReady` 回调之后执行
 * @param 指定片段文件名
 */
public boolean beginSection(String sectionFileName);

/**
 * 停止录制当前片段
 */
public boolean endSection();

/**
 * 删除上一个录制的片段
 */
public boolean deleteLastSection();

/**
 * 删除所有录制的片段
 */
public boolean deleteAllSections();

/**
 * 合并录制的片段，SDK 将会在缓存目录中临时创建对应文件
 * @param   用于接收合并回调的 listener
 */
public void concatSections(PLVideoSaveListener listener);

/**
 * 取消进行中的片段合并，会清理已生成的文件
 */
public void cancelConcat();

/**
 * 切换到下一个摄像头
 */
public void switchCamera();

/**
 * 切换到指定摄像头
 */
public void switchCamera(PLCameraSetting.CAMERA_FACING_ID facingId);

/**
 * 设置闪光灯开关
 */
public void setFlashEnabled(boolean enabled);

/**
 * 更新美颜设置
 * @param 美颜设置对象
 */
public final void updateFaceBeautySetting(PLFaceBeautySetting setting);

/**
 * 注册相机预览监听器
 * @param 监听器对象
 */
public final void setCameraPreviewListener(PLCameraPreviewListener listener);

/**
 * 注册相机参数选定监听器
 * @param 监听器对象
 */
public final void setCameraParamSelectListener(PLCameraParamSelectListener listener);

/**
 * 注册自定义美颜、滤镜效果的监听器
 * @param 监听器对象
 */
public final void setVideoFilterListener(PLVideoFilterListener listener);

/**
 * 注册自定义美颜、滤镜效果的监听器
 * @param 监听器对象
 * @param 指定监听器中返回的纹理类型为 OES
 */
public final void setVideoFilterListener(PLVideoFilterListener listener, boolean callbackOES);

/**
 * 设置纹理在以下 2 个地方的旋转角度
 * 1. 预览
 * 2. 最终拼接的视频
 * 注意：不会对从 PLVideoFilterListener 返回的纹理有影响
 * @param 旋转角度
 */
public void setTextureRotation(int rotation);

/**
 * 注册音频帧监听器
 * @param 监听器对象
 */
public final void setAudioFrameListener(PLAudioFrameListener listener);

/**
 * 注册录制状态监听器
 * @param 监听器对象
 */
public final void setRecordStateListener(PLRecordStateListener listener);

/**
 * 获取 SDK 自带的滤镜列表
 * @return PLBuiltinFilter 数组
 */
public PLBuiltinFilter[] getBuiltinFilterList();

/**
 * 应用 SDK 自带的滤镜
 * @param 滤镜名，从 getBuiltinFilter 获取
 */
public void setBuiltinFilter(String filterName);

/**
 * 应用 SD 卡中的滤镜
 * @param 滤镜名，滤镜资源的绝对路径
 */
public void setExternalFilter(String filterFilePath);

/**
 * 截取当前预览一帧，并应用滤镜效果
 * @param 监听器对象
  */
public void captureFrame(PLCaptureFrameListener captureFrameListener);

/**
 * 截取当前预览一帧
 * @param 监听器对象
 * @param 是否应用滤镜效果
  */
public void captureFrame(PLCaptureFrameListener captureFrameListener, boolean hasFilter);

/**
 * 获取当前摄像头的最大曝光补偿值
 * @return 最大曝光补偿值
 */
public int getMaxExposureCompensation();

/**
 * 获取当前摄像头的最小曝光补偿值
 * @return 最小曝光补偿值
 */
public int getMinExposureCompensation();

/**
 * 设置曝光补偿值，这个操作将会关闭自动曝光
 */
public void setExposureCompensation(int exposureCompensation);

/**
 * 设置是否开启自动曝光补偿，默认自动开启
 */
public void setAutoExposure(boolean enable);

/**
 * 判断当前是否已开启自动曝光补偿
 */
public boolean isAutoExposureEnable();

/**
 * 设置倍数拍摄，只支持 2 的倍数，或 1/2 的倍数
 * 例如：2x, 4x, 1/2x, 1/4x
 * 注意调用过一次 beginSection 后，该方法设置无效
 * @param 倍数值
 */
public void setRecordSpeed(double recordSpeed);

/**
 * 设置预览画面的缩放值
 * 调用此方法前，请先调用 getZooms 方法获取有效值
 * @param 缩放值
 */
public void setZoom(float zoom);

/**
 * 获取有效的缩放值列表
 * 已由小至大排序
 * @return 如果该分辨率不支持缩放，则返回 null
 */
public List<Float> getZooms();

/**
 * 设置存储下的音乐文件
 *
 * @param 文件路径
 */
public void setMusicFile(String filePath);

/**
 * 设置 Assets 下的音乐文件
 *
 * @param AssetFileDescriptor
 */
public void setMusicAsset(AssetFileDescriptor afd);

/**
 * 设置音乐文件播放的起始位置
 *
 * @param 起始位置
 */
public void setMusicPosition(int position);

/**
 * 设置背景音乐循环
 *
 * @param musicLoop 是否循环
 */
public void setMusicLoop(boolean musicLoop);

/**
 * 获取音乐文件当前的播放位置
 *
 * @return 当前播放位置
 */
public int getMusicPosition();

/**
 * 设置预览时是否镜像
 * @param isMirror 是否镜像
 */
public void setMirrorForPreview(boolean isMirror);

/**
 * 设置编码时是否镜像
 * @param isMirror 是否镜像
 */
public void setMirrorForEncode(boolean isMirror);

/**
 * 将当前录制的片段与设置项存入草稿箱
 * @param 草稿标签，不同草稿需要有不同的标签，否则保存时会覆盖相同标签的草稿
 */
public boolean saveToDraftBox(String tag);

/**
 * 恢复草稿
 * @param glSurfaceView 预览的 view
 * @param draft 草稿对象
 */
public boolean recoverFromDraft(GLSurfaceView glSurfaceView, PLDraft draft);

/**
 * 设置白平衡模式
 *
 * @param whiteBalanceMode 白平衡模式
 */
public boolean setWhiteBalanceMode(String whiteBalanceMode) {
    return mShortVideoCore.setWhiteBalanceMode(whiteBalanceMode);
}

/**
 * 获取当前白平衡模式
 *
 * @return 白平衡模式
 */
public String getWhiteBalanceMode() {
    return mShortVideoCore.getWhiteBalanceMode();
}

/**
 * 获取支持的白平衡模式列表
 *
 * @return 白平衡模式列表
 */
public List<String> getSupportedWhiteBalanceMode() {
    return mShortVideoCore.getSupportedWhiteBalanceMode();
}

/**
 * 构造 PLScreenRecorder 对象
 */
public PLScreenRecorder(Activity activity)

/**
 * 配置屏幕录制参数
 *
 * @param screenSetting       PLScreenRecorderSetting 对象
 * @param microphoneSetting   PLMicrophoneSetting 对象
 */
public boolean prepare(PLScreenRecorderSetting screenSetting,
                       PLMicrophoneSetting microphoneSetting);

/**
 * 1、申请屏幕录制权限
 */
public void requestScreenRecord();

/**
 * 2、获取用户授权信息
 */
public boolean onActivityResult(int requestCode, int resultCode, Intent data);

/**
 * 3、开始屏幕录制
 */
public void start();

/**
 * 4、结束屏幕录制
 */
public void stop();

/**
 * 注册录制状态监听器
 * @param 监听器对象
 */
public void setRecordStateListener(PLScreenRecordStateListener stateListener);

/**
 * 注册音频帧监听器
 * @param 监听器对象
 */
public void setAudioFrameListener(PLAudioFrameListener listener);

/**
 * 外部导入音频数据接口
 * @param buffer        音频 PCM 数据
 * @param tsInNanoTime  时间戳
 */
public void inputAudioFrame(byte[] buffer, long tsInNanoTime);

/**
 * 是否正在进行录制
 */
public boolean isRecording();

/**
 * 构造 PLShortVideoEditor 对象
 * @GLSurfaceView 用于预览视频的 View
 * @setting 编辑配置
 */
public PLShortVideoEditor(GLSurfaceView view, PLVideoEditSetting setting);

/**
 * 构造 PLShortVideoEditor 对象, 需通过 setVideoEditSetting 设置编辑配置
 * @GLSurfaceView 用于预览视频的 View
 */
public PLShortVideoEditor(GLSurfaceView view);

/**
 * 播放视频
 */
public void startPlayback();

/**
 * 播放视频，并添加自定义滤镜效果
 */
public void startPlayback(PLVideoFilterListener listener);

/**
 * 播放视频，并添加自定义滤镜效果，指定监听器中返回的纹理类型为 OES
 */
public void startPlayback(PLVideoFilterListener listener, boolean callbackOES);

/**
 * 恢复播放
 */
public void resumePlayback();

/**
 * 暂停播放
 */
public void pausePlayback();

/**
 * 停止播放
 */
public void stopPlayback();

/**
 * 跳到 msec 处播放
 */
public void seekTo(int msec);

/**
 * 获取当前播放的时间
 */
public int getCurrentPosition();

/**
 * 获取 SDK 自带的滤镜列表
 * @return PLBuiltinFilter 数组
 */
public PLBuiltinFilter[] getBuiltinFilterList();

/**
 * 应用 SDK 自带的滤镜
 * @param 滤镜名，从 getBuiltinFilter 获取
 */
public void setBuiltinFilter(String filterName);

/**
 * 应用 SD 卡中的滤镜
 * @param 滤镜名，滤镜资源的绝对路径
 */
public void setExternalFilter(String filterFilePath);

/**
 * 注册保存视频的监听器
 * @param 监听器对象
 */
public void setVideoSaveListener(PLVideoSaveListener listener);

/**
 * 注册预览视频播放状态的监听器
 * @param 监听器对象
 */
public void setVideoPlayerListener(PLVideoPlayerListener listener);

/**
 * 应用水印设置
 * @param 水印设置变量
 */
public void setWatermark(PLWatermarkSetting setting);

/**
 * 更新预览视频的水印设置变量
 * @param 水印设置变量
 */
public void updatePreviewWatermark(PLWatermarkSetting watermarkSetting);

/**
 * 更新保存视频的水印设置变量
 * @param 水印设置变量
 */
public void updateSaveWatermark(PLWatermarkSetting watermarkSetting);

/**
 * 添加 GIF 水印、贴纸
 * 注意：添加完 GIF 水印之后需要开启预览至少播放一帧才会生效
 * @param 水印设置变量
 */
public void addGifWatermark(PLGifWatermarkSetting watermarkSetting)

/**
 * 移除 GIF 水印、贴纸
 * @param 水印设置变量
 */
public void removeGifWatermark(PLGifWatermarkSetting watermarkSetting)

/**
 * 更新 GIF 水印、贴纸的配置
 * @param 水印设置变量
 */
public void updateGifWatermark(PLGifWatermarkSetting watermarkSetting)

/**
 * 设置视频的旋转角度
 * 注意：该旋转角度的设置，仅支持 2D 纹理，在播放以及保存时指定纹理类型为 OES 纹理的场景下，该接口不生效
 * 
 * @param 旋转角度。仅支持 0、90、180、270
 */
public void setRotation(int rotation)

/**
 * 设置画面镜像
 *
 * @enable 是否开启画面镜像，默认不开启
 */
public void setMirror(boolean enable)

/**
 * 保存视频
 */
public void save();

/**
 * 保存视频，并添加自定义滤镜效果
 */
public void save(PLVideoFilterListener listener);

/**
 * 保存视频，并添加自定义滤镜效果，指定监听器中返回的纹理类型为 OES
 */
public void save(PLVideoFilterListener listener, boolean callbackOES);

/**
 * 取消进行中的视频保存，会清理已生成的文件
 */
public void cancelSave();

/**
 * 设置混音文件（本地音频文件）
 * @param file 混音文件
 */
public void setAudioMixFile(String file);

/**
 * 设置混音文件（assets 下的音频文件）
 * @param afd 混音文件
 */
public void setAudioMixAsset(AssetFileDescriptor afd);

/**
 * 设置混音起始和结束时间位置，单位为 Ms
 *
 * @param startTime 起始时间
 * @param endTime 结束时间
 */
public void setAudioMixFileRange(long startTime, long endTime);

/**
 * 设置原音（前景）和混音（背景）音量
 *
 * @param fgVolume 原音音量
 * @param bgVolume 混音音量
 */
public void setAudioMixVolume(float fgVolume, float bgVolume);

/**
 * 设置是否循环混音文件
 * @param isLooping 是否循环
 */
public void setAudioMixLooping(boolean isLooping);

/**
 * 原音消除
 * @param isMute 是否消除原音
 */
public void muteOriginAudio(boolean isMute);

/**
 * 增加文字特效
 *
 * @param textView 文字特效控件
 */
public void addTextView(PLTextView textView);

/**
 * 删除文字特效
 *
 * @param textView 文字特效控件
 */
public void removeTextView(PLTextView textView);

/**
 * 添加 MV 特效
 *
 * @param MV视频文件路径
 * @param 蒙版文件路径
 */
public void setMVEffect(String mvFilePath, String maskFilePath);

/**
 * 设置变速，只支持 2 的倍数，或 1/2 的倍数
 * 例如：2x, 4x, 1/2x, 1/4x
 * @param 倍数值
 */
public void setSpeed(double speed);

/**
 * 分段设置速度，无法和 setSpeed 同用，即如果调用了该方法，则 setSpeed 方法无效
 * 注：分段变速会导致最后生成的视频的 FPS 不一致，对于恒定速度的场景，请优先选用 setSpeed 进行变速
 * @param speedTimeRanges 视频各个时间段的速度设定
 */
public void setSpeedTimeRanges(List<PLSpeedTimeRange> speedTimeRanges);

/**
 * 添加涂鸦
 *
 * @param paintView 涂鸦控件
 */
public void addPaintView(PLPaintView paintView);

/**
 * 删除涂鸦
 *
 * @param paintView 涂鸦控件
 */
public void removePaintView(PLPaintView paintView);

/**
 * 添加贴图
 *
 * @param imageView 贴图控件
 */
public void addImageView(PLImageView imageView);

/**
 * 删除贴图
 *
 * @param imageView 贴图控件
 */
public void removeImageView(PLImageView imageView);

/**
 * 添加自定义视图
 *
 * @param view 自定义控件
 */
public void addView(View view);

/**
 * 删除自定义视图
 *
 * @param view 自定义控件
 */
public void removeView(View view);

/**
 * 指定特效的时间范围（文字特效，贴图和涂鸦），单位为 Ms
 *
 * @param view        特效控件（PLTextView, PLImageView 或者 PLPaintView）
 * @param beginMs     起始时间戳
 * @param durationMs  特效持续时间
 */
 public void setViewTimeline(View view, long beginMs, long durationMs);

/**
 * 指定视频编码设置
 *
 * @param videoEncodeSetting 视频编码设置
 */
public void setVideoEncodeSetting(PLVideoEncodeSetting videoEncodeSetting);

/**
 * 设置是否使用硬件解码，默认为使用，关闭后则使用软件解码器
 */
public void setHwDecodeEnabled(boolean enabled);

/**
 * 设置是否循环播放
 *
 * @param 是否循环播放
 */
public void setPlaybackLoop(boolean loop);

/**
 * 指定视频的时间范围
 *
 * @param beginMs 起始时间戳
 * @param endMs   结束时间戳
 */
 public void setVideoRange(long beginMs, long endMs);

/**
 * 设置当前视频的编辑配置
 *
 * @param videoEditSetting 视频编辑配置
 */
 public void setVideoEditSetting(PLVideoEditSetting videoEditSetting)

/**
 * 设置播放视频的显示模式
 *
 * @param 显示模式，可为 FIT、FULL、KEEP
 */
public void setDisplayMode(PLDisplayMode displayMode);

/**
 * 构造 PLShortVideoTrimmer 对象
 * @param context 上下文对象
 * @param srcFilePath 源视频文件路径
 * @param dstFilePath 目标视频文件路径
 */
public PLShortVideoTrimmer(Context context, String srcFilePath, String dstFilePath);

/**
 * 剪辑源视频中的 [beginMs-endMs] 部分
 * @param beginMs 起始时间戳
 * @param endMs 结束时间戳
 * @param saveListener 剪辑结果监听器
 * @note beginMs 和 endMs 可参考 从 getKeyFrame() 返回的 PLVideoFrame 中的时间戳
 */
public void trim(long beginMs, long endMs, PLVideoSaveListener saveListener);

/**
 * 剪辑源视频中的 [beginMs-endMs] 部分
 * @param beginMs 起始时间戳
 * @param endMs 结束时间戳
 * @param mode 剪辑模式，可设置为快速模式（TRIM_MODE.FAST）和精准模式 (TRIM_MODE.ACCURATE), 默认为精准模式
 * @param saveListener 剪辑结果监听器
 * @note beginMs 和 endMs 可参考 从 getKeyFrame() 返回的 PLVideoFrame 中的时间戳
 */
public void trim(long beginMs, long endMs, TRIM_MODE mode, PLVideoSaveListener saveListener);

/**
 * 取消进行中的视频剪辑，会清理已生成的文件
 */
public void cancelTrim();

/**
 * 设置剪辑后视频的速度，仅在精确模式 (TRIM_MODE.ACCURATE) 下有效，支持 2 的倍数，或 1/2 的倍数
 * 例如：2x, 4x, 1/2x, 1/4x
 * @param speed 倍数值
 */
public void setSpeed(double speed);

/**
 * 获取源视频时长，单位为 Ms
 * @return 源视频时长
 * @deprecated 该方法已被 PLMediaFile 的 getDurationMs() 所取代
 */
@Deprecated
public long getSrcDurationMs();

/**
 * 获取源视频的视频帧总数
 * @param keyFrame 是否限定返回关键帧总数
 * @return 源视频视频帧总数
 * @deprecated 该方法已被 PLMediaFile 的 getVideoFrameCount(boolean keyFrame) 所取代
 */
@Deprecated
public int getVideoFrameCount(boolean keyFrame);

/**
 * 获取源视频指定时间戳的视频帧
 * @param timeMs 指定的时间戳
 * @param keyFrame 是否限定返回关键帧
 * @return 指定时间戳的视频帧
 * @deprecated 该方法已被 PLMediaFile 的 getVideoFrameByTime(long timeMs, boolean keyFrame) 所取代
 */
@Deprecated
public PLVideoFrame getVideoFrameByTime(long timeMs, boolean keyFrame);

/**
 * 获取源视频指定索引的视频帧
 * @param index 指定的索引
 * @param keyFrame 是否限定返回关键帧
 * @return 指定索引的视频帧
 * @deprecated 该方法已被 PLMediaFile 的 getVideoFrameByIndex(int index, boolean keyFrame) 所取代
 */
@Deprecated
public PLVideoFrame getVideoFrameByIndex(int index, boolean keyFrame);

/**
 * 获取源视频指定时间戳的视频帧，并缩放裁剪到指定宽高。
 * @param timeMs 指定的时间戳
 * @param keyFrame 是否限定返回关键帧
 * @param outputWidth 输出宽度
 * @param outputHeight 输出宽度
 * @return 指定时间戳的视频帧
 * @deprecated 该方法已被 PLMediaFile 的 getVideoFrameByTime(long timeMs, boolean keyFrame, int outputWidth, int outputHeight) 所取代
 */
@Deprecated
public PLVideoFrame getVideoFrameByTime(long timeMs, boolean keyFrame, int outputWidth, int outputHeight);

/**
 * 获取源视频指定索引的视频帧，并缩放裁剪到指定宽高。
 * @param index 指定的索引
 * @param keyFrame 是否限定返回关键帧
 * @param outputWidth 输出宽度
 * @param outputHeight 输出宽度
 * @return 指定索引的视频帧
 * @deprecated 该方法已被 PLMediaFile 的 getVideoFrameByIndex(int index, boolean keyFrame, int outputWidth, int outputHeight) 所取代
 */
@Deprecated
public PLVideoFrame getVideoFrameByIndex(int index, boolean keyFrame, int outputWidth, int outputHeight);

/**
 * 在使用完毕后，请调用该方法销毁资源
 */
public void destroy();

/**
 * 构造 PLShortVideoTranscoder 对象
 * @param context 上下文
 * @param srcFilePath 源视频文件路径
 * @param dstFilePath 目标视频文件路径
 */
public PLShortVideoTranscoder(Context context, String srcFilePath, String dstFilePath)

/**
 * 转码到指定的宽度，高度，码率
 * @param dstWidth 目标宽度
 * @param dstHeight 目标高度
 * @param dstBitrate 目标码率
 * @param saveListener 转码结果监听器
 * @return 是否开始成功
 */
public boolean transcode(int dstWidth, int dstHeight, int dstBitrate, PLVideoSaveListener saveListener)

/**
 * 转码到指定的宽度，高度，码率
 * @param dstWidth 目标宽度
 * @param dstHeight 目标高度
 * @param dstBitrate 目标码率
 * @param reverse 是否进行时光倒流（视频倒置）
 * @param saveListener 转码结果监听器
 * @return 是否开始成功
 */
public boolean transcode(int dstWidth, int dstHeight, int dstBitrate, boolean reverse, PLVideoSaveListener saveListener)

/**
 * 转码到指定的宽度，高度，码率
 * @param dstWidth 目标宽度
 * @param dstHeight 目标高度
 * @param dstBitrate 目标码率
 * @param rotateBy 在源视频的基础上旋转某些角度, 可设置为 0, (-)90, (-)180, (-)270
 * @param reverse 是否进行时光倒流（视频倒置）
 * @param saveListener 转码结果监听器
 * @return 是否开始成功
 */
public boolean transcode(int dstWidth, int dstHeight, int dstBitrate, int rotateBy, boolean reverse, PLVideoSaveListener saveListener)

/**
 * 指定转码输出文件的帧率上限
 *
 * @param maxFrameRate 指定的帧率上限值
 */
public void setMaxFrameRate(int maxFrameRate)

/**
 * 指定裁剪区域的位置和面积
 * NOTE: 如存在旋转，则应依据旋转后的图像决定裁剪位置和面积
 *
 * @param x 裁剪区域左上角横坐标
 * @param y 裁剪区域左上角纵坐标
 * @param width 裁剪区域宽度
 * @param height 裁剪区域高度
 */
public void setClipArea(int x, int y, int width, int height)

/**
 * 取消进行中的视频转码，会清理已生成的文件
 */
public void cancelTranscode()

/**
 * 设置转码水印
 *
 * @param watermarkSetting 水印设置
 */
public void setWatermark(PLWatermarkSetting watermarkSetting)

/**
 * 设置转码目标文件的 ProfileMode
 * 
 * @param profileMode 目标文件的 ProfileMode
 */
public void setProfileMode(PLVideoEncodeSetting.ProfileMode profileMode)

/**
 * 设置转码使用的码率模式
 *
 * @param bitrateMode 码率模式
 */
public void setBitrateMode(PLVideoEncodeSetting.BitrateMode bitrateMode)

/**
 * 设置混音文件
 * 
 * @param mixAudioFile 混音文件路径
 * @param startMs 视频中开始混音的时间
 * @param endMs 视频中结束混音的时间
 * @param looping 是否循环混音
 */
public void setMixAudioFile(String mixAudioFile, long startMs, long endMs, boolean looping)

/**
 * 设置时间范围
 *
 * @param beginMs 开始的时间点
 * @param endMs 结束的时间点
 */
public void setTimeRange(long beginMs, long endMs)

/**
 * 设置画面填充模式
 * @param 画面填充模式
 */
public void setDisplayMode(PLDisplayMode displayMode)

/**
 * 设置是否使用硬件编码器，默认为使用，关闭后则使用软件编码器
 * @param 是否使用硬件编码器
 */
public void setHWEncodeEnable(boolean enable)
  
/**
 * 设置是否使用硬件解码，默认为使用，关闭后则使用软件解码器
 */
public void setHwDecodeEnabled(boolean enabled);

/**
 * 获取源视频时长，单位为 Ms
 * @return 源视频时长
 * @deprecated 该方法已被 PLMediaFile 的 getDurationMs() 所取代
 */
@Deprecated
public long getSrcDurationMs();

/**
 * 获取源视频宽度
 * @return 源视频宽度
 * @deprecated 该方法已被 PLMediaFile 的 getVideoWidth() 所取代
 */
@Deprecated
public int getSrcWidth();

/**
 * 获取源视频高度
 * @return 源视频高度
 * @deprecated 该方法已被 PLMediaFile 的 getVideoHeight() 所取代
 */
@Deprecated
public int getSrcHeight();

/**
 * 获取源视频码率
 * @return 源视频码率
 * @deprecated 该方法已被 PLMediaFile 的 getVideoBitrate() 所取代
 */
@Deprecated
public int getSrcBitrate();

/**
 * 构造 PLShortVideoUploader 对象
 * @param context Android 上下文对象
 * @param uploadSetting 上传配置
 */
public PLShortVideoUploader(Context context, PLUploadSetting uploadSetting)

/**
 * 开始上传 默认返回文件的哈希值作为 key
 * @filePath 上传的文件路径
 * @token 上传的鉴权信息
 */
public void startUpload(String filePath, String token)

/**
 * 上传
 * @filepath 即将上传的文件的路径
 * @key 指定上传后的 key 值
 * @token 上传的凭证，客户端在上传前，需要先从服务端获取上传凭证
 */
 public void startUpload(String filePath, String key, String token)

/**
 * 取消上传
 */
public void cancelUpload()

/**
 * 注册上传结果的监听器
 * @param 监听器对象
 */
public void setUploadResultListener(PLUploadResultListener listener)

/**
 * 注册上传进度的监听器
 * @param 监听器对象
 */
public void setUploadProgressListener(PLUploadProgressListener listener)

/**
 * 将一系列图像转换为 gif
 * @param frames 图像的 bitmap 数据列表
 * @param delayTimeMs gif 里每张图显示的时间
 * @param isLoop gif 是否循环播放
 * @param outputPath 保存路径
 * @param listener 监听器对象
 */
public void composeToGIF(List<Bitmap> frames, int delayTimeMs, boolean isLoop, String outputPath, PLVideoSaveListener listener);

 /**
  * 从视频导出 gif 动图
  *
  * @param inputPath     输入视频文件;
  * @param startTimeMs   起始时间;
  * @param endTimeMs     截止时间;
  * @param pictureCount  总帧数;
  * @param width         输出图像宽度
  * @param height        输出图像高度；
  * @param isLoop        是否循环；
  * @param outputPath    输出 gif 文件;
  * @param listener      监听器对象
  */
public void extractVideoToGIF(final String inputPath, final long startTimeMs, final long endTimeMs, final int pictureCount, final int width, final int height, final boolean isLoop, final String outputPath, final PLVideoSaveListener listener);

/**
 * 取消进行中的 gif 合成任务
 */
public void cancelComposeToGIF();

/**
 * 顺序拼接多个 mp4 视频文件
 *
 * @param srcVideos    源视频文件列表
 * @param dstVideoPath 输出的视频文件路径
 * @param setting      输出的视频文件编码参数
 * @param listener     监听器对象
 * @return 是否开始成功
 */
public boolean composeVideos(List<String> srcVideos, String dstVideoPath, PLVideoEncodeSetting setting, PLVideoSaveListener listener);

/**
 * 顺序拼接多个 mp4 视频文件，并指定内容的缩放模式
 *
 * @param srcVideos    源视频文件列表
 * @param dstVideoPath 输出的视频文件路径
 * @param displayMode  内容缩放模式
 * @param setting      输出的视频文件编码参数
 * @param listener     监听器对象
 * @return 是否开始成功
 */
public boolean composeVideos(List<String> srcVideos, String dstVideoPath, PLDisplayMode displayMode, PLVideoEncodeSetting setting, PLVideoSaveListener listener)

/**
 * 顺序拼接多个 mp4 视频文件，并且指定每段视频文件的范围
 *
 * @param videoRanges  源视频文件范围配置列表
 * @param dstVideoPath 输出的视频文件路径
 * @param setting      输出的视频文件编码参数
 * @param listener     监听器对象
 * @return 是否开始成功
 */
public boolean composeVideoRanges(List<PLVideoRange> videoRanges, String dstVideoPath, PLVideoEncodeSetting setting, PLVideoSaveListener listener);

/**
 * 顺序拼接多个 mp4 视频文件，并且指定每段视频文件的范围和内容缩放模式
 *
 * @param videoRanges  源视频文件范围配置列表
 * @param dstVideoPath 输出的视频文件路径
 * @param displayMode  内容缩放模式
 * @param setting      输出的视频文件编码参数
 * @param listener     监听器对象
 * @return 是否开始成功
 */
public boolean composeVideoRanges(List<PLVideoRange> videoRanges, String dstVideoPath, PLDisplayMode displayMode, PLVideoEncodeSetting setting, PLVideoSaveListener listener)

/**
 * 取消进行中的视频拼接
 */
public void cancelComposeVideos();

/**
* 合成多张图片为 mp4 视频文件
*
* @param items        图片的配置列表
* @param dstVideoPath 输出的视频文件路径
* @param setting      输出的视频文件编码参数
* @param listener     监听器对象
* @return 是否开始成功
*/
public boolean composeImages(List<PLComposeItem> items, String dstVideoPath, PLVideoEncodeSetting setting, PLVideoSaveListener listener);

/**
* 把多张图片和一个音频文件合成为一个 mp4 视频文件
*
* @param items        图片的配置列表
* @param srcAudioPath 输入的音频文件路径
* @param isAudioLoop  是否循环背景音乐
* @param dstVideoPath 输出的视频文件路径
* @param setting      输出的视频文件编码参数
* @param listener     监听器对象
* @return 是否开始成功
*/
public boolean composeImages(List<PLComposeItem> items, String srcAudioPath, boolean isAudioLoop, String dstVideoPath, PLVideoEncodeSetting setting, PLVideoSaveListener listener);

/**
* 把多张图片和一个音频文件合成为一个 mp4 视频文件，并指定图片展示模式
*
* @param items        图片的配置列表
* @param srcAudioPath 输入的音频文件路径
* @param isAudioLoop  是否循环背景音乐
* @param dstVideoPath 输出的视频文件路径
* @param displayMode  图片的展示模式，可为 FIT、FULL、KEEP
* @param setting      输出的视频文件编码参数
* @param listener     监听器对象
* @return 是否开始成功
*/
public boolean composeImages(List<PLComposeItem> items, String srcAudioPath, boolean isAudioLoop, String dstVideoPath, PLDisplayMode displayMode, PLVideoEncodeSetting setting, PLVideoSaveListener listener);

/**
* 取消进行中的图片合成
*/
public void cancelComposeImages();

/**
 * 把多个图片，视频或 GIF 合成为一个 mp4 视频文件
 *
 * @param items         拼接的配置列表
 * @param destVideoPath 输出的视频文件路径
 * @param setting       输出的视频文件编码参数
 * @param listener      监听器对象
 * @return 是否开始成功
 */
public boolean composeItems(List<PLComposeItem> items, String destVideoPath, PLVideoEncodeSetting setting, PLVideoSaveListener listener);

/**
 * 把多个图片，视频或 GIF 和一个音频文件合成为一个 mp4 视频文件
 *
 * @param items         拼接的配置列表
 * @param destVideoPath 输出的视频文件路径
 * @param setting       输出的视频文件编码参数
 * @param mixFilePath   输入的音频文件路径 (需要混音的文件)
 * @param fgVolume      原音音量
 * @param bgVolume      混音音量
 * @param listener      监听器对象
 * @return 是否开始成功
 */
public boolean composeItems(List<PLComposeItem> items, String destVideoPath, PLVideoEncodeSetting setting, String mixFilePath, float fgVolume, float bgVolume, PLVideoSaveListener listener)；

/**
 * 把多个图片，视频或 GIF 和一个音频文件合成为一个 mp4 视频文件，并指定内容的缩放模式
 *
 * @param items         拼接的配置列表
 * @param destVideoPath 输出的视频文件路径
 * @param setting       输出的视频文件编码参数
 * @param mixFilePath   输入的音频文件路径 (需要混音的文件)
 * @param fgVolume      原音音量
 * @param bgVolume      混音音量
 * @param displayMode   内容的缩放模式
 * @param listener      监听器对象
 * @return 是否开始成功
 */
public boolean composeItems(List<PLComposeItem> items, String destVideoPath, PLVideoEncodeSetting setting, String mixFilePath, float fgVolume, float bgVolume, PLDisplayMode displayMode, PLVideoSaveListener listener)

/**
 * 取消进行中的合成.
 */
public void cancelComposeItems();

/**
 * 构造 PLShortAudioRecorder 对象
 */
public PLShortAudioRecorder();

/**
 * 使 PLShortAudioRecorder 暂停工作，通常在 Activity#onPause 中调用
 */
public pause();

/**
 * 使 PLShortAudioRecorder 恢复工作，通常在 Activity#onResume 中调用
 */
public resume();

/**
 * 销毁 PLShortAudioRecorder 对象，通常在 Activity#onDestroy 中调用
 * 将删除已录制的片段
 */
public destory();

/**
 * 销毁 PLShortAudioRecorder 对象，通常在 Activity#onDestroy 中调用
 * @param clearSections 是否删除已录制的片段
 */
public destory(boolean clearSections);

/**
 * Prepare the recorder
 *
 * @param context            Context 对象
 * @param microphoneSetting  PLMicrophoneSetting 对象
 * @param audioEncodeSetting PLAudioEncodeSetting 对象
 * @param recordSetting      PLRecordSetting 对象
 */
public void prepare(Context context,
                    PLMicrophoneSetting microphoneSetting,
                    PLAudioEncodeSetting audioEncodeSetting,
                    PLRecordSetting recordSetting);

/**
 * 开始录制音频片段，需要收到 `onReady` 回调之后执行
 */
public boolean beginSection();

/**
 * 开始录制音频片段，需要收到 `onReady` 回调之后执行
 * @param 指定片段文件名
 */
public boolean beginSection(String sectionFileName);

/**
 * 停止录制当前音频片段
 */
public boolean endSection();

/**
 * 删除上一个录制的音频片段
 */
public boolean deleteLastSection();

/**
 * 删除所有录制的音频片段
 */
public boolean deleteAllSections();

/**
 * 合并录制的音频片段，SDK 将会在缓存目录中临时创建对应文件
 * @param   用于接收合并回调的 listener
 */
public void concatSections(PLVideoSaveListener listener);

/**
 * 取消进行中的音频片段合并，会清理已生成的文件
 */
public void cancelConcat();

/**
 * 注册音频帧监听器
 * @param 监听器对象
 */
public final void setAudioFrameListener(PLAudioFrameListener listener);

/**
 * 注册录制状态监听器
 * @param 监听器对象
 */
public final void setRecordStateListener(PLRecordStateListener listener);

/**
 * 将当前录制的片段与设置项存入草稿箱
 * @param 草稿标签，不同草稿需要有不同的标签，否则保存时会覆盖相同标签的草稿
 */
public boolean saveToDraftBox(String tag) {
    return mShortAudioRecorderCore.saveToDraftBox(tag);
}

/**
 * 从草稿恢复
 * @param context context 对象
 * @param draft 草稿对象
 */
public boolean recoverFromDraft(Context context, PLDraft draft);

/**
 * 构造 PLTransitionMaker 对象
 * @param viewGroup ViewGroup 对象
 * @param setting   PLVideoEncodeSetting 对象
 */
public PLTransitionMaker(ViewGroup viewGroup, PLVideoEncodeSetting setting);

/**
 * 设置过场字幕的背景颜色
 * @param color 背景颜色
 */
public setBackgroundColor(int color);

/**
 * 设置过场字幕的持续时间
 * @param durationMs 持续时间
 */
public void setDuration(int durationMs);

/**
 * 添加文字控件
 * @param textView 文字控件
 */
public void addText(PLTextView textView);

/**
 * 添加图片控件
 * @param imageView 图片控件
 */
public addImage(PLImageView imageView);

/**
 * 在文字控件上添加一个过场动画
 * @param textView   文字控件
 * @param transition 所添加的过场动画
 */
public void addTransition(PLTextView textView, PLTransition transition);

/**
 * 在图片控件上添加一个过场动画
 * @param imageView  图片控件
 * @param transition 所添加的过场动画
 */
public void addTransition(PLImageView imageView, PLTransition transition);

/**
 * 播放过场动画
 */
public void play();

/**
 * 停止播放动画
 */
public void stop();

/**
 * 保存过场字幕为 mp4
 * @param dstFilePath  目标视频文件路径
 * @param saveListener 保存结果监听器
 */
public void save(String dstFilePath, PLVideoSaveListener saveListener);

/**
 * 取消保存
 */
public void cancelSave()

/**
 * 删除所有已添加的控件和过场动画
 */
public void removeAllResource();

/**
 * 在使用完毕后，请调用该方法销毁资源
 */
public void destroy();

/**
 * 构造 PLViewRecorder 对象
 */
public PLViewRecorder();

/**
 * 使 PLViewRecorder 暂停工作，通常在 Activity#onPause 中调用
 */
public pause();

/**
 * 使 PLViewRecorder 恢复工作，通常在 Activity#onResume 中调用
 */
public resume();

/**
 * 销毁 PLViewRecorder 对象，通常在 Activity#onDestroy 中调用
 * 将删除已录制的片段
 */
public destory();

/**
 * 销毁 PLViewRecorder 对象，通常在 Activity#onDestroy 中调用
 * @param clearSections 是否删除已录制的片段
 */
public destory(boolean clearSections);

/**
 * Prepare the recorder
 *
 * @param view               需要录制的 View
 * @param microphoneSetting  PLMicrophoneSetting 对象
 * @param videoEncodeSetting PLVideoEncodeSetting 对象
 * @param audioEncodeSetting PLAudioEncodeSetting 对象
 * @param recordSetting      PLRecordSetting 对象
 */
public void prepare(View view,
                    PLMicrophoneSetting microphoneSetting,
                    PLVideoEncodeSetting videoEncodeSetting,
                    PLAudioEncodeSetting audioEncodeSetting,
                    PLRecordSetting recordSetting);

/**
 * 开始录制片段，需要收到 `onReady` 回调之后执行
 */
public boolean beginSection();

/**
 * 开始录制片段，需要收到 `onReady` 回调之后执行
 * @param 指定片段文件名
 */
public boolean beginSection(String sectionFileName);

/**
 * 停止录制当前片段
 */
public boolean endSection();

/**
 * 删除上一个录制的片段
 */
public boolean deleteLastSection();

/**
 * 删除所有录制的片段
 */
public boolean deleteAllSections();

/**
 * 合并录制的片段，SDK 将会在缓存目录中临时创建对应文件
 * @param   用于接收合并回调的 listener
 */
public void concatSections(PLVideoSaveListener listener);

/**
 * 取消进行中的片段合并，会清理已生成的文件
 */
public void cancelConcat();

/**
 * 注册音频帧监听器
 * @param 监听器对象
 */
public final void setAudioFrameListener(PLAudioFrameListener listener);

/**
 * 注册录制状态监听器
 * @param 监听器对象
 */
public final void setRecordStateListener(PLRecordStateListener listener);

/**
 * 设置倍数拍摄，只支持 2 的倍数，或 1/2 的倍数
 * 例如：2x, 4x, 1/2x, 1/4x
 * 注意调用过一次 beginSection 后，该方法设置无效
 * @param 倍数值
 */
public void setRecordSpeed(double recordSpeed);

/**
 * 设置存储下的音乐文件
 *
 * @param 文件路径
 */
public void setMusicFile(String filePath);

/**
 * 设置 Assets 下的音乐文件
 *
 * @param AssetFileDescriptor
 */
public void setMusicAsset(AssetFileDescriptor afd);

/**
 * 设置音乐文件播放的起始位置
 *
 * @param 起始位置
 */
 public void setMusicPosition(int position);

/**
 * 获取音乐文件当前的播放位置
 *
 * @return 当前播放位置
 */
public int getMusicPosition();

/**
 * 是否消除麦克风采集的声音
 *
 * @param 是否消除声音
 */
public void mute(boolean isMute);

/**
 * 构造 PLExternalMediaRecorder 对象
 */
public PLExternalMediaRecorder(Context context);

/**
 * 初始化 PLExternalMediaRecorder 对象
 *
 * @param videoEncodeSetting 视频编码参数
 * @param audioEncodeSetting 音频编码参数
 * @param recordSetting      录制参数
 * @return status code: true - success; false - failed;
 */
public boolean prepare(PLVideoEncodeSetting videoEncodeSetting,
                       PLAudioEncodeSetting audioEncodeSetting,
                       PLRecordSetting recordSetting);

/**
 * 开始录制
 */
public void start();

/**
 * 停止录制
 */
public void stop();

/**
 * 设置录制状态监听器
 *
 * @param stateListener
 */
public void setRecordStateListener(PLExternalRecordStateListener stateListener);

/**
 * 输入一帧音频数据进行编码
 *
 * @param data
 * @param size
 * @param timestampNs
 */
public void inputAudioFrame(byte[] data, int size, long timestampNs);

/**
 * 输入一帧视频数据进行编码
 *
 * @param data
 * @param width
 * @param height
 * @param rotation
 * @param timestampNs
 */
public void inputVideoFrame(byte[] data, int width, int height, int rotation, long timestampNs);

/**
 * 判断是否正在录制过程中
 * @return
 */
public boolean isRecording();

/**
 * 构造 PLShortVideoMixRecorder 对象
 * 
 * @param context 上下文对象
 */
public PLShortVideoMixRecorder(Context context);

/**
 * 配置 PLShortVideoMixRecorder 的各个参数
 *
 * @param cameraSurfaceView  摄像机预览的 GLSurfaceView
 * @param sampleSurfaceView  样本视频预览的 GLSurfaceView
 * @param videoMixSetting    PLVideoMixSetting 对象
 * @param cameraSetting      PLCameraSetting 对象
 * @param microphoneSetting  PLMicrophoneSetting 对象
 * @param videoEncodeSetting PLVideoEncodeSetting 对象
 * @param audioEncodeSetting PLAudioEncodeSetting 对象
 * @param faceBeautySetting  PLFaceBeautySetting 对象
 * @param recordSetting      PLRecordSetting 对象
 */
public void prepare(GLSurfaceView cameraSurfaceView,
                    GLSurfaceView sampleSurfaceView,
                    PLVideoMixSetting videoMixSetting,
                    PLCameraSetting cameraSetting,
                    PLMicrophoneSetting microphoneSetting,
                    PLVideoEncodeSetting videoEncodeSetting,
                    PLAudioEncodeSetting audioEncodeSetting,
                    PLFaceBeautySetting faceBeautySetting,
                    PLRecordSetting recordSetting);

/**
 * 使 PLShortVideoMixRecorder 暂停工作，通常在 Activity#onPause 中调用
 */
public pause();

/**
 * 使 PLShortVideoMixRecorder 恢复工作，通常在 Activity#onResume 中调用
 */
public resume();

/**
 * 销毁 PLShortVideoMixRecorder 对象，通常在 Activity#onDestroy 中调用
 * 将删除已录制的片段
 */
public destory();

/**
 * 销毁 PLShortVideoMixRecorder 对象，通常在 Activity#onDestroy 中调用
 * @param clearSections 是否删除已录制的片段
 */
public destory(boolean clearSections);

/**
 * 开始录制片段，需要收到 `onReady` 回调之后执行
 */
public boolean beginSection();

/**
 * 开始录制片段，需要收到 `onReady` 回调之后执行
 * @param 指定片段文件名
 */
public boolean beginSection(String sectionFileName);

/**
 * 停止录制当前片段
 */
public boolean endSection();

/**
 * 删除上一个录制的片段
 */
public boolean deleteLastSection();

/**
 * 删除所有录制的片段
 */
public boolean deleteAllSections();

/**
 * 生成合拍视频并保存
 * @param   用于接收保存回调的 listener
 */
public void save(PLVideoSaveListener listener);

/**
 * 取消合拍视频的保存工作
 */
public void cancel();

/**
 * 设置麦克风采集的音频是否静音
 *
 * @param muteMicrophone 麦克风采集的音频是否静音
 */
public void muteMicrophone(boolean muteMicrophone);

/**
 * 设置样本视频是否静音
 *
 * @param muteSampleVideo 样本视频是否静音
 */
public void muteSampleVideo(boolean muteSampleVideo);

/**
 * 获取麦克风音频和样本音频的混合模式，仅在麦克风和样本都不静音的情况下有效
 *
 * @return 麦克风音频和样本音频的混合模式 (可为 SPEAKERPHONE_MODE 或 EARPHONE_MODE)
 */
public PLAudioMixMode getAudioMixMode();

/**
 * 设置麦克风音频和样本音频的混合模式，仅在麦克风和样本都不静音的情况下有效
 *
 * @param 麦克风音频和样本音频的混合模式 (可为 SPEAKERPHONE_MODE 或 EARPHONE_MODE)
 */
public void setAudioMixMode(PLAudioMixMode audioMixMode);

/**
 * 设置麦克风和样本视频的音量，仅在选择了 EARPHONE_MODE 模式下有效
 *
 * @param microphoneVolume 麦克风音量
 * @param sampleVolume     样本音量
 */
public void setAudioMixVolume(float microphoneVolume, float sampleVolume);

/**
 * 注册音频帧监听器
 * @param 监听器对象
 */
public final void setAudioFrameListener(PLAudioFrameListener listener);

/**
 * 注册录制状态监听器
 * @param 监听器对象
 */
public final void setRecordStateListener(PLRecordStateListener listener);

/**
 * 手动对焦，在 prepare 里设置好的 GLSurfaceView 上指定对焦块大小以及相应的中央坐标
 * @param 对焦块的宽度
 * @param 对焦块的高度
 * @param 对焦块的中央X坐标
 * @param 对焦块的中央Y坐标
 */
public void manualFocus(int focusBlockWidth, int focusBlockHeight, int focusBlockCenterX, int focusBlockCenterY);

/**
 * 注册相机对焦监听器
 * @param 对焦监听器
 */
public void setFocusListener(PLFocusListener focusListener);

/**
 * 切换到下一个摄像头
 */
public void switchCamera();

/**
 * 切换到指定摄像头
 */
public void switchCamera(PLCameraSetting.CAMERA_FACING_ID facingId);

/**
 * 设置闪光灯开关
 */
public void setFlashEnabled(boolean enabled);

/**
 * 更新美颜设置
 * @param 美颜设置对象
 */
public final void updateFaceBeautySetting(PLFaceBeautySetting setting);

/**
 * 注册相机预览监听器
 * @param 监听器对象
 */
public final void setCameraPreviewListener(PLCameraPreviewListener listener);

/**
 * 注册相机参数选定监听器
 * @param 监听器对象
 */
public final void setCameraParamSelectListener(PLCameraParamSelectListener listener);

/**
 * 注册自定义美颜、滤镜效果的监听器
 * @param 监听器对象
 */
public final void setVideoFilterListener(PLVideoFilterListener listener);

/**
 * 注册自定义美颜、滤镜效果的监听器
 * @param 监听器对象
 * @param 指定监听器中返回的纹理类型为 OES
 */
public final void setVideoFilterListener(PLVideoFilterListener listener, boolean callbackOES);

/**
 * 获取当前摄像头的最大曝光补偿值
 * @return 最大曝光补偿值
 */
public int getMaxExposureCompensation();

/**
 * 获取当前摄像头的最小曝光补偿值
 * @return 最小曝光补偿值
 */
public int getMinExposureCompensation();

/**
 * 设置曝光补偿值
 */
public void setExposureCompensation(int exposureCompensation);

/**
 * 设置预览画面的缩放值
 * 调用此方法前，请先调用 getZooms 方法获取有效值
 * @param 缩放值
 */
public void setZoom(float zoom);

/**
 * 获取有效的缩放值列表
 * 已由小至大排序
 * @return 如果该分辨率不支持缩放，则返回 null
 */
public List<Float> getZooms();

/**
 * PLShortVideoMixer 的构造方法
 * @param context       Context对象
 * @param dstFilePath   最后生成视频的路径
 * @param maxDurationMs 最后生成视频的时长
 */
PLShortVideoMixer(Context context, String dstFilePath, long maxDurationMs);

/**
 * 设置生成视频的编码配置
 *
 * @param videoEncodeSetting 编码配置
 */
public void setVideoEncodeSetting(PLVideoEncodeSetting videoEncodeSetting);

/**
 * 开始视频拼图
 *
 * @param items        拼图的配置列表
 * @param saveListener 结果回调函数
 */
public void mix(List<PLVideoMixItem> items, PLVideoSaveListener saveListener);

/**
 * 取消视频拼图
 */
public void cancel();

/**
 * 设置日志等级
 *
 * @param level 日志等级，分别为 Log.VERBOSE、Log.DEBUG、Log.INFO、Log.WARN、Log.ERROR
 */
public static void setLogLevel(int level)

/**
 * 查询包名鉴权信息
 *
 * @param context 上下文
 * @param callback 包名鉴权信息的回调
 */
public static void checkAuthentication(Context context, PLAuthenticationResultCallback callback)

public interface PLAuthenticationResultCallback {
    /**
     * 未知鉴权（网络无连接等场景下会回调该结果）
     */
    int UnCheck = -1;

    /**
     * 未鉴权
     */
    int UnAuthorized = 0;

    /**
     * 已鉴权
     */
    int Authorized = 1;

    /**
     * 回调鉴权信息的结果
     *
     * @param result 根据包名鉴权的结果
     */
    void onAuthorizationResult(int result);
}

/**
 * 构造 PLShortVideoReader 对象
 * @context 上下文
 */
public PLShortVideoReader(Context context);

/**
 * 开始读取指定视频的视频帧
 * @param path 视频地址
 * @param listener 视频帧读取监听回调
 */
public void startRead(String path, PLVideoReadListener listener);

/**
 * 取消读取指定视频的视频帧
 */
public void cancelRead();

/**
 * 设置采集摄像头
 * @param 默认设置为手机的后置摄像头
 */
public PLCameraSetting setCameraId(PLCameraSetting.CAMERA_FACING_ID cameraId);

/**
 * 设置采集画面的分辨率
 * @param 可以选择从 120P 到 1200P 之间的多种分辨率。默认设置为 480P
 */
public PLCameraSetting setCameraPreviewSizeLevel(PLCameraSetting.CAMERA_PREVIEW_SIZE_LEVEL level); 

/**
 * 设置采集画面的长宽比
 * @param 可以选择 4:3 或 16:9。默认设置为 16:9
 */
public PLCameraSetting setCameraPreviewSizeRatio(PLCameraSetting.CAMERA_PREVIEW_SIZE_RATIO ratio);

/**
 * 设置屏幕录制尺寸
 */
public PLScreenRecorderSetting setSize(int width, int height);

/**
 * 设置 DPI
 */
public PLScreenRecorderSetting setDpi(int dpi);

/**
 * 设置屏幕录制 FPS
 */
public PLScreenRecorderSetting setFps(int fps)

/**
 * 设置屏幕录制文件保存位置
 * @param recordFile
 */
public PLScreenRecorderSetting setRecordFile(String recordFile);

/**
 * 设置是否由外部导入音频
 * @param inputAudioEnabled 
 */
public PLScreenRecorderSetting setInputAudioEnabled(boolean inputAudioEnabled);

/**
 * 设置编码码率
 * @param 码率，单位为 bps，默认为 4000 * 1024
 */
public PLScreenRecorderSetting setEncodingBitrate(int bitrate);

/**
 * 设置音频采集源
 * @param 默认为系统的 MediaRecorder.AudioSource.MIC，可时情况进行修改
 */
public PLMicrophoneSetting setAudioSource(int source);

/**
 * 设置音频格式
 * @param 默认为系统的 AudioFormat.ENCODING_PCM_16BIT，其他格式可能不兼容部分设备，请视情况使用
 */
public PLMicrophoneSetting setAudioFormat(int format);

/**
 * 设置音频声道
 * @param 默认为系统的 AudioFormat.CHANNEL_IN_MONO，其他格式如 AudioFormat.CHANNEL_IN_STEREO 可能不兼容部分设备，请视情况使用
 */
public PLMicrophoneSetting setChannelConfig(int channelConfig);

/**
 * 设置音频采样率
 * @param 采样率, 默认为 44100，其他设置可能不兼容部分设备，请视情况使用
 */
public PLMicrophoneSetting setSampleRate(int rate);

/**
 * 开启音频 PTS 优化，有助于降低音画不同步概率，略微消耗计算资源
 * @param 是否开启。默认开启
 */
public PLMicrophoneSetting setAudioPtsOptimizeEnabled(boolean enable);

/**
 * 设置是否开启蓝牙 SCO，如果使用蓝牙耳机采集音频
 * @param 是否开启。默认关闭
 */
public PLMicrophoneSetting setBluetoothSCOEnabled(boolean enable);

/**
 * 设置是否开启降噪功能
 * @param 是否开启。默认关闭
 * @return 是否设置成功
 */
public boolean setNSEnabled(boolean enabled);

/**
 * 设置是否开启回声消除功能
 * @param 是否开启。默认关闭
 * @return 是否设置成功
 */
public boolean setAECEnabled(boolean enabled);

/**
 * 判断手机是否支持双声道麦克风采集
 * @return 是否支持
 */
public static boolean isSupportChannelInStereo()

/**
 * 设置编码码率
 * @param 码率，单位为 bps，默认为 1000 * 1000
 */
public PLVideoEncodeSetting setEncodingBitrate(int bitrate);

/**
 * 设置码率模式
 * QUALITY_PRIORITY ：表示编码器会根据图像的复杂度来动态调整输出码率，最后的视频码率会在一定的范围波动
 * BITRATE_PRIORITY ：表示编码器会尽量把输出码率控制为设定值
 * CONSTANT_QUALITY_PRIORITY ：表示编码器完全不控制码率，尽最大可能保证图像质量
 * @param 可选择 QUALITY_PRIORITY , BITRATE_PRIORITY 或 CONSTANT_QUALITY_PRIORITY
 * @param 默认设置为 `QUALITY_PRIORITY`
 */
public PLVideoEncodeSetting setEncodingBitrateMode(PLVideoEncodeSetting.BitrateMode mode);

/**
 * 设置 profile 模式（软编码 or 硬编码系统 API 16+）
 * 质量：HIGH > MAIN > BASELINE
 * 性能与兼容性：BASELINE > MAIN > HIGH
 * @param 可选择 HIGH、MAIN、BASELINE
 * @param 默认设置为 `BASELINE`
 */
public PLVideoEncodeSetting setProfileMode(PLVideoEncodeSetting.ProfileMode mode);

/**
 * 设置编码 fps
 * @param fps 值，默认设置为 30
 */
public PLVideoEncodeSetting setEncodingFps(int fps);

/**
 * 设置编码视频的分辨率
 * @param 可以选择从 240P 到 1200P 之间的多种分辨率，默认设置为 480 * 480
 */
public PLVideoEncodeSetting setEncodingSizeLevel(PLVideoEncodeSetting.VIDEO_ENCODING_SIZE_LEVEL level);

/**
 * 如果 SDK 内置的分辨率列表不能满足需求，可以通过此方法自定义编码视频的分辨率
 * @param width 宽度
 * @param height 高度
 */
public PLVideoEncodeSetting setPreferedEncodingSize(int width, int height);

/**
 * 设置编码视频关键帧的间隔
 * @param 单位为帧数，默认设置为 30 帧
 */
public PLVideoEncodeSetting setIFrameInterval(int interval);

/**
 * 设置 H.264 编码方式
 * @param 是否开启 H.264 硬编 - true:硬编 false:软编
 */
public PLVideoEncodeSetting setHWCodecEnabled(boolean enabled)

/**
 * 设置视频旋转角度（通过 Metadata 实现，目前仅在视频录制时有效）
 * @param 旋转角度 90 的倍数（可为负数）
 */
public PLVideoEncodeSetting setRotationInMetadata(int rotationInMetadata)

/**
 * 设置视频宽高拉伸模式
 * 
 * @param displayMode 视频宽高拉伸模式
 */
public PLVideoEncodeSetting setDisplayMode(PLDisplayMode displayMode)

/**
 * 设置编码码率
 * @param 码率，单位为 bps，默认为 44100
 */
public PLAudioEncodeSetting setBitrate(int bitrate);

/**
 * 设置音频声道数量
 * @param 声道数量，目前只支持 1 (默认) 和 2，分别对应 PLMicrophoneSetting 声道设置的 AudioFormat.CHANNEL_IN_MONO 与 AudioFormat.CHANNEL_IN_STEREO
 */
public PLAudioEncodeSetting setChannels(int channels);

/**
 * 设置音频采样率
 * @param 采样率, 默认为 44100，需要与采集时的设置保持一致
 */
public PLAudioEncodeSetting setSampleRate(int sampleRate);

/**
 * 设置 AAC 编码方式
 * @param 是否开启 AAC 硬编 - true:硬编 false:软编
 */
public PLAudioEncodeSetting setHWCodecEnabled(boolean enabled)

 /**
  * 构造 PLFaceBeautySetting 对象
  * @param beauty 美颜程度，0-1 递增
  * @param whiten 美白程度，0-1 递增
  * @param redden 红润程度，0-1 递增
  */
public PLAudioEncodeSetting(float beauty, float whiten, float redden);

/**
 * 设置是否开启美颜
 * @param 是否开启。默认开启
 */
public void setEnable(boolean enable);

/**
 * 设置美颜程度
 * @param 0-1 递增
 */
public void setBeautyLevel(float level);

/**
 * 设置美白程度
 * @param 0-1 递增
 */
public void setWhiten(float level);

/**
 * 设置红润程度
 * @param 0-1 递增
 */
public void setRedden(float level);

/**
 * 设置最大录制长度
 * @param 最大录制长度，单位 ms，默认 10*1000
 */
public PLRecordSetting setMaxRecordDuration(int duration);

/**
 * 设置视频缓存目录
 * @param 缓存目录
 */
public PLRecordSetting setVideoCacheDir(File dir);
public PLRecordSetting setVideoCacheDir(String dir);

/**
 * 设置录制的视频文件全路径，默认从缓冲目录随机生成
 * @param 视频文件全路径
 */
public PLRecordSetting setVideoFilepath(String filepath);

/**
 * 设置录制时 Camera preview 在 GLSurfaceView 和编码中的显示模式
 * @param 显示模式，可为 FIT、FULL、KEEP
 */
public PLRecordSetting setDisplayMode(PLDisplayMode displayMode);

/**
 * 设置编辑保存后是否保留原始文件
 *
 * @param 是否保留原始文件
 */
public PLVideoEditSetting setKeepOriginFile(boolean keepOriginFile);

/**
 * 设置需要编辑的视频文件地址
 *
 * @param 原视频文件地址
 */
public PLVideoEditSetting setSourceFilepath(String filepath);

/**
 * 设置 `save` 保存视频地址
 *
 * @param 保存视频地址
 */
public PLVideoEditSetting setDestFilepath(String filepath);

/**
 * 设置动态贴纸是否开启预览
 *
 * @param 开启或关闭
 */
public PLVideoEditSetting setGifPreviewEnabled(boolean enabled);

/**
 * 设置水印素材 Bitmap
 * @param bitmap
 */
public void setBitmap(int bitmap);

/**
 * 设置水印素材 ID, 如果已设置 Bitmap, 此设置将失效
 * @param resource id
 */
public void setResourceId(int resourceId);

/**
 * 设置水印位置
 * @param x 水印左上角在视频 x 轴上的位置，0-1
 * @param y 水印左上角在视频 y 轴上的位置，0-1
 */
public void setPosition(float x, float y);

/**
 * 设置水印大小
 * @param width 水印宽度在视频 x 轴上的占比，0-1
 * @param height 水印高度在视频 y 轴上的占比，0-1
 */
public void setSize(float width, float height);

/**
 * 设置水印旋转角度
 * @param rotation 水印的旋转角度
 */
public void setRotation(int rotation)

/**
 * 设置水印透明度
 * @param alpha 0-255
 */
public void setAlpha(int alpha);

/**
 * 设置水印层级是否为最上层
 * @param zOrder 水印是否在最上层，此设置只对保存有效，预览不受其约束
 */
public void setZOrderOnTop(boolean onTop)

/**
 * 设置分片上传时，每片的大小，默认 2M
 *
 * @param chunkSize
 */
public PLUploadSetting setChunkSize(int chunkSize)

/**
 * 设置启用分片上传阈值，默认 4M
 *
 * @param putThreshhold
 */
public PLUploadSetting setPutThreshhold(int putThreshhold)

/**
 * 设置链接超时时间，默认10秒
 *
 * @param connectTimeout
 */
public PLUploadSetting setConnectTimeout(int connectTimeout)

/**
 * 设置服务器相应超时时间，默认60秒
 *
 * @param responseTimeout
 */
public PLUploadSetting setResponseTimeout(int responseTimeout)

/**
 * 设置区域，指定不同区域的上传域名、备用域名、备用IP
 *
 * @param zone 上传区域，如果传入 null，则 SDK 内部会自动判断选择合适的区域
 */
public PLUploadSetting setZone(PLUploadZone zone)

/**
 * 是否启用 https 上传，默认不启用
 *
 * @param enabled
 */
public PLUploadSetting setHttpsEnabled(boolean enabled)

/**
 * 配置上传自定义变量
 *
 * @param params
 */
public PLUploadSetting setParams(Map<String, String> params)

/**
 * 创建合拍配置对象
 *
 * @param cameraVideoRect         摄像头拍摄视频的位置区域
 * @param sampleVideoRect         样本视频的位置区域
 * @param sampleVideoPath         样本视频的路径
 * @param cameraRecodingCachePath 摄像机录制的片段最后拼接的缓存视频的路径，它用于和样本视频最后进行合成
 */
public PLVideoMixSetting(Rect cameraVideoRect, Rect sampleVideoRect, String sampleVideoPath, String cameraRecodingCachePath)

/**
 * 创建合拍配置对象（可指定样本视频的显示模式）
 *
 * @param cameraVideoRect         摄像头拍摄视频的位置区域
 * @param sampleVideoRect         样本视频的位置区域
 * @param sampleVideoPath         样本视频的路径
 * @param sampleDisplayMode       样本视频的显示模式
 * @param cameraRecodingCachePath 摄像机录制的片段最后拼接的缓存视频的路径，它用于和样本视频最后进行合成
 */
public PLVideoMixSetting(Rect cameraVideoRect, Rect sampleVideoRect, String sampleVideoPath, PLDisplayMode sampleDisplayMode, String cameraRecodingCachePath);

/**
 * 创建合拍配置对象（可指定样本视频的显示模式和上下层级）
 *
 * @param cameraVideoRect         摄像头拍摄视频的位置区域
 * @param sampleVideoRect         样本视频的位置区域
 * @param sampleVideoPath         样本视频的路径
 * @param sampleDisplayMode       样本视频的显示模式
 * @param cameraAboveSample       录制视频是否出于样本视频上方
 * @param cameraRecodingCachePath 摄像机录制的片段最后拼接的缓存视频的路径，它用于和样本视频最后进行合成
 */
public PLVideoMixSetting(Rect cameraVideoRect, Rect sampleVideoRect, String sampleVideoPath, PLDisplayMode sampleDisplayMode, boolean cameraAboveSample, String cameraRecodingCachePath);

/**
 * 设置水印素材的路径
 * @param filePath 文件路径
 */
public void setFilePath(String filePath);

/**
 * 设置水印位置
 * @param x 水印左上角在视频 x 轴上的位置，0-1
 * @param y 水印左上角在视频 y 轴上的位置，0-1
 */
public void setPosition(float x, float y);

/**
 * 设置水印大小
 * @param width 水印宽度在视频 x 轴上的占比，0-1
 * @param height 水印高度在视频 y 轴上的占比，0-1
 */
public void setSize(float width, float height);

/**
 * 设置水印透明度
 * @param alpha, 0-255
 */
public void setAlpha(int alpha);

/**
 * 设置水印角度（顺时针旋转）
 * @param rotation 旋转角度
 */
public void setRotation(int rotation)

/**
 * 设置水印显示的开始时间以及持续时间
 * @param startTimeMs 开始时间，单位：ms
 * @param durationMs 水印显示时长，单位：ms
 */
public void setDisplayPeriod(long startTimeMs, long durationMs);

/**
 * 设置拼图视频路径
 *
 * @param videoPath 拼图的视频路径
 */
PLVideoMixItem setVideoPath(String videoPath);

/**
 * 设置拼图视频的矩形区域
 *
 * @param videoRect 矩形区域
 */
PLVideoMixItem setVideoRect(Rect videoRect);

/**
 * 设置拼图视频是否循环
 *
 * @param looping 是否循环
 */
PLVideoMixItem setLooping(boolean looping);

/**
 * 设置该视频的开始播放时间
 *
 * @param startTimeMs 开始播放时间
 */
PLVideoMixItem setStartTimeMs(int startTimeMs);

/**
 * 设置该视频的显示模式
 *
 * @param mode 显示模式，可为 FIT、FULL、KEEP
 */
PLVideoMixItem setDisplayMode(PLDisplayMode mode);

/**
 * 设置该视频的音量大小
 *
 * @param volume 音量
 */
PLVideoMixItem setVolume(float volume);

/**
 * 当预览画面有视频帧待渲染时触发
 * @param data 视频帧数据
 * @param width 视频帧宽度
 * @param height 视频帧高度
 * @param rotation 视频角度，顺时针 0/90/180/270 度
 * @param fmt 视频格式，在 PLFourCC 类中定义
 * @param timestamp 该帧的时间戳，单位为 ns
 */
boolean onPreviewFrame(byte[] data, int width, int height, int rotation, int fmt, long timestampNs);

/**
 * 录制失败时触发
 * @param 错误码，在 PLErrorCode 中定义
 */
void onAudioRecordFailed(int errorCode);

/**
 * 当有待处理的音频帧时触发
 * @param data PCM 数据
 * @param timestampUs 音频帧时间戳，单位为 ns
 */
void onAudioFrameAvailable(byte[] data, long timestampNs);

/**
 * 当预览尺寸确定时触发
 * @param 此设备支持的尺寸列表
 * @return 选择的尺寸
 */
Camera.Size onPreviewSizeSelected(List<Camera.Size> list);

/**
 * 当采集视频的 fps 确定时触发
 * @param 此设备支持的 fps 列表
 * @return 选择的 fps
 */
int[] onPreviewFpsSelected(List<int[]> list);

/**
 * 当摄像头预览对焦模式确定时触发
 * 当返回的对焦模式为 null 且当前摄像头支持 FOCUS_MODE_CONTINUOUS_VIDEO 模式时会自动选择 FOCUS_MODE_CONTINUOUS_VIDEO 模式
 *
 * @param 当前摄像头支持的对焦模式列表
 * @return 选择的对焦模式
 */
String onFocusModeSelected(List<String> list);

/**
 * 当准备完毕可以进行录制时触发
 */
void onReady();

/**
 * 当录制的片段过短时触发
 */
void onDurationTooShort();

/**
 * 录制开始
 */
void onRecordStarted();

/**
 * 录制结束
 */
void onRecordStopped();

/**
 * 实时返回录制视频时长
 */
void onSectionRecording(long sectionDurationMs, long videoDurationMs, int sectionCount);
    
/**
 * 当有新片段录制完成时触发
 * @param incDuration   增加的时长
 * @param totalDuration 总时长
 * @param sectionCount  当前的片段总数
 */
void onSectionIncreased(long incDuration, long totalDuration, int sectionCount);

/**
 * 当有片段被删除时触发
 * @param decDuration   减少的时长
 * @param totalDuration 总时长
 * @param sectionCount  当前的片段总数
 */
void onSectionDecreased(long decDuration, long totalDuration, int sectionCount);

/**
 * 当录制全部完成时触发
 */
void onRecordCompleted();

/**
 * 当准备完毕可以进行屏幕录制时触发
 */
void onReady();

/**
 * 当有异常发生时触发
 */
void onError(int code);

/**
 * 屏幕录制开始
 */
void onRecordStarted();

/**
 * 屏幕录制结束
 */
void onRecordStopped();

/**
 * 当有新的 surface 创建时触发
 **/
void onSurfaceCreated();

/**
 * 当 surface 发生改变时触发
 * @param width 宽度
 * @param height 高度
 *
 **/
void onSurfaceChanged(int width, int height);

/**
 * 当 Surface 销毁时触发
 **/
void onSurfaceDestroy();

/**
 * 绘制帧时触发
 * @param texId 待渲染的 SurfaceTexture 对象的 texture ID
 * @param texWidth 绘制的 surface 宽度
 * @param texHeight 绘制的 surface 高度
 * @param timeStampNs 该帧的时间戳，单位 Ns
 * @param transformMatrix 一般为单位矩阵，除非返回的纹理类型为 OES
 * @return 新创建的制定给 SurfaceTexuture 对象的 texture ID，类型必须为 GL_TEXTURE_2D
 **/
int onDrawFrame(int texId, int texWidth, int texHeight, long timeStampNs, float[] transformMatrix);

/**
 * 保存成功时触发
 * @param 编辑后的视频文件
 */
void onSaveVideoSuccess(File editedFile);

/**
 * 保存失败时触发
 * @param 错误码，在 PLErrorCode 中定义
 */
void onSaveVideoFailed(int errorCode);

/**
 * 保存取消时触发
 */
void onSaveVideoCanceled();

/**
 * 保存进度更新时触发
 * @param 进度百分比
 */
void onProgressUpdate(float percentage);

/**
 * 上传成功时触发
 * @param response 上传成功信息
 */
void onUploadVideoSuccess(JSONObject response);

/**
 * 上传失败时触发
 * @param statusCode 返回值
 * @param error 错误信息
 */
void onUploadVideoFailed(int statusCode, String error);

/**
 * 上传进度改变时触发
 * @param fileName 文件名
 * @param percent 上传进度
 */
void onUploadProgress(String fileName, double percent);

/**
 * 启动手动对焦是否成功
 * @param 启动手动对焦结果
 */
void onManualFocusStart(boolean result);

/**
 * 手动对焦是否成功
 * @param 手动对焦结果
 */
void onManualFocusStop(boolean result);

/**
 * 当前手动对焦被取消，因另一个手动对焦事件被触发了
 */
void onManualFocusCancel();

/**
 * 连续自动对焦启动事件
 * 只有在 PLCameraParamSelectListener#onFocusModeSelected(List) 中选择了
 * FOCUS_MODE_CONTINUOUS_VIDEO 或 FOCUS_MODE_CONTINUOUS_PICTURE 的对焦方式才会被触发
 */
void onAutoFocusStart();

/**
 * 连续自动对焦停止事件
 * 只有在 PLCameraParamSelectListener#onFocusModeSelected(List) 中选择了
 * FOCUS_MODE_CONTINUOUS_VIDEO 或 FOCUS_MODE_CONTINUOUS_PICTURE 的对焦方式才会被触发
 */
void onAutoFocusStop();

/**
 * 当预览帧被截取后回调
 * @param capturedFrame 截取到的帧
 */
public void onFrameCaptured(PLVideoFrame capturedFrame);

/**
 * 当预览视频播放完成后回调
 */
void onCompletion();

/**
 * 当准备完毕可以进行外部音视频数据导入录制时触发
 */
void onReady();

/**
 * 当有异常发生时触发
 */
void onError(int code);

/**
 * 外部音视频数据导入录制开始
 */
void onRecordStarted();

/**
 * 外部音视频数据导入录制结束
 */
void onRecordStopped();

    /**
     * 添加一张图片
     */
    public void addItem(PLComposeItem item);

    /**
     * 删除图片
     */
    public void removeItem(PLComposeItem item);

    /**
     * 获取合成总时长 毫秒
     */
    public long getDurationMs();

    /**
     * 释放对象
     */
    public void release();

    /**
     * 保存合成视频
     */
    public void save(String outputPath, PLVideoEncodeSetting setting, PLVideoSaveListener listener);

    /**
     * 取消合成
     */
    public void cancelSave();

    /**
     * 设置预览监听
     */
    public void setPreviewListener(PLPreviewListener listener);

    /**
     * 设置预览 SurfaceTexture
     */
    public void setPreviewTexture(SurfaceTexture surfaceTexture);

    /**
     * 设置预览 Surface
     */
    public void setPreviewSurface(Surface surface, boolean autoRelease);

    /**
     * 设置预览宽高
     */
    public void setPreviewSize(int width, int height);

    /**
     * 循环播放
     */
    public void setPreviewLoop(boolean loop);

    /**
     * 开始预览
     */
    public void startPreview();

    /**
     * 恢复预览
     */
    public void resumePreview();

    /**
     * 暂停预览
     */
    public void pausePreview();

    /**
     * 停止预览
     */
    public void stopPreview();

    /**
     * seek 预览到对应毫秒
     */
    public void seekPreview(long timeMs);

    /**
     * 预览监听
     */
    public interface PLPreviewListener {
        /**
         * 进度更新
         */
        void onProgress(float progress);

        /**
         * 预览播放完成
         */
        void onCompleted();
    }

/**
 * 开始读取视频帧
 */
void onStart();

/**
 * 视频帧回调
 * @param texId 视频帧纹理
 * @param texWidth 纹理宽度
 * @param texHeight 纹理高度
 * @param rotation 角度信息
 * @param timestampNs 时间戳，单位 ns
 * @param transformMatrix 纹理矩阵
 */
void onDrawFrame(int texId, int texWidth, int texHeight,int rotation, long timestampNs, float[] transformMatrix);

/**
 * 读取结束
 */
void onFinish();

/**
 * 取消读取视频帧
 */
void onCancel();

/**
 * 读取出错
 * @param error 错误码
 */
void onError(int error);

/**
 * 获取帧数据
 */
public byte[] getData();
/**
 * 获取帧数据格式
 */
public DATA_FORMAT getDataFormat();
/**
 * 是否关键帧
 */
public boolean isKeyFrame();
/**
 * 获取帧宽度
 */
public int getWidth();
/**
 * 获取帧高度
 */
public int getHeight();
/**
 * 获取正常显示时应当旋转的角度
 */
public int getRotation();
/**
 * 将帧数据转换为 Bitmap
 */
public Bitmap toBitmap();
/**
 * 获取帧时间戳
 */
public long getTimestampMs();

public enum DATA_FORMAT {
    ARGB_8888,
    RGB_565
}

/**
 * 构造函数
 * @param filepath 视频文件路径
 */
public PLMediaFile(String filepath);

/**
 * 销毁申请的资源
 */
public void release();

/**
 * 文件中是否存在视频轨
 */
public boolean hasVideo();

/**
 * 文件中是否存在音频轨
 */
public boolean hasAudio();

/**
 * 获取文件路径
 */
public String getFilepath();

/**
 * 获取视频时长
 */
public long getDurationMs();

/**
 * 获取视频的宽
 */
public int getVideoWidth();

/**
 * 获取视频的高
 */
public int getVideoHeight();

/**
 * 获取视频的帧率
 */
public int getVideoFrameRate();

/**
 * 获取视频的码率
 */
public int getVideoBitrate();

/**
 * 获取视频的关键帧间隔
 */
public int getVideoIFrameInterval();

/**
 * 获取视频的角度
 */
public int getVideoRotation();

/**
 * 获取音频的通道数
 */
public int getAudioChannels();

/**
 * 获取音频的采样率
 */
public int getAudioSampleRate();

/**
 * 判断视频是否为 H265 编码格式
 */
public boolean isH265Encode();

/**
 * 获取源视频的视频帧总数
 * @param keyFrame 是否限定返回关键帧总数
 * @return 源视频视频帧总数
 */
public int getVideoFrameCount(boolean keyFrame);

/**
 * 获取源视频指定时间戳的视频帧
 * @param timeMs 指定的时间戳
 * @param keyFrame 是否限定返回关键帧
 * @return 指定时间戳的视频帧
 */
public PLVideoFrame getVideoFrameByTime(long timeMs, boolean keyFrame);

/**
 * 获取源视频指定时间戳的视频帧，并缩放裁剪到指定宽高。
 * @param timeMs 指定的时间戳
 * @param keyFrame 是否限定返回关键帧
 * @param outputWidth 输出宽度
 * @param outputHeight 输出高度
 * @return 指定时间戳的视频帧
 */
public PLVideoFrame getVideoFrameByTime(long timeMs, boolean keyFrame, int outputWidth, int outputHeight);

/**
 * 获取源视频指定索引的视频帧
 * @param index 指定的索引
 * @param keyFrame 是否限定返回关键帧
 * @return 指定索引的视频帧
 */
public PLVideoFrame getVideoFrameByIndex(int index, boolean keyFrame);

/**
 * 获取源视频指定索引的视频帧，并缩放裁剪到指定宽高。
 * @param index 指定的索引
 * @param keyFrame 是否限定返回关键帧
 * @param outputWidth 输出宽度
 * @param outputHeight 输出宽度
 * @return 指定索引的视频帧
 */
public PLVideoFrame getVideoFrameByIndex(int index, boolean keyFrame, int outputWidth, int outputHeight);

/**
 * 构造函数
 * @param filePath 图片文件路径
 */
public PLComposeItem(String filePath);

/**
 * 设置拼接类型（可分别为：图片，GIF 和视频类型）
 * @param itemType 拼接类型
 */
public void setItemType(ItemType itemType);

/**
 * 获取拼接类型
 */
public ItemType getItemType();

/**
 * 获取文件路径
 */
public String getFilePath();

/**
 * 获取持续时间
 */
public long getDurationMs();

/**
 * 获取转场特效时间
 */
public long getTransitionTimeMs();

/**
 * 设置文件路径
 *
 * @param filePath 文件路径
 */
public PLComposeItem setFilePath(String filePath);

/**
 * 设置持续时间
 *
 * @param durationMs 持续时间
 */
public PLComposeItem setDurationMs(long durationMs);

/**
 * 设置转场特效时间
 *
 * @param transitionTimeMs 转场特效时间
 */
public PLComposeItem setTransitionTimeMs(long transitionTimeMs);

/**
  * 获取转场特效，注意PLTransitionType 仅在使用 PLImageComposer 合成时才生效
  *
  * @return 转场特效
  */
public PLTransitionType getTransitionType();

/**
  * 设置转场特效，注意PLTransitionType 仅在使用 PLImageComposer 合成时才生效
  *
  * @param transitionType 转场特效
  */
public void setTransitionType(PLTransitionType transitionType);

    /**
     * 获取草稿标签
     */
    public String getTag();
    
    /**
     * 获取草稿中的片段数
     */
    public int getSectionCount();
    
    /**
     * 获取片段的开始时间，单位为 ms；如果片段不存在，则返回 -1
     * @param index 草稿列表的 index
     */
    public long getSectionStartTime(int index);

    /**
     * Get 获取片段的长度，单位为 ms；若片段不存在，则返回 -1
     * @param index 草稿列表的 index
     */
    public long getSectionDuration(int index);

    /**
     * 获取片段的绝对路径；若片段不存在，则返回 null
     * @param index 草稿列表的 index
     */
    public String getSectionFilePath(int index);

    /**
     * 获取保存的 PLCameraSetting
     */
    public PLCameraSetting getCameraSetting();

    /**
     * 获取保存的 PLMicrophoneSetting 
     */
    public PLMicrophoneSetting getMicrophoneSetting();

    /**
     * 获取保存的 PLVideoEncodingSetting
     */
    public PLVideoEncodeSetting getVideoEncodeSetting();

    /**
     * 获取保存的 PLAudioEncodingSetting
     */
    public PLAudioEncodeSetting getAudioEncodeSetting();

    /**
     * 获取保存的 PLFaceBeautySetting
     */
    public PLFaceBeautySetting getFaceBeautySetting();

    /**
     * 获取保存的 PLRecordSetting
     */
    public PLRecordSetting getRecordSetting();

/**
 * 获取草稿箱
 * @param context context
 */
public static PLDraftBox getInstance(Context context);

/**
 * 通过标签获取草稿，若不存在对应的草稿则返回 null
 * @param 草稿标签
 */
public PLDraft getDraftByTag(String tag);

/**
 * 获取所有草稿，若无草稿则返回一个空的 ArrayList
 */
public List<PLDraft> getAllDrafts();

/**
 * 通过标签删除草稿
 * @param tag 草稿标签
 * @param deleteSectionFiles 是否删除草稿中的分段视频文件
 */
public void removeDraftByTag(String tag, boolean deleteSectionFiles);

/**
 * 删除所有草稿
 * @param deleteSectionFiles 是否删除草稿中的分段视频文件
 */
public void removeAllDrafts(boolean deleteSectionFiles);

/**
 * 构造函数
 * @param startTimeMs 动画开始时间
 * @param durationMs  动画持续时间
 * @param fromAlpha   起始透明度 (范围为：0-1)
 * @param toAlpha     结束透明度 (范围为：0-1)
 */
public PLFadeTransition(long startTimeMs, long durationMs, float fromAlpha, float toAlpha);

/**
 * 构造函数
 * @param startTimeMs 动画开始时间
 * @param durationMs  动画持续时间
 * @param fromX       起始位置的 X 坐标
 * @param fromY       起始位置的 Y 坐标
 * @param toX         终止位置的 X 坐标
 * @param toY         终止位置的 Y 坐标
 */
public PLPositionTransition(long startTimeMs, long durationMs, int fromX, int fromY, int toX, int toY);

public enum  PLDisplayMode {
    // 全屏模式，拉伸最短边，裁剪最长边
    FULL, 
    // 适应模式，按照最长边来等比压缩，空的地方用黑色填充
    FIT, 
    // 固定模型，固定宽高不拉伸，超出画面就裁剪，不足则以黑色填充
    KEEP
}