/**
* @overview SDK WEB应用JS文档
* @version 3.4.0
* @copyright 北京美摄网络科技有限公司
*/
/**
* @classdesc 事件发射器
*/
class NvsEventEmitter {
/**
* @constructor
*/
constructor() {
this.store = {}
}
/**
* @description 绑定
*/
on(key, fn) {
if (this.store[key]) {
this.store[key].push(fn)
} else {
this.store[key] = [fn]
}
}
/**
* @description 触发
*/
emit(key, ...args) {
if (!this.store[key]) {
return
}
while (this.store[key].length > 0) {
let fn = this.store[key][0]
fn(...args)
this.off(key, fn)
}
}
/**
* @description 解绑
*/
off(key, fn) {
if (!this.store[key]) {
return
}
const idx = this.store[key].findIndex(i => i === fn)
if (idx === -1) {
return
}
this.store[key].splice(idx, 1)
}
}
/**
* @description 视频特效常量
*/
const NvsStreamingSdkFuncVideoFx = 'videoFx';
/**
* @description 动画贴纸
*/
const NvsStreamingSdkFuncAnimatedSticker = 'animatedSticker';
/**
* @description 音乐
*/
const NvsStreamingSdkFuncMusic = 'music';
/**
* @description 字幕
*/
const NvsStreamingSdkFuncCaption = 'caption';
/**
* @description 视频特效扩展
*/
const NvsStreamingSdkFuncVideoFxExtension = 'videoFxExtension';
/**
* @description 视频转场
*/
const NvsStreamingSdkFuncVideoTransition = 'videoTransition';
/**
* @description 主题
*/
const NvsStreamingSdkFuncTheme = 'theme';
/**
* @description 粒子视频特效
*/
const NvsStreamingSdkFuncParticleVideoFx = 'particleVideoFx';
/**
* @description 模板
*/
const NvsStreamingSdkFuncTemplate = 'template';
/**
* @description 使用模板
*/
const NvsStreamingSdkFuncUseTemplate = 'useTemplate';
/**
* @description 视频转场扩展
*/
const NvsStreamingSdkFuncVideoTransitionExtension = 'videoTransitionExtension';
/**
* @description 改变速度
*/
const NvsStreamingSdkFuncChangeSpeed = 'changeSpeed';
/**
* @description 片段分割
*/
const NvsStreamingSdkFuncClipSplit = 'clipSplit';
/**
* @description 视频颜色调整
*/
const NvsStreamingSdkFuncVideoColorAdjust = 'videoColorAdjust';
/**
* @description 字幕风格设置
*/
const NvsStreamingSdkFuncCaptionStyleSetting = 'captionStyleSetting';
/**
* @description 事件发射器对象
*/
const nvsEventEmitter = new NvsEventEmitter();
/**
* @description 流媒体引擎状态停止
*/
const streamingEngineStateStopped = 'streamingEngineStateStopped';
/**
* @classdesc SDK版本号
*/
class NvsSdkVersion {
/**
* @constructor
* @param {Number} majorVersion 主版本号
* @param {Number} minorVersion 次版本号
* @param {Number} revisionNumber 序号
*/
constructor(majorVersion, minorVersion, revisionNumber) {
this.majorVersion = majorVersion;
this.minorVersion = minorVersion;
this.revisionNumber = revisionNumber;
}
}
/**
* @classdesc 比例值
*/
class NvsRational {
/**
* @constructor
* @param {Number} numerator 分子
* @param {Number} denominator 分母
*/
constructor(numerator, denominator) {
this.num = numerator;
this.den = denominator;
}
}
/**
* @classdesc 视频分辨率
*/
class NvsVideoResolution {
/**
* @constructor
* @param {Number} imageWidth 宽度
* @param {Number} imageHeight 高度
*/
constructor(imageWidth, imageHeight) {
this.imageWidth = imageWidth;
this.imageHeight = imageHeight;
}
}
/**
* @classdesc 音频分辨率
*/
class NvsAudioResolution {
/**
* @constructor
* @param {Number} sampleRate 采样率
* @param {Number} channelCount 通道数
*/
constructor(sampleRate, channelCount) {
this.sampleRate = sampleRate;
this.channelCount = channelCount;
}
}
/**
* @description 浏览窗口填充模式枚举
*/
const NvsLiveWindowFillModeEnum = Object.freeze({
"PreserveAspectCrop" : 0,
"PreserveAspectFit" : 1,
"Stretch" : 2});
/**
* @classdesc 视频预览窗口
*/
class NvsLiveWindow {
/**
* @constructor
*/
constructor() {
this.internalLiveWindow = 0;
}
/**
* @description 设置填充模式
* @param {Number} fillMode 填充模式
* @return {Void}
*/
setFillMode(fillMode) {
Module.nvs_liveWindow_setFillMode(this.internalLiveWindow, fillMode);
}
/**
* @description 获取填充模式
* @return {Number} 填充模式
*/
getFillMode() {
return Module.nvs_liveWindow_getFillMode(this.internalLiveWindow);
}
/**
* @description 时间线坐标转换成视图坐标
* @param {NvsPointF} ptCanonical 时间线坐标
* @return {NvsPointF} 视图坐标
*/
mapCanonicalToView(ptCanonical) {
return Module.nvs_liveWindow_mapCanonicalToView(this.internalLiveWindow, ptCanonical);
}
/**
* @description 视图坐标转换成时间线坐标
* @param {NvsPointF} ptView 视图坐标
* @return {NvsPointF} 时间线坐标
*/
mapViewToCanonical(ptView) {
return Module.nvs_liveWindow_mapViewToCanonical(this.internalLiveWindow, ptView);
}
/**
* @description 归一化坐标转换成视图坐标
* @param {NvsPointF} ptNormalized 归一化坐标
* @return {NvsPointF} 视图坐标
*/
mapNormalizedToView(ptNormalized) {
return Module.nvs_liveWindow_mapNormalizedToView(this.internalLiveWindow, ptNormalized);
}
/**
* @description 视图坐标转换成归一化坐标
* @param {NvsPointF} 视图坐标
* @return {NvsPointF} 归一化坐标
*/
mapViewToNormalized(ptView) {
return Module.nvs_liveWindow_mapViewToNormalized(this.internalLiveWindow, ptView);
}
/**
* @description 设置背景颜色
* @param {NvsColor} color 背景颜色
* @return {Void} 无返回值
*/
setBackgroundColor(color) {
Module.nvs_liveWindow_setBackgroundColor(this.internalLiveWindow, color);
}
}
/**
* @description 视频预览大小模式枚举
*/
const NvsVideoPreviewSizeModeEnum = Object.freeze({
"FullSize" : 0,
"LiveWindowSize" : 1});
/**
* @description 搜索标志枚举
*/
const NvsSeekFlagEnum = Object.freeze({
"ShowCaptionPoster" : 2,
"ShowAnimatedStickerPoster" : 4,
"BuddyHostVideoFrame" : 16,
"WebReaderPrefetchForSeek" : 32});
/**
* @description 播放标记枚举
*/
const NvsPlaybackFlagEnum = Object.freeze({
"LowPipelineSize" : 8,
"DisableFixedPrerollTime" : 16,
"BuddyHostVideoFrame" : 32});
/**
* @description 流媒体引擎状态枚举
*/
const NvsStreamingEngineStateEnum = Object.freeze({
"StreamingEngineStateStopped" : 0,
"StreamingEngineStatePlayback" : 3,
"StreamingEngineStateSeeking" : 4,
"StreamingEngineStateCompile" : 5});
/**
* @description 资源包类型枚举
*/
const NvsAssetPackageTypeEnum = Object.freeze({
"VideoFx" : 0,
"VideoTransition" : 1,
"CaptionStyle" : 2,
"AnimatedSticker" : 3,
"Theme" : 4,
"CaptureScene" : 5,
"ARScene" : 6,
"CompoundCaption" : 7,
"CaptionContext" : 8,
"CaptionRenderer" : 9,
"CaptionAnimation" : 10,
"CaptionInAnimation" : 11,
"CaptionOutAnimation" : 12,
"Template" : 13});
/**
* @description 资源包状态枚举
*/
const NvsAssetPackageStatusEnum = Object.freeze({
"NotInstalled" : 0,
"Installing" : 1,
"Ready" : 2,
"Upgrading" : 3});
/**
* @description 轨道类型枚举
*/
const NvsTrackTypeEnum = Object.freeze({
"Video" : 0,
"Audio" : 1});
/**
* @description 片段类型枚举
*/
const NvsClipTypeEnum = Object.freeze({
"Video" : 0,
"Audio" : 1});
/**
* @description 视频片段类型枚举
*/
const NvsVideoClipTypeEnum = Object.freeze({
"AV" : 0,
"Image" : 1});
/**
* @description 视频片段运动模式枚举
*/
const NvsVideoClipMotionModeEnum = Object.freeze({
"LetterBoxZoomIn" : 0,
"LetterBoxZoomOut" : 1,
"Image_ROI" : 2});
/**
* @description 视频片段扩展旋转枚举
*/
const NvsVideoClipExtraRotationEnum = Object.freeze({
"Rotation0" : 0,
"Rotation90" : 1,
"Rotation180" : 2,
"Rotation270" : 3});
/**
* @description 视频片段背景模式枚举
*/
const NvsVideoClipBackgroundModeEnum = Object.freeze({
"ColorSolid" : 0,
"Blur" : 1});
/**
* @description 片段角色主题枚举
*/
const NvsClipRoleInThemeEnum = Object.freeze({
"General" : 0,
"Title" : 1,
"Trailer" : 2});
/**
* @description 视频特效类型枚举
*/
const NvsVideoFxTypeEnum = Object.freeze({
"Builtin" : 0,
"Package" : 1,
"Custom" : 2});
/**
* @description 视频转场类型枚举
*/
const NvsVideoTransitionTypeEnum = Object.freeze({
"Builtin" : 0,
"Package" : 1});
/**
* @description 字幕角色主题枚举
*/
const NvsCaptionRoleInThemeEnum = Object.freeze({
"General" : 0,
"Title" : 1,
"Trailer" : 2});
/**
* @description 字幕文本排列枚举
*/
const NvsCaptionTextAlignmentEnum = Object.freeze({
"Left" : 0,
"Center" : 1,
"Right" : 2});
/**
* @description 字幕文本边界类型枚举
*/
const NvsCaptionTextBoundingTypeEnum = Object.freeze({
"Text" : 0,
"TextFrame" : 1,
"Frame" : 2});
/**
* @description 字幕字符间隔类型枚举
*/
const NvsCaptionLetterSpacingTypeEnum = Object.freeze({
"Percentage" : 0,
"Absolute" : 1});
/**
* @description 人体检测功能枚举
*/
const NvsHumanDetectionFeatureEnum = Object.freeze({
"FaceLandmark" : 1,
"FaceAction" : 2,
"AvatarExpression" : 4,
"VideoMode" : 8,
"ImageMode" : 16});
/**
* @description 关键帧查询模式枚举
*/
const NvsKeyFrameFindModeEnum = Object.freeze({
"Before" : 1,
"After" : 2});
/**
* @description 片段包装模式枚举
*/
const NvsClipWrapModeEnum = Object.freeze({
"RepeatLastFrame" : 0,
"RepeatFirstFrame" : 1,
"Repeat" : 2});
/**
* @description 时间线纵横比枚举
*/
const NvsTimelineAspectRatioEnum = Object.freeze({
"16v9": 1,
"1v1": 2,
"9v16": 4,
"4v3": 8,
"3v4": 16,
"18v9": 32,
"9v18": 64,
"21v9": 512,
"9v21": 1024});
/**
* @description 恢复音频上下文
* @return {Void}
*/
function nvsResumeAudioContext() {
// Under some browsers(such as chrome >= 70) The AudioContext was not allowed to start
// if we don't resume AudioContext after a user gesture on the page.
// For detailed information please refer to https://developers.google.com/web/updates/2017/09/autoplay-policy-changes#webaudio
if (typeof(Module['Meishe']) === 'undefined')
Module['Meishe'] = {};
var Meishe = Module['Meishe'];
if (!Meishe.audioContext) {
if (typeof(AudioContext) !== 'undefined')
Meishe.audioContext = new AudioContext();
else if (typeof(webkitAudioContext) !== 'undefined')
Meishe.audioContext = new webkitAudioContext();
else
return;
}
var audioCtx = Meishe.audioContext;
if (audioCtx.state === 'suspended')
audioCtx.resume();
}
/**
* @description 使用 Promise 恢复 AudioContext
* @return {Void}
*/
function nvsResumeAudioContextWithPromise() {
// Under some browsers(such as chrome >= 70) The AudioContext was not allowed to start
// if we don't resume AudioContext after a user gesture on the page.
// For detailed information please refer to https://developers.google.com/web/updates/2017/09/autoplay-policy-changes#webaudio
if (typeof(Module['Meishe']) === 'undefined')
return Promise.reject(new Error('Module.Meishe is undefined'));
var Meishe = Module['Meishe'];
if (!Meishe.audioContext) {
console.error('Meishe.audioContext is null!');
return Promise.reject(new Error('Meishe.audioContext is null'));
}
if (Meishe.audioContext.state === 'suspended')
return Meishe.audioContext.resume();
return Promise.resolve();
}
/**
* @description 获取流媒体上下文实例
* @return {NvsStreamingContext} 流媒体引擎对象
*/
function nvsGetStreamingContextInstance() {
return Module.Meishe.streamingContext;
}
/**
* @classdesc 浮点类型数组
*/
// std::vector<float>
class NvsVectorFloat {
/**
* @constructor
*/
constructor() {
return new Module.VectorFloat();
}
}
/**
* @classdesc 对象类型数组
*/
// std::vector<emscripten::val>
class NvsVectorVal {
/**
* @constructor
*/
constructor() {
return new Module.VectorVal();
}
}
/**
* @classdesc AI调色信息
*/
class NvsAIToningInfo {
/**
* @constructor
*/
constructor() {
this.exposure = 0;
this.contrast = 0;
this.shadow = 0;
this.highlight = 0;
this.brightness = 0;
this.blackpoint = 0;
this.saturation = 0;
this.vibrance = 0;
this.definition = 0;
this.sharpeness = 0;
}
}
/**
* @classdesc 流媒体上下文：流媒体上下文类可视作整个SDK框架的入口。开发过程中，NvsStreamingContext提供了静态sharedInstance接口创建流媒体上下文的唯一实例。 通过这个实例对象，我们可以开启采集设备录制视频，添加采集视频特效，设置拍摄时的各项参数，包括自动聚焦，自动曝光调节， 开关换补光灯等。同时还能够创建时间线，并将时间线与实时预览窗口连接起来，实时预览播放已经拍摄完成的视频。整个视频制作完成后，要销毁流媒体上下文的对象实例。 带特效拍摄时，添加素材资源包(采集特效包，场景资源包等)，都得先安装，安装成功后获取packageId才能使用，而内建采集特效(builtin)只需获取特效名称即可使用。sdk接口中凡是需要传入资源、授权等文件路径时一定是全路径。
*/
class NvsStreamingContext {
/**
* @constructor
*/
constructor() {
this.onWebRequestWaitStatusChange = function(isVideo, waiting) {
}
this.onWebRequestAuthFinish = function(success, uuid) {
}
this.onPlaybackTimelinePosition = function(timeline, position) {
}
this.onPlaybackStopped = function(timeline) {
}
this.onPlaybackEOF = function(timeline) {
}
this._onStreamingEngineStateChanged = function(state) {
}
this.onAudioVUMeter = function(timeline, leftVUValue, rightVUValue, timeStamp) {
}
this.onImageGrabbedArrived = function(imageData, time) {
}
}
get onStreamingEngineStateChanged() {
return (state) => {
if (state === 0) {
nvsEventEmitter.emit(streamingEngineStateStopped);
}
this._onStreamingEngineStateChanged(state)
}
}
set onStreamingEngineStateChanged(fun) {
this._onStreamingEngineStateChanged = fun
}
/**
* @description 流引擎准备好时间线修改
* @return {Promise} Promise
*/
streamingEngineReadyForTimelineModification() {
let self = this;
return new Promise((resolve, reject) => {
if (Module.Meishe.streamingContext.getStreamingEngineState() === 0)
resolve();
else {
nvsEventEmitter.on(streamingEngineStateStopped, function slot() {
resolve();
});
self.stop();
}
});
}
/**
* @description 验证SDK许可文件
* @param {} requestUrl 请求url
* @param {} type 类型
* @return {}
*/
verifySdkLicenseFile(requestUrl, type = '') {
return Module.nvs_streamingContext_verifySdkLicenseFile(requestUrl, type);
}
/**
* @description 使用扩展用户数据验证SDK许可文件
* @param {String} requestUrl 请求的url
* @param {} extraUserData 扩展用户数据
* @return {}
*/
verifySdkLicenseFileWithExtraUserData(requestUrl, extraUserData) {
Module.Meishe.ExtraUserData = extraUserData;
return Module.nvs_streamingContext_verifySdkLicenseFileWithExtraUserData(requestUrl);
}
/**
* @description 获取SDK版本号
* @return {NvsSdkVersion} SDK版本号
*/
getSdkVersion() {
return Module.nvs_streamingContext_getSdkVersion();
}
/**
* @description 创建时间线
* @param {} videoRes 视频解析度
* @param {} fps 视频帧率
* @param {} audioRes 音频解析度
* @param {Number} flags 标识
* @return {NvsTimeline} 时间线对象
*/
createTimeline(videoRes, fps, audioRes, flags = 0) {
return Module.nvs_streamingContext_createTimeline(videoRes, fps, audioRes, flags);
}
/**
* @description 根据模板ID，创建模板时间线
* @param {} templateId 模板ID
* @param {} templateFootages 模板素材
* @param {} flags 标识
* @return {NvsTimeline} 时间线对象
*/
createTemplateTimeline(templateId, templateFootages, flags = 0) {
return Module.nvs_streamingContext_createTemplateTimeline(templateId, templateFootages, flags);
}
/**
* @description 创建空模板时间线
* @param {} videoRes 视频解析度
* @param {} fps 视频帧率
* @param {} audioRes 音频解析度
* @param {} templateId 模板ID
* @param {} flags 标识
* @return {NvsTimeline} 时间线对象
*/
createEmptyTemplateTimeline(videoRes, fps, audioRes, templateId, flags = 0) {
return Module.nvs_streamingContext_createEmptyTemplateTimeline(videoRes, fps, audioRes, templateId, flags);
}
/**
* @description 删除时间线
* @param {} timeline 时间线
* @return {Num}
*/
removeTimeline(timeline) {
return Module.nvs_streamingContext_removeTimeline(timeline);
}
/**
* @description 根据画板ID，创建流媒体浏览窗口
* @param {} canvasId 画板ID
* @return {Num}
*/
createLiveWindow(canvasId) {
return Module.nvs_streamingContext_createLiveWindow(canvasId);
}
/**
* @description 删除流媒体浏览窗口
* @param {} liveWindow 流媒体预览窗口
* @return {Num}
*/
removeLiveWindow(liveWindow) {
Module.nvs_streamingContext_removeLiveWindow(liveWindow);
}
/**
* @description 连接时间线到流媒体窗口
* @param {} timeline 时间线
* @param {} liveWindow 预览窗口
* @return {Num}
*/
connectTimelineWithLiveWindow(timeline, liveWindow) {
return Module.nvs_streamingContext_connectTimelineWithLiveWindow(timeline, liveWindow);
}
/**
* @description 查找时间线
* @param {} timeline 时间线
* @param {} timestamp 时间戳
* @param {} videoSizeMode 视频大小模式
* @param {} flags 标记
* @return {Num}
*/
seekTimeline(timeline, timestamp, videoSizeMode, flags) {
return Module.nvs_streamingContext_seekTimeline(timeline, timestamp, videoSizeMode, flags);
}
/**
* @description 播放时间线
* @param {} timeline 时间线
* @param {} startTime 开始时间
* @param {} endTime 结束时间
* @param {} videoSizeMode 视频大小模式
* @param {} preload 预载
* @param {} flags 标识
* @return {Num}
*/
playbackTimeline(timeline, startTime, endTime, videoSizeMode, preload, flags) {
return Module.nvs_streamingContext_playbackTimeline(timeline, startTime, endTime, videoSizeMode, preload, flags);
}
/**
* @description 使用代理缩放播放时间线
* @param {} timeline 时间线
* @param {} startTime 开始时间
* @param {} endTime 结束时间
* @param {} proxyScale 缩放代理
* @param {} preload 预载
* @param {} flags 标识
* @return {Num}
*/
playbackTimelineWithProxyScale(timeline, startTime, endTime, proxyScale, preload, flags) {
return Module.nvs_streamingContext_playbackTimelineWithProxyScale(timeline, startTime, endTime, proxyScale, preload, flags);
}
/**
* @description 流媒体上下文停止
* @return {Num}
*/
stop() {
Module.nvs_streamingContext_stop();
}
/**
* @description 获取当前时间线位置
* @param {} timeline 时间线
* @return {Num}
*/
getTimelineCurrentPosition(timeline) {
return Module.nvs_streamingContext_getTimelineCurrentPosition(timeline);
}
/**
* @description 获取流媒体引擎状态
* @return {Num}
*/
getStreamingEngineState() {
return Module.nvs_streamingContext_getStreamingEngineState();
}
/**
* @description 获取资源包管理器
* @return {Num}
*/
getAssetPackageManager() {
return Module.nvs_streamingContext_getAssetPackageManager();
}
/**
* @description 获取音视频文件信息
* @param {} avFilePath 音视频文件路径
* @param {} extraFlag 扩展标记
* @return {Num}
*/
getAVFileInfo(avFilePath, extraFlag) {
return Module.nvs_streamingContext_getAVFileInfo(avFilePath, extraFlag);
}
/**
* @description 根据文件路径注册字体
* @param {} fontFilePath
* @return {Num}
*/
registerFontByFilePath(fontFilePath) {
return Module.nvs_streamingContext_registerFontByFilePath(fontFilePath);
}
/**
* @description 从时间轴抓取图像
* @param {} timeline 时间线
* @param {} timestamp 时间戳
* @param {} proxyScale 缩放代理
* @param {} flags
* @return {Num}
*/
grabImageFromTimeline(timeline, timestamp, proxyScale, flags) {
return Module.nvs_streamingContext_grabImageFromTimeline(timeline, timestamp, proxyScale, flags);
}
/**
* @description 设置音频输出设备音量
* @param {} volume 音量
* @return {Num}
*/
setAudioOutputDeviceVolume(volume) {
Module.nvs_streamingContext_setAudioOutputDeviceVolume(volume);
}
/**
* @description 设置最大视频文件阅读器计数
* @param {} count 计数
* @return {Num}
*/
setMaxVideoFileReaderCount(count) {
Module.nvs_streamingContext_setMaxVideoFileReaderCount(count);
}
/**
* @description 设置最大视频解码线程数
* @param {} count 计数
* @return {Num}
*/
setMaxVideoDecodingThreadCount(count) {
Module.nvs_streamingContext_setMaxVideoDecodingThreadCount(count);
}
/**
* @description 功能授权
* @param {} sdkFunctionName 函数名
* @return {Num}
*/
functionalityAuthorised(sdkFunctionName) {
return Module.nvs_streamingContext_functionalityAuthorised(sdkFunctionName);
}
/**
* @description 设置只使用中文
* @param {} useChineseLanguageOnly 只使用中文
* @return {Num}
*/
setUseChineseLanguageOnly(useChineseLanguageOnly) {
Module.nvs_streamingContext_setUseChineseLanguageOnly(useChineseLanguageOnly);
}
/**
* @description 是否仅仅使用中文
* @return {Num}
*/
isUseChineseLanguageOnly() {
return Module.nvs_streamingContext_isUseChineseLanguageOnly();
}
/**
* @description 初始化人体检测
* @param {} modelFilePath 模型文件路径
* @param {} licenseFilePath 许可证文件路径
* @param {} features 特征
* @return {Num}
*/
initHumanDetection(modelFilePath, licenseFilePath, features) {
return Module.nvs_streamingContext_initHumanDetection(modelFilePath, licenseFilePath, features);
}
/**
* @description 关闭人体检测
* @return {Num}
*/
closeHumanDetection() {
Module.nvs_streamingContext_closeHumanDetection();
}
/**
* @description 预加载效果资源
* @return {Num}
*/
preloadEffectResources() {
return Module.nvs_streamingContext_preloadEffectResources();
}
/**
* @description 通知更新到网络阅读器
* @param {} webAVFilePath 网页音视频文件路径
* @return {Num}
*/
notifyUpdateToWebReader(webAVFilePath) {
return Module.nvs_streamingContext_notifyUpdateToWebReader(webAVFilePath);
}
/**
* @description 启用音频 VU 表
* @param {} enable 是否开启
* @return {Num}
*/
enableAudioVUMeter(enable) {
Module.nvs_streamingContext_enableAudioVUMeter(enable);
}
/**
* @description 获取自动音调参数
* @param {} imageData 图片数据
* @param {} width 宽度
* @param {} height 高度
* @param {} isRawImage 是否原始图片
* @return {Num}
*/
getAutoToneParameters(imageData, width, height, isRawImage) {
return Module.nvs_AIAdjustColorDetect_getAutoToneParameters(imageData, width, height, isRawImage);
}
}
/**
* @description 使用模板
*/
const TEMPLATE_KEY_REPLACE_ID = 'MSTemplate-ReplaceId'
/**
* @description 使用模板
*/
const TEMPLATE_KEY_FOOTAGE_ID = 'MSTemplate-FootageId'
/**
* @description 使用模板
*/
const TEMPLATE_KEY_FOOTAGE_TAGS = 'MSTemplate-FootageTags'
/**
* @classdesc 工程对象
*/
class NvsProjObj {
/**
* @constructor
*/
constructor() {
this.internalObj = 0;
}
/**
* @description 设置内置对象
* @param {} obj
* @return {Num}
*/
setInternalObject(obj) {
this.internalObj = obj;
}
/**
* @description 获取内置对象
* @return {Num}
*/
getInternalObject() {
return this.internalObj;
}
/**
* @description 设置模板附件
* @param {} key 键
* @param {} value 值
* @return {Num}
*/
setTemplateAttachment(key, value) {
Module.nvs_object_setTemplateAttachment(this.internalObj, key, value);
}
/**
* @description 根据键，获取模板属性值
* @param {} key 键
* @return {Num}
*/
getTemplateAttachment(key) {
return Module.nvs_object_getTemplateAttachment(this.internalObj, key);
}
}
/**
* @classdesc 时间线类：编辑场景的时间轴实体，时间线由轨道组成，可视作一系列音视频轨道的集合。在时间线上可添加或者移除多条视频轨道和音轨轨道，多条轨道之间是相互叠加合成的关系。 当编辑视频时，根据需要还会添加上时间线字幕，主题以及相应的动画贴纸，以制作出美观的视频。另外，添加素材资源包(主题包，动画贴纸包，字幕样式包，时间线特效包等)， 都得先安装，安装成功后获取packageId才能使用，而内建时间线特效(builtin)只需获取特效名称即可使用。
* @extends NvsProjObj
*/
class NvsTimeline extends NvsProjObj {
/**
* @constructor
*/
constructor() {
super();
}
/**
* @description 获取视频资源
* @return {Num}
*/
getVideoRes() {
return Module.nvs_timeline_getVideoRes(this.internalObj);
}
/**
* @description 获取音频资源
* @return {Num}
*/
getAudioRes() {
return Module.nvs_timeline_getAudioRes(this.internalObj);
}
/**
* @description 获取时间线时长
* @return {Num}
*/
getDuration() {
return Module.nvs_timeline_getDuration(this.internalObj);
}
/**
* @description 附加视频轨道
* @return {Num}
*/
appendVideoTrack() {
return Module.nvs_timeline_appendVideoTrack(this.internalObj);
}
/**
* @description 添加音频轨道
* @return {Num}
*/
appendAudioTrack() {
return Module.nvs_timeline_appendAudioTrack(this.internalObj);
}
/**
* @description 插入视频轨道
* @param {} insertPoint 插入点
* @return {Num}
*/
insertVideoTrack(insertPoint) {
return Module.nvs_timeline_insertVideoTrack(this.internalObj, insertPoint);
}
/**
* @description 插入音频轨道
* @param {} insertPoint 插入点
* @return {Num}
*/
insertAudioTrack(insertPoint) {
return Module.nvs_timeline_insertAudioTrack(this.internalObj, insertPoint);
}
/**
* @description 删除视频轨道
* @param {} trackIndex 轨道索引
* @return {Num}
*/
removeVideoTrack(trackIndex) {
return Module.nvs_timeline_removeVideoTrack(this.internalObj, trackIndex);
}
/**
* @description 删除音频轨道
* @param {} trackIndex 轨道索引
* @return {Num}
*/
removeAudioTrack(trackIndex) {
return Module.nvs_timeline_removeAudioTrack(this.internalObj, trackIndex);
}
/**
* @description 获取视频轨道计数
* @return {Num}
*/
videoTrackCount() {
return Module.nvs_timeline_videoTrackCount(this.internalObj);
}
/**
* @description 获取音频轨道计数
* @return {Num}
*/
audioTrackCount() {
return Module.nvs_timeline_audioTrackCount(this.internalObj);
}
/**
* @description 根据索引，获取视频轨道
* @param {} trackIndex 轨道索引
* @return {Num}
*/
getVideoTrackByIndex(trackIndex) {
return Module.nvs_timeline_getVideoTrackByIndex(this.internalObj, trackIndex);
}
/**
* @description 根据索引，获取音频轨道
* @param {} trackIndex 轨道索引
* @return {Num}
*/
getAudioTrackByIndex(trackIndex) {
return Module.nvs_timeline_getAudioTrackByIndex(this.internalObj, trackIndex);
}
/**
* @description 改变视频大小
* @param {} videoWidth 视频宽度
* @param {} videoHeight 视频高度
* @return {Num}
*/
changeVideoSize(videoWidth, videoHeight) {
return Module.nvs_timeline_changeVideoSize(this.internalObj, videoWidth, videoHeight);
}
/**
* @description 改变视频大小
* @param {} videoWidth 视频宽度
* @param {} videoHeight 视频高度
* @return {Num}
*/
changeVideoSize2(videoWidth, videoHeight) {
return Module.nvs_timeline_changeVideoSize2(this.internalObj, videoWidth, videoHeight);
}
/**
* @description 获取第一个字幕
* @return {Num}
*/
getFirstCaption() {
return Module.nvs_timeline_getFirstCaption(this.internalObj);
}
/**
* @description 获取最后一个字幕
* @return {Num}
*/
getLastCaption() {
return Module.nvs_timeline_getLastCaption(this.internalObj);
}
/**
* @description 获取上一个字幕
* @param {} caption 字幕
* @return {Num}
*/
getPrevCaption(caption) {
return Module.nvs_timeline_getPrevCaption(this.internalObj, caption);
}
/**
* @description 获取下一个字幕
* @param {} caption 字幕
* @return {Num}
*/
getNextCaption(caption) {
return Module.nvs_timeline_getNextCaption(this.internalObj, caption);
}
/**
* @description 根据时间线位置获取字幕
* @param {} timelinePos 时间线位置
* @return {Num}
*/
getCaptionsByTimelinePosition(timelinePos) {
return Module.nvs_timeline_getCaptionsByTimelinePosition(this.internalObj, timelinePos);
}
/**
* @description 添加字幕
* @param {} captionText 字幕文本
* @param {} inPoint 入点
* @param {} duration 持续时间
* @param {} captionStylePackageId 字幕风格包ID
* @param {} isPanoramic 是否是全景
* @return {Num}
*/
addCaption(captionText, inPoint, duration, captionStylePackageId, isPanoramic) {
return Module.nvs_timeline_addCaption(this.internalObj, captionText, inPoint, duration, captionStylePackageId, isPanoramic);
}
/**
* @description 添加模块化字幕
* @param {} captionText 字幕文本
* @param {} inPoint 入点
* @param {} duration 持续时间
* @return {Num}
*/
addModularCaption(captionText, inPoint, duration) {
return Module.nvs_timeline_addModularCaption(this.internalObj, captionText, inPoint, duration);
}
/**
* @description 删除字幕
* @param {} caption 字幕对象
* @return {Num}
*/
removeCaption(caption) {
return Module.nvs_timeline_removeCaption(this.internalObj, caption);
}
/**
* @description 获取第一个复合字幕
* @return {Num}
*/
getFirstCompoundCaption() {
return Module.nvs_timeline_getFirstCompoundCaption(this.internalObj);
}
/**
* @description 获取最后一个复合字幕
* @return {Num}
*/
getLastCompoundCaption() {
return Module.nvs_timeline_getLastCompoundCaption(this.internalObj);
}
/**
* @description 获取上一个复合字幕
* @param {} caption 字幕对象
* @return {Num}
*/
getPrevCompoundCaption(caption) {
return Module.nvs_timeline_getPrevCompoundCaption(this.internalObj, caption);
}
/**
* @description 获取下一个复合字幕
* @param {} caption 字幕对象
* @return {Num}
*/
getNextCompoundCaption(caption) {
return Module.nvs_timeline_getNextCompoundCaption(this.internalObj, caption);
}
/**
* @description 根据时间线位置，获取复合字幕
* @param {} timelinePos 时间线位置
* @return {Num}
*/
getCompoundCaptionsByTimelinePosition(timelinePos) {
return Module.nvs_timeline_getCompoundCaptionsByTimelinePosition(this.internalObj, timelinePos);
}
/**
* @description 添加复合字幕
* @param {} inPoint 入点
* @param {} duration 持续时间
* @param {} compoundCaptionPackageId 组合字幕包ID
* @return {Num}
*/
addCompoundCaption(inPoint, duration, compoundCaptionPackageId) {
return Module.nvs_timeline_addCompoundCaption(this.internalObj, inPoint, duration, compoundCaptionPackageId);
}
/**
* @description 删除复合字幕
* @param {} caption 字幕对象
* @return {Num}
*/
removeCompoundCaption(caption) {
return Module.nvs_timeline_removeCompoundCaption(this.internalObj, caption);
}
/**
* @description 获取第一个动画贴纸
* @return {Num}
*/
getFirstAnimatedSticker() {
return Module.nvs_timeline_getFirstAnimatedSticker(this.internalObj);
}
/**
* @description 获取最后一个动画贴纸
* @return {Num}
*/
getLastAnimatedSticker() {
return Module.nvs_timeline_getLastAnimatedSticker(this.internalObj);
}
/**
* @description 获取上一个动画贴纸
* @param {} animatedSticker 动画贴纸
* @return {Num}
*/
getPrevAnimatedSticker(animatedSticker) {
return Module.nvs_timeline_getPrevAnimatedSticker(this.internalObj, animatedSticker);
}
/**
* @description 获取下一个动画贴纸
* @param {} animatedSticker 动画贴纸对象
* @return {Num}
*/
getNextAnimatedSticker(animatedSticker) {
return Module.nvs_timeline_getNextAnimatedSticker(this.internalObj, animatedSticker);
}
/**
* @description 根据时间线位置获取动画贴纸
* @param {} timelinePos 时间线位置
* @return {Num}
*/
getAnimatedStickersByTimelinePosition(timelinePos) {
return Module.nvs_timeline_getAnimatedStickersByTimelinePosition(this.internalObj, timelinePos);
}
/**
* @description 添加动画贴纸
* @param {} inPoint 入点
* @param {} duration 持续时间
* @param {} animatedStickerPackageId 动画贴纸包ID
* @param {} isPanoramic 是否是全景
* @param {} isCustom 是否自定制
* @param {} customImagePath 自定制图片路径
* @return {Num}
*/
addAnimatedSticker(inPoint, duration, animatedStickerPackageId, isPanoramic, isCustom, customImagePath) {
return Module.nvs_timeline_addAnimatedSticker(this.internalObj, inPoint, duration, animatedStickerPackageId, isPanoramic, isCustom, customImagePath);
}
/**
* @description 删除动画贴纸
* @param {} animatedSticker 动画贴纸
* @return {Num}
*/
removeAnimatedSticker(animatedSticker) {
return Module.nvs_timeline_removeAnimatedSticker(this.internalObj, animatedSticker);
}
/**
* @description 获取第一个时间线视频特效
* @return {Num}
*/
getFirstTimelineVideoFx() {
return Module.nvs_timeline_getFirstTimelineVideoFx(this.internalObj);
}
/**
* @description 获取最后时间线视频特效
* @return {Num}
*/
getLastTimelineVideoFx() {
return Module.nvs_timeline_getLastTimelineVideoFx(this.internalObj);
}
/**
* @description 获取前一个时间线视频特效
* @param {} timelineVideoFx 时间线视频特效
* @return {Num}
*/
getPrevTimelineVideoFx(timelineVideoFx) {
return Module.nvs_timeline_getPrevTimelineVideoFx(this.internalObj, timelineVideoFx);
}
/**
* @description 获取下一个时间线视频特效
* @param {} timelineVideoFx 时间线视频特效
* @return {Num}
*/
getNextTimelineVideoFx(timelineVideoFx) {
return Module.nvs_timeline_getNextTimelineVideoFx(this.internalObj, timelineVideoFx);
}
/**
* @description 根据时间线位置获取时间线视频特效
* @param {} timelinePos 时间线位置
* @return {Num}
*/
getTimelineVideoFxByTimelinePosition(timelinePos) {
return Module.nvs_timeline_getTimelineVideoFxByTimelinePosition(this.internalObj, timelinePos);
}
/**
* @description 添加内置时间线视频特效
* @param {} inPoint 入点
* @param {} duration 持续时间
* @param {} videoFxName 视频特效名字
* @return {Num}
*/
addBuiltinTimelineVideoFx(inPoint, duration, videoFxName) {
return Module.nvs_timeline_addBuiltinTimelineVideoFx(this.internalObj, inPoint, duration, videoFxName);
}
/**
* @description 添加包时间线视频特效
* @param {} inPoint 入点
* @param {} duration 持续时间
* @param {} videoFxPackageId 视频特效包ID
* @return {Num}
*/
addPackagedTimelineVideoFx(inPoint, duration, videoFxPackageId) {
return Module.nvs_timeline_addPackagedTimelineVideoFx(this.internalObj, inPoint, duration, videoFxPackageId);
}
/**
* @description 删除时间线视频特效
* @param {} timelineVideoFx 时间线视频特效
* @return {Num}
*/
removeTimelineVideoFx(timelineVideoFx) {
return Module.nvs_timeline_removeTimelineVideoFx(this.internalObj, timelineVideoFx);
}
/**
* @description 获取当前主题ID
* @return {Num}
*/
getCurrentThemeId() {
return Module.nvs_timeline_getCurrentThemeId(this.internalObj);
}
/**
* @description 应用主题
* @param {} themeId 主题ID
* @return {Num}
*/
applyTheme(themeId) {
return Module.nvs_timeline_applyTheme(this.internalObj, themeId);
}
/**
* @description 删除当前主题
* @return {Num}
*/
removeCurrentTheme() {
Module.nvs_timeline_removeCurrentTheme(this.internalObj);
}
/**
* @description 设置主题标题字幕文本
* @param {} text 文本
* @return {Num}
*/
setThemeTitleCaptionText(text) {
Module.nvs_timeline_setThemeTitleCaptionText(this.internalObj, text);
}
/**
* @description 设置主题预报字幕文本
* @param {} text 文本
* @return {Num}
*/
setThemeTrailerCaptionText(text) {
Module.nvs_timeline_setThemeTrailerCaptionText(this.internalObj, text);
}
/**
* @description 设置主题音乐音量增益
* @param {} leftVolumeGain 左音量增益
* @param {} rightVolumeGain 右音量增益
* @return {Num}
*/
setThemeMusicVolumeGain(leftVolumeGain, rightVolumeGain) {
Module.nvs_timeline_setThemeMusicVolumeGain(this.internalObj, leftVolumeGain, rightVolumeGain);
}
/**
* @description 获取主题音乐音量增益
* @return {Num}
*/
getThemeMusicVolumeGain() {
return Module.nvs_timeline_getThemeMusicVolumeGain(this.internalObj);
}
/**
* @description 设置播放速率控制
* @param {} playbackRateControlRegions 播放速率控制区域
* @return {Num}
*/
setPlaybackRateControl(playbackRateControlRegions) {
Module.nvs_timeline_setPlaybackRateControl(this.internalObj, playbackRateControlRegions);
}
/**
* @description 添加水印
* @param {} filePath 文件路径
* @param {} displayWidth 显示宽度
* @param {} displayHeight 显示高度
* @param {} opacity 不透明度
* @param {} position 位置
* @param {} marginX X边界
* @param {} marginY Y边界
* @return {Num}
*/
addWatermark(filePath, displayWidth, displayHeight, opacity, position, marginX, marginY) {
Module.nvs_timeline_addWatermark(this.internalObj, filePath, displayWidth, displayHeight, opacity, position, marginX, marginY);
}
/**
* @description 添加水印
* @param {} sceneWidth
* @param {} sceneHeight
* @param {} imageName
* @param {} imgWidth
* @param {} imgHeight
* @param {} tx
* @param {} ty
* @param {} dirPath
* @param {} opacity
* @return {Num}
*/
addWatermark2(sceneWidth, sceneHeight, imageName, imgWidth, imgHeight, tx, ty, dirPath, opacity) {
Module.nvs_timeline_addWatermark2(this.internalObj, sceneWidth, sceneHeight, imageName, imgWidth, imgHeight, tx, ty, dirPath, opacity);
}
/**
* @description 删除水印
* @return {Num}
*/
deleteWatermark() {
Module.nvs_timeline_deleteWatermark(this.internalObj);
}
/**
* @description 设置水印透明度
* @param {} opacity 不透明度
* @return {Num}
*/
setWatermarkOpacity(opacity) {
Module.nvs_timeline_setWatermarkOpacity(this.internalObj, opacity);
}
/**
* @description 获取水印信息
* @return {Num}
*/
getWatermarkInfo() {
return Module.nvs_timeline_getWatermarkInfo(this.internalObj);
}
/**
* @description 设置视频轨道支持的最大音频流
* @param {} maxStream 最大流数量
* @return {Num}
*/
setMaxAudioStreamSupportedOnVideoTrack(maxStream) {
Module.nvs_timeline_setMaxAudioStreamSupportedOnVideoTrack(this.internalObj, maxStream);
}
/**
* @description 获得视频轨道支持的最大音频流
* @return {Num}
*/
getMaxAudioStreamSupportedOnVideoTrack() {
return Module.nvs_timeline_getMaxAudioStreamSupportedOnVideoTrack(this.internalObj);
}
}
/**
* @classdesc 轨道类：轨道，容纳片段的结构。轨道可视作片段的集合,分为音频轨道(Audio Track)和视频轨道(Video Track)。创建时间线实例后，可添加或移除多条轨道。在每一条轨道上，可以添加多个要编辑的视音频片段，并对片段进行音量设置，也可以进行移除和位置移动。
* @extends NvsProjObj
*/
class NvsTrack extends NvsProjObj {
/**
* @constructor
*/
constructor() {
super();
}
/**
* @description 获取类型
* @return {Num}
*/
getType() {
return Module.nvs_track_getType(this.internalObj);
}
/**
* @description 获取轨道索引
* @return {Num}
*/
getIndex() {
return Module.nvs_track_getIndex(this.internalObj);
}
/**
* @description 获取时长
* @return {Num}
*/
getDuration() {
return Module.nvs_track_getDuration(this.internalObj);
}
/**
* @description 获取片段数量
* @return {Num}
*/
getClipCount() {
return Module.nvs_track_getClipCount(this.internalObj);
}
/**
* @description 改变入点
* @param {} clipIndex 片段索引
* @param {} newInPoint 新的入点
* @return {Num}
*/
changeInPoint(clipIndex, newInPoint) {
return Module.nvs_track_changeInPoint(this.internalObj, clipIndex, newInPoint);
}
/**
* @description 改变出点
* @param {} clipIndex 片段索引
* @param {} newOutPoint 新的出点
* @return {Num}
*/
changeOutPoint(clipIndex, newOutPoint) {
return Module.nvs_track_changeOutPoint(this.internalObj, clipIndex, newOutPoint);
}
/**
* @description 分割片段
* @param {} clipIndex 片段索引
* @param {} splitPoint 分割点
* @return {Num}
*/
splitClip(clipIndex, splitPoint) {
return Module.nvs_track_splitClip(this.internalObj, clipIndex, splitPoint);
}
/**
* @description 删除片段
* @param {} clipIndex 片段索引
* @param {} keepSpace 保留空间
* @return {Num}
*/
removeClip(clipIndex, keepSpace) {
return Module.nvs_track_removeClip(this.internalObj, clipIndex, keepSpace);
}
/**
* @description 删除区间
* @param {} startTimelinePos 开始点在时间线上的位置
* @param {} endTimelinePos 结束点在时间线上的位置
* @param {} keepSpace 保留空间
* @return {Num}
*/
removeRange(startTimelinePos, endTimelinePos, keepSpace) {
return Module.nvs_track_removeRange(this.internalObj, startTimelinePos, endTimelinePos, keepSpace);
}
/**
* @description 移动片段
* @param {} sourceClipIndex 源片段索引
* @param {} targetClipIndex 目标片段索引
* @return {Num}
*/
moveClip(sourceClipIndex, targetClipIndex) {
return Module.nvs_track_moveClip(this.internalObj, sourceClipIndex, targetClipIndex);
}
/**
* @description 根据位置，移动片段
* @param {} sourceClipIndex 源片段索引
* @param {} targetTimelinePos 目标时间线位置
* @param {} isInsertTarget 是否是插入目标
* @param {} keepSpace 保留空间
* @return {Num}
*/
moveClipByPosition(sourceClipIndex, targetTimelinePos, isInsertTarget, keepSpace) {
return Module.nvs_track_moveClipByPosition(this.internalObj, sourceClipIndex, targetTimelinePos, isInsertTarget, keepSpace);
}
/**
* @description 删除所有片段
* @return {Num}
*/
removeAllClips() {
return Module.nvs_track_removeAllClips(this.internalObj);
}
/**
* @description 设置音量增益
* @param {} leftVolumeGain 左声道增益
* @param {} rightVolumeGain 右声道增益
* @return {Num}
*/
setVolumeGain(leftVolumeGain, rightVolumeGain) {
return Module.nvs_track_setVolumeGain(this.internalObj, leftVolumeGain, rightVolumeGain);
}
/**
* @description 获取音量增益
* @return {Num}
*/
getVolumeGain() {
return Module.nvs_track_getVolumeGain(this.internalObj);
}
}
/**
* @classdesc 视频轨道类：视频片段的集合。视频轨道是容纳视频片段的实体，可以添加、插入、删移多个视频片段。视频轨道随着片段的增加不断延展，而片段与片段之间可进行视频转场设置。 添加包裹转场时，都得先安装，安装成功后获取packageId才能使用，而内建转场(builtin)只需获取转场名称即可使用。 注：视频片段的索引都是从0开始。
* @extends NvsTrack
*/
class NvsVideoTrack extends NvsTrack {
/**
* @constructor
*/
constructor() {
super();
}
/**
* @description 插入片段
* @param {} videoFilePath 视频文件路径
* @param {} insertPoint 插入点
* @return {Num}
*/
insertClip(videoFilePath, insertPoint) {
return Module.nvs_videoTrack_insertClip(this.internalObj, videoFilePath, insertPoint);
}
/**
* @description 插入片段
* @param {} videoFilePath 视频文件路径
* @param {} trimIn 修剪入点
* @param {} trimOut 修剪出点
* @param {} insertPoint 插入点
* @return {Num}
*/
insertClip2(videoFilePath, trimIn, trimOut, insertPoint) {
return Module.nvs_videoTrack_insertClip2(this.internalObj, videoFilePath, trimIn, trimOut, insertPoint);
}
/**
* @description 追加片段
* @param {} videoFilePath 视频文件路径
* @return {Num}
*/
appendClip(videoFilePath) {
return this.insertClip(videoFilePath, this.getClipCount());
}
/**
* @description 追加片段
* @param {} videoFilePath 视频文件路径
* @param {} trimIn 修剪入点
* @param {} trimOut 修剪出点
* @return {Num}
*/
appendClip2(videoFilePath, trimIn, trimOut) {
return this.insertClip2(videoFilePath, trimIn, trimOut, this.getClipCount());
}
/**
* @description 添加片段
* @param {} videoFilePath 视频文件路径
* @param {} inPoint 入点
* @return {Num}
*/
addClip(videoFilePath, inPoint) {
return Module.nvs_videoTrack_addClip(this.internalObj, videoFilePath, inPoint);
}
/**
* @description 添加片段
* @param {} videoFilePath 视频文件路径
* @param {} inPoint 入点
* @param {} trimIn 修剪入点
* @param {} trimOut 修剪出点
* @return {Num}
*/
addClip2(videoFilePath, inPoint, trimIn, trimOut) {
return Module.nvs_videoTrack_addClip2(this.internalObj, videoFilePath, inPoint, trimIn, trimOut);
}
/**
* @description 添加速度片段
* @param {} videoFilePath 视频文件路径
* @param {} inPoint 修剪入点
* @param {} speed 速度
* @param {} keepAudioPitch 保持音频音调
* @return {Num}
*/
addClipWithSpeed(videoFilePath, inPoint, speed, keepAudioPitch) {
return Module.nvs_videoTrack_addClipWithSpeed(this.internalObj, videoFilePath, inPoint, speed, keepAudioPitch);
}
/**
* @description 添加速度片段
* @param {} videoFilePath 视频文件路径
* @param {} inPoint 入点
* @param {} trimIn 修剪入点
* @param {} trimOut 修剪出点
* @param {} speed 速度
* @param {} keepAudioPitch 保持音频音调
* @return {Num}
*/
addClipWithSpeed2(videoFilePath, inPoint, trimIn, trimOut, speed, keepAudioPitch) {
return Module.nvs_videoTrack_addClipWithSpeed2(this.internalObj, videoFilePath, inPoint, trimIn, trimOut, speed, keepAudioPitch);
}
/**
* @description 根据索引获取片段
* @param {} index 索引
* @return {Num}
*/
getClipByIndex(index) {
return Module.nvs_videoTrack_getClipByIndex(this.internalObj, index);
}
/**
* @description 根据时间线位置获取片段
* @param {} timelinePos 时间线位置
* @return {Num}
*/
getClipByTimelinePosition(timelinePos) {
return Module.nvs_videoTrack_getClipByTimelinePosition(this.internalObj, timelinePos);
}
/**
* @description 设置内置转场
* @param {} srcClipIndex 源片段索引
* @param {} transitionName 转场名字
* @return {Num}
*/
setBuiltinTransition(srcClipIndex, transitionName) {
return Module.nvs_videoTrack_setBuiltinTransition(this.internalObj, srcClipIndex, transitionName);
}
/**
* @description 设置包转场
* @param {} srcClipIndex 源片段索引
* @param {} packageId 包ID
* @return {Num}
*/
setPackagedTransition(srcClipIndex, packageId) {
return Module.nvs_videoTrack_setPackagedTransition(this.internalObj, srcClipIndex, packageId);
}
/**
* @description 根据源片段索引获取转场
* @param {} srcClipIndex 源片段索引
* @return {Num}
*/
getTransitionBySourceClipIndex(srcClipIndex) {
return Module.nvs_videoTrack_getTransitionBySourceClipIndex(this.internalObj, srcClipIndex);
}
/**
* @description 设置在主题中可用
* @param {} available 可用性
* @return {Num}
*/
setAvailableInTheme(available) {
return Module.nvs_videoTrack_setAvailableInTheme(this.internalObj, available);
}
/**
* @description 是否在主题中可用
* @return {Num}
*/
isAvailableInTheme() {
return Module.nvs_videoTrack_isAvailableInTheme(this.internalObj);
}
}
/**
* @classdesc 音频轨道，音频片段的集合。音频轨道是容纳音频片段的实体。每条音频轨道可以添加或者移除多个音频片段。一个音频片段播放到另一个音频片段时，需要进行音频转场设置，以便过渡衔接。注：对于音频轨道的一系列接口及所其属参数含义,请参照视频轨道NvsVideoTrack的对应接口来对照理解。
* @extends NvsTrack
*/
class NvsAudioTrack extends NvsTrack {
/**
* @constructor
*/
constructor() {
super();
}
/**
* @description 添加片段
* @param {} audioFilePath 音频文件路径
* @param {} insertPoint 插入点
* @return {Num}
*/
insertClip(audioFilePath, insertPoint) {
return Module.nvs_audioTrack_insertClip(this.internalObj, audioFilePath, insertPoint);
}
/**
* @description 插入片段
* @param {} audioFilePath 音频文件路径
* @param {} trimIn 修剪入点
* @param {} trimOut 修剪出点
* @param {} insertPoint 插入点
* @return {Num}
*/
insertClip2(audioFilePath, trimIn, trimOut, insertPoint) {
return Module.nvs_audioTrack_insertClip2(this.internalObj, audioFilePath, trimIn, trimOut, insertPoint);
}
/**
* @description 追加片段
* @param {} audioFilePath 音频文件路径
* @return {Num}
*/
appendClip(audioFilePath) {
return this.insertClip(audioFilePath, this.getClipCount());
}
/**
* @description 追加片段
* @param {} audioFilePath 音频文件路径
* @param {} trimIn 裁剪入点
* @param {} trimOut 裁剪出点
* @return {Num}
*/
appendClip2(audioFilePath, trimIn, trimOut) {
return this.insertClip2(audioFilePath, trimIn, trimOut, this.getClipCount());
}
/**
* @description 添加片段
* @param {} audioFilePath 音频文件路径
* @param {} inPoint 入点
* @return {Num}
*/
addClip(audioFilePath, inPoint) {
return Module.nvs_audioTrack_addClip(this.internalObj, audioFilePath, inPoint);
}
/**
* @description 添加片段
* @param {} audioFilePath 音频文件路径
* @param {} inPoint 入点
* @param {} trimIn 裁剪入点
* @param {} trimOut 裁剪出点
* @return {Num}
*/
addClip2(audioFilePath, inPoint, trimIn, trimOut) {
return Module.nvs_audioTrack_addClip2(this.internalObj, audioFilePath, inPoint, trimIn, trimOut);
}
/**
* @description 根据索引获取片段
* @param {} index 索引
* @return {Num}
*/
getClipByIndex(index) {
return Module.nvs_audioTrack_getClipByIndex(this.internalObj, index);
}
/**
* @description 根据时间线位置获取片段
* @param {} timelinePos 时间线位置
* @return {Num}
*/
getClipByTimelinePosition(timelinePos) {
return Module.nvs_audioTrack_getClipByTimelinePosition(this.internalObj, timelinePos);
}
/**
* @description 设置内置转场
* @param {srcClipIndex} 源片段索引
* @param {transitionName} 转场名字
* @return {Num}
*/
setBuiltinTransition(srcClipIndex, transitionName) {
return Module.nvs_audioTrack_setBuiltinTransition(this.internalObj, srcClipIndex, transitionName);
}
/**
* @description 根据原片段索引获取转场
* @param {srcClipIndex} 源片段索引
* @return {}
*/
getTransitionBySourceClipIndex(srcClipIndex) {
return Module.nvs_audioTrack_getTransitionBySourceClipIndex(this.internalObj, srcClipIndex);
}
}
/**
* @classdesc 片段，音视频文件的具体描述。片段是容纳音视频内容的实体，是对视频、音频文件的描述，分为音频片段(Audio Clip)和视频片段(Video Clip)。它定义了不同类型片段所拥有的共同属性和行为， 即派生的音频片段和和视频片段可根据需要修改各自的裁剪出入点，左右声道，播放速度等。在SDK框架中，在轨道(Track)上可添加相应的音频片段和视频片段。
* @extends NvsProjObj
*/
class NvsClip extends NvsProjObj {
/**
* @constructor
*/
constructor() {
super();
}
/**
* @description 获取修剪入点
* @return {}
*/
getTrimIn() {
return Module.nvs_clip_getTrimIn(this.internalObj);
}
/**
* @description 获取修剪出点
* @return {}
*/
getTrimOut() {
return Module.nvs_clip_getTrimOut(this.internalObj);
}
/**
* @description 移动修剪点
* @param {} offset
* @return {}
*/
moveTrimPoint(offset) {
return Module.nvs_clip_moveTrimPoint(this.internalObj, offset);
}
/**
* @description 获取入点
* @return {}
*/
getInPoint() {
return Module.nvs_clip_getInPoint(this.internalObj);
}
/**
* @description 获取出点
* @return {}
*/
getOutPoint() {
return Module.nvs_clip_getOutPoint(this.internalObj);
}
/**
* @description 获取类型
* @return {}
*/
getType() {
return Module.nvs_clip_getType(this.internalObj);
}
/**
* @description 获取索引
* @return {}
*/
getIndex() {
return Module.nvs_clip_getIndex(this.internalObj);
}
/**
* @description 获取文件路径
* @return {}
*/
getFilePath() {
return Module.nvs_clip_getFilePath(this.internalObj);
}
/**
* @description 获取特效计数
* @return {}
*/
getFxCount() {
return Module.nvs_clip_getFxCount(this.internalObj);
}
/**
* @description 改变入点
* @param {} newTrimInPoint 新裁剪入点
* @param {} affectSibling 影响同级
* @return {}
*/
changeTrimInPoint(newTrimInPoint, affectSibling) {
return Module.nvs_clip_changeTrimInPoint(this.internalObj, newTrimInPoint, affectSibling);
}
/**
* @description 改变出点
* @param {} newTrimOutPoint 新裁剪出点
* @param {} affectSibling 影响同级
* @return {}
*/
changeTrimOutPoint(newTrimOutPoint, affectSibling) {
return Module.nvs_clip_changeTrimOutPoint(this.internalObj, newTrimOutPoint, affectSibling);
}
/**
* @description 获取速度
* @return {}
*/
getSpeed() {
return Module.nvs_clip_getSpeed(this.internalObj);
}
/**
* @description 改变速度
* @param {} newSpeed 新速度
* @param {} keepAudioPitch 保持音频音调
* @return {}
*/
changeSpeed(newSpeed, keepAudioPitch) {
Module.nvs_clip_changeSpeed(this.internalObj, newSpeed, keepAudioPitch);
}
/**
* @description 获取音量增益
* @return {}
*/
getVolumeGain() {
return Module.nvs_clip_getVolumeGain(this.internalObj);
}
/**
* @description 设置音量增益
* @param {} leftVolumeGain 左音频增益
* @param {} rightVolumeGain 右音频增益
* @return {}
*/
setVolumeGain(leftVolumeGain, rightVolumeGain) {
Module.nvs_clip_setVolumeGain(this.internalObj, leftVolumeGain, rightVolumeGain);
}
/**
* @description 设置淡入持续时间
* @param {} duration 持续时间
* @return {}
*/
setFadeInDuration(duration) {
Module.nvs_clip_setFadeInDuration(this.internalObj, duration);
}
/**
* @description 获取淡入持续时间
* @return {}
*/
getFadeInDuration() {
return Module.nvs_clip_getFadeInDuration(this.internalObj);
}
/**
* @description 设置淡出持续时间
* @param {} duration 持续时间
* @return {}
*/
setFadeOutDuration(duration) {
Module.nvs_clip_setFadeOutDuration(this.internalObj, duration);
}
/**
* @description 获取淡出持续时间
* @return {}
*/
getFadeOutDuration() {
return Module.nvs_clip_getFadeOutDuration(this.internalObj);
}
/**
* @description 改变曲线变速
* @param {} curvesString 曲线字符串
* @param {} keepAudioPitch 保持音频音调
* @return {}
*/
changeCurvesVariableSpeed(curvesString, keepAudioPitch) {
return Module.nvs_clip_changeCurvesVariableSpeed(this.internalObj, curvesString, keepAudioPitch);
}
/**
* @description 获取片段变速曲线字符串
* @return {}
*/
getClipVariableSpeedCurvesString() {
return Module.nvs_clip_getClipVariableSpeedCurvesString(this.internalObj);
}
/**
* @description 根据时间线位置曲线变速获取片段位置
* @param {} timelinePos 时间线位置
* @return {}
*/
getClipPosByTimelinePosCurvesVariableSpeed(timelinePos) {
return Module.nvs_clip_getClipPosByTimelinePosCurvesVariableSpeed(this.internalObj, timelinePos);
}
/**
* @description 根据片段位置曲线变速获取时间线位置
* @param {} clipPos 片段位置
* @return {}
*/
getTimelinePosByClipPosCurvesVariableSpeed(clipPos) {
return Module.nvs_clip_getTimelinePosByClipPosCurvesVariableSpeed(this.internalObj, clipPos);
}
}
/**
* @classdesc 视频片段，对视频文件的描述。视频片段源可以是视频或者图片。每个视频片段可以修改其裁剪入点、裁剪出点以及播放速度，也可以设置摇摄和扫描。编辑视频时，可以按特效类型的不同（内建特效，包裹式特效，美颜特效）添加或者插入多个视频特效。 添加资源包特效时，都得先安装，安装成功后获取packageId才能使用，而内建特效(builtin)只需获取特效名称即可使用。
* @extends NvsClip
*/
class NvsVideoClip extends NvsClip {
/**
* @constructor
*/
constructor() {
super();
}
/**
* @description 追加内置特效
* @param {} fxName 特效名字
* @return {}
*/
appendBuiltinFx(fxName) {
return Module.nvs_videoClip_appendBuiltinFx(this.internalObj, fxName, false);
}
/**
* @description 插入内置特效
* @param {} fxName 特效名字
* @param {} fxIndex 特效索引
* @return {}
*/
insertBuiltinFx(fxName, fxIndex) {
return Module.nvs_videoClip_insertBuiltinFx(this.internalObj, fxName, fxIndex, false);
}
/**
* @description 追加包特效
* @param {} fxPackageId 特效包ID
* @return {}
*/
appendPackagedFx(fxPackageId) {
return Module.nvs_videoClip_appendPackagedFx(this.internalObj, fxPackageId, false);
}
/**
* @description 加入包特效
* @param {} fxPackageId 特效包ID
* @param {} fxIndex 特效索引
* @return {}
*/
insertPackagedFx(fxPackageId, fxIndex) {
return Module.nvs_videoClip_insertPackagedFx(this.internalObj, fxPackageId, fxIndex, false);
}
/**
* @description 删除特效
* @param {} fxIndex 特效索引
* @return {}
*/
removeFx(fxIndex) {
return Module.nvs_videoClip_removeFx(this.internalObj, fxIndex, false);
}
/**
* @description 删除所有特效
* @return {}
*/
removeAllFx() {
return Module.nvs_videoClip_removeAllFx(this.internalObj);
}
/**
* @description 根据索引获取特效
* @param {} fxIndex 特效索引
* @return {}
*/
getFxByIndex(fxIndex) {
return Module.nvs_videoClip_getFxByIndex(this.internalObj, fxIndex, false);
}
/**
* @description 追加原始内置特效
* @param {} fxName 特效名字
* @return {}
*/
appendRawBuiltinFx(fxName) {
return Module.nvs_videoClip_appendBuiltinFx(this.internalObj, fxName, true);
}
/**
* @description 插入原始内置特效
* @param {} fxName 特效名字
* @param {} fxIndex 特效索引
* @return {}
*/
insertRawBuiltinFx(fxName, fxIndex) {
return Module.nvs_videoClip_insertBuiltinFx(this.internalObj, fxName, fxIndex, true);
}
/**
* @description 追加原始包特效
* @param {} fxPackageId 特效包ID
* @return {}
*/
appendRawPackagedFx(fxPackageId) {
return Module.nvs_videoClip_appendPackagedFx(this.internalObj, fxPackageId, true);
}
/**
* @description 加入原始包特效
* @param {} fxPackageId 特效包ID
* @param {} fxIndex 特效索引
* @return {}
*/
insertRawPackagedFx(fxPackageId, fxIndex) {
return Module.nvs_videoClip_insertPackagedFx(this.internalObj, fxPackageId, fxIndex, true);
}
/**
* @description 删除原始特效
* @param {} fxIndex 特效索引
* @return {}
*/
removeRawFx(fxIndex) {
return Module.nvs_videoClip_removeFx(this.internalObj, fxIndex, true);
}
/**
* @description 获取原始特效计数
* @return {}
*/
getRawFxCount() {
return Module.nvs_videoClip_getRawFxCount(this.internalObj);
}
/**
* @description 根据索引获取原始特效
* @param {} fxIndex 特效索引
* @return {}
*/
getRawFxByIndex(fxIndex) {
return Module.nvs_videoClip_getFxByIndex(this.internalObj, fxIndex, true);
}
/**
* @description 获取视频类型
* @return {}
*/
getVideoType() {
return Module.nvs_videoClip_getVideoType(this.internalObj);
}
/**
* @description 获取主题角色
* @return {}
*/
getRoleInTheme() {
return Module.nvs_videoClip_getRoleInTheme(this.internalObj);
}
/**
* @description 设置反向播放
* @param {} playInReverse 反向播放
* @return {}
*/
setPlayInReverse(playInReverse) {
Module.nvs_videoClip_setPlayInReverse(this.internalObj, playInReverse);
}
/**
* @description 获取反向播放
* @return {}
*/
getPlayInReverse() {
return Module.nvs_videoClip_getPlayInReverse(this.internalObj);
}
/**
* @description 设置扩展视频旋转
* @param {} rotation 旋转
* @return {}
*/
setExtraVideoRotation(rotation) {
Module.nvs_videoClip_setExtraVideoRotation(this.internalObj, rotation);
}
/**
* @description 获取扩展视频旋转
* @return {}
*/
getExtraVideoRotation() {
return Module.nvs_videoClip_getExtraVideoRotation(this.internalObj);
}
/**
* @description 设置遥感和扫描
* @param {} pan 遥感
* @param {} scan 扫描
* @return {}
*/
setPanAndScan(pan, scan) {
Module.nvs_videoClip_setPanAndScan(this.internalObj, pan, scan);
}
/**
* @description 获取遥感和扫描
* @return {}
*/
getPanAndScan() {
return Module.nvs_videoClip_getPanAndScan(this.internalObj);
}
/**
* @description 设置源背景模式
* @param {} mode 模式
* @return {}
*/
setSourceBackgroundMode(mode) {
Module.nvs_videoClip_setSourceBackgroundMode(this.internalObj, mode);
}
/**
* @description 获取源背景模式
* @return {}
*/
getSourceBackgroundMode() {
return Module.nvs_videoClip_getSourceBackgroundMode(this.internalObj);
}
/**
* @description 设置源背景颜色
* @param {} color 颜色
* @return {}
*/
setSourceBackgroundColor(color) {
Module.nvs_videoClip_setSourceBackgroundColor(this.internalObj, color);
}
/**
* @description 获取源背景颜色
* @return {}
*/
getSourceBackgroundColor() {
return Module.nvs_videoClip_getSourceBackgroundColor(this.internalObj);
}
/**
* @description 设置图像运动模式
* @param {} mode 模式
* @return {}
*/
setImageMotionMode(mode) {
Module.nvs_videoClip_setImageMotionMode(this.internalObj, mode);
}
/**
* @description 获取图像运动模式
* @return {}
*/
getImageMotionMode() {
return Module.nvs_videoClip_getImageMotionMode(this.internalObj);
}
/**
* @description 设置图像运动动画启用
* @param {} enabled 开启
* @return {}
*/
setImageMotionAnimationEnabled(enabled) {
Module.nvs_videoClip_setImageMotionAnimationEnabled(this.internalObj, enabled);
}
/**
* @description 是否启用了图像运动动画
* @return {}
*/
isImageMotionAnimationEnabled() {
return Module.nvs_videoClip_isImageMotionAnimationEnabled(this.internalObj);
}
/**
* @description 设置片段包装模式
* @param {} wrapMode 包装模式
* @return {}
*/
setClipWrapMode(wrapMode) {
Module.nvs_videoClip_setClipWrapMode(this.internalObj, wrapMode);
}
/**
* @description 获取片段包装模式
* @return {}
*/
getClipWrapMode() {
return Module.nvs_videoClip_getClipWrapMode(this.internalObj);
}
/**
* @description 启用片段冻结帧
* @param {} enabled 开启
* @return {}
*/
enableClipFreezeFrame(enabled) {
Module.nvs_videoClip_enableClipFreezeFrame(this.internalObj, enabled);
}
/**
* @description 是否启用了片段冻结帧
* @return {}
*/
isClipFreezeFrameEnabled() {
return Module.nvs_videoClip_isClipFreezeFrameEnabled(this.internalObj);
}
/**
* @description 设置片段冻结帧修剪位置
* @param {} trimPos 裁剪点
* @return {}
*/
setClipFreezeFrameTrimPosition(trimPos) {
Module.nvs_videoClip_setClipFreezeFrameTrimPosition(this.internalObj, trimPos);
}
/**
* @description 获取剪辑冻结帧修剪位置
* @return {}
*/
getClipFreezeFrameTrimPosition() {
return Module.nvs_videoClip_getClipFreezeFrameTrimPosition(this.internalObj);
}
/**
* @description 获取属性视频特效
* @return {}
*/
getPropertyVideoFx() {
return Module.nvs_videoClip_getPropertyVideoFx(this.internalObj);
}
/**
* @description 启用属性视频特效
* @param {} enabled 开启
* @return {}
*/
enablePropertyVideoFx(enabled) {
Module.nvs_videoClip_enablePropertyVideoFx(this.internalObj, enabled);
}
}
/**
* @classdesc 音频片段，对音频文件的描述。音频片段既可以修改其裁剪入点和出点，播放速度等，还可以添加、插入、移除以及获取多个音频特效。
* @extends NvsClip
*/
class NvsAudioClip extends NvsClip {
/**
* @constructor
*/
constructor() {
super();
}
/**
* @description 追加特效
* @param {} fxName 特效名字
* @return {}
*/
appendFx(fxName) {
return Module.nvs_audioClip_appendFx(this.internalObj, fxName);
}
/**
* @description 插入特效
* @param {} fxName 特效名字
* @param {} fxIndex 特效索引
* @return {}
*/
insertFx(fxName, fxIndex) {
return Module.nvs_audioClip_insertFx(this.internalObj, fxName, fxIndex);
}
/**
* @description 删除特效
* @param {} fxIndex 特效索引
* @return {}
*/
removeFx(fxIndex) {
return Module.nvs_audioClip_removeFx(this.internalObj, fxIndex);
}
/**
* @description 根据索引获取特效
* @param {} fxIndex 特效索引
* @return {}
*/
getFxByIndex(fxIndex) {
return Module.nvs_audioClip_getFxByIndex(this.internalObj, fxIndex);
}
/**
* @description 设置音频流索引
* @param {} streamIndex 流索引
* @return {}
*/
setAudioStreamIndex(streamIndex) {
Module.nvs_audioClip_setAudioStreamIndex(this.internalObj, streamIndex);
}
/**
* @description 获取音频流索引
* @return {}
*/
getAudioSteramIndex() {
return Module.nvs_audioClip_getAudioSteramIndex(this.internalObj);
}
}
/**
* @classdesc 遥感扫描类
*/
class NvsPanAndScan {
/**
* @constructor
* @param {} pan 遥感
* @param {} scan 扫描
*/
constructor(pan, scan) {
this.pan = pan;
this.scan = scan;
}
}
/**
* @classdesc 音量类，设置音量的左右声道
*/
class NvsVolume {
/**
* @constructor
* @param {} leftVolume 左边音量
* @param {} rightVolume 右边音量
*/
constructor(leftVolume, rightVolume) {
this.leftVolume = leftVolume;
this.rightVolume = rightVolume;
}
}
/**
* @classdesc 自定义颜色类。SDK中，NvsColor类属性r,g,b,a取值范围是[0,1]，而非[0,255]。
*/
class NvsColor {
/**
* @constructor
* @param {} r 颜色r分量
* @param {} g 颜色g分量
* @param {} b 颜色g分量
* @param {} a 颜色a分量
*/
constructor(r, g, b, a) {
this.r = r;
this.g = g;
this.b = b;
this.a = a;
}
}
/**
* @classdesc 二维坐标点结构。 参数类型为双精度浮点数。
*/
class NvsPointF {
/**
* @constructor
* @param {} x x坐标
* @param {} y y坐标
*/
constructor(x, y) {
this.x = x;
this.y = y;
}
}
/**
* @classdesc 矩形类
*/
class NvsRectF {
/**
* @constructor
* @param {} left 左
* @param {} top 上
* @param {} right 右
* @param {} bottom 下
*/
constructor(left, top, right, bottom) {
this.left = left;
this.top = top;
this.right = right;
this.bottom = bottom;
}
}
/**
* @classdesc 水印信息类
*/
class NvsWatermarkInfo {
/**
* @constructor
* @param {} sceneWidth 场景宽度
* @param {} sceneHeight 场景高度
* @param {} imageName 图片名字
* @param {} imgWidth 图片宽度
* @param {} imgHeight 图片高度
* @param {} tx
* @param {} ty
* @param {} dirPath
* @param {} opacity
*/
constructor(sceneWidth, sceneHeight, imageName, imgWidth, imgHeight, tx, ty, dirPath, opacity) {
this.sceneWidth = sceneWidth;
this.sceneHeight = sceneHeight;
this.imageName = imageName;
this.imgWidth = imgWidth;
this.imgHeight = imgHeight;
this.tx = tx;
this.ty = ty;
this.dirPath = dirPath;
this.opacity = opacity;
}
}
/**
* @classdesc 资源包管理器，管理视频场景中的资源包。在SDK开发过中，资源包管理器统一对需要的各种特技资源包包括字幕，主题，动画贴纸等进行相应的安装，升级，卸载等操作。在安装，升级，卸载时，出现差错都会有相应的错误提示类型，以便快速定位和解决错误。
*/
class NvsAssetPackageManager {
/**
* @constructor
*/
constructor() {
this.internalObj = 0;
this.onFinishAssetPackageInstallation = function(assetPackageId, assetPackageFilePath, assetPackageType, error) {
}
this.onFinishTemplatePackageGenerate = function(assetPackageFilePath, error) {
}
}
/**
* @description 设置内置对象
* @param {} obj 对象
* @return {}
*/
setInternalObject(obj) {
this.internalObj = obj;
}
/**
* @description 获取内置对象
* @return {}
*/
getInternalObject() {
return this.internalObj;
}
/**
* @description 安装资源包
* @param {} assetPackageFilePath 资源包文件路径
* @param {} licenseFilePath 许可证文件路径
* @param {} type 类型
* @return {}
*/
installAssetPackage(assetPackageFilePath, licenseFilePath, type) {
return Module.nvs_assetPackageManager_installAssetPackage(assetPackageFilePath, licenseFilePath, type);
}
/**
* @description 卸载资源包
* @param {} assetPackageId 资源包ID
* @param {} type 类型
* @return {}
*/
uninstallAssetPackage(assetPackageId, type) {
return Module.nvs_assetPackageManager_uninstallAssetPackage(assetPackageId, type);
}
/**
* @description 获取资源包状态
* @param {} assetPackageId 资源包ID
* @param {} type 类型
* @return {}
*/
getAssetPackageStatus(assetPackageId, type) {
return Module.nvs_assetPackageManager_getAssetPackageStatus(assetPackageId, type);
}
/**
* @description 是否是粒子特效
* @param {} uuidString
* @return {}
*/
isParticleFX(uuidString) {
return Module.nvs_assetPackageManager_isParticleFX(uuidString);
}
/**
* @description 获取视频特效资源包描述
* @param {} uuidString 字符串唯一标识
* @return {}
*/
getVideoFxAssetPackageDescription(uuidString) {
return Module.nvs_assetPackageManager_getVideoFxAssetPackageDescription(uuidString);
}
/**
* @description 获取模板素材
* @param {} uuidString 字符串唯一标识
* @return {}
*/
getTemplateFootages(uuidString) {
return Module.nvs_assetPackageManager_getTemplateFootages(uuidString);
}
/**
* @description 获取模板字幕
* @param {} uuidString 字符串唯一标识
* @return {}
*/
getTemplateCaptions(uuidString) {
return Module.nvs_assetPackageManager_getTemplateCaptions(uuidString);
}
/**
* @description 获取模板组合字幕
* @return {}
*/
getTemplateCompoundCaptions() {
return Module.nvs_assetPackageManager_getTemplateCompoundCaptions(uuidString);
}
/**
* @description 获取模板包路径
* @param {} uuidString
* @return {}
*/
getTemplatePackageDirPath(uuidString) {
return Module.nvs_assetPackageManager_getTemplatePackageDirPath(uuidString);
}
/**
* @description 获取模板当前纵横比
* @param {} uuidString 字符串唯一标识
* @return {}
*/
getTemplateCurrentAspectRatio(uuidString) {
return Module.nvs_assetPackageManager_getTemplateCurrentAspectRatio(uuidString);
}
/**
* @description 获取模板缺省纵横比
* @param {} uuidString 字符串唯一标识
* @return {}
*/
getTemplateDefaultAspectRatio(uuidString) {
return Module.nvs_assetPackageManager_getTemplateDefaultAspectRatio(uuidString);
}
/**
* @description 写XML模板
* @param {} timeline
* @param {} aspectRatio
* @param {} uuidString
* @return {}
*/
writeTemplateXml(timeline, aspectRatio, uuidString) {
return Module.nvs_assetPackageManager_writeTemplateXml(timeline, aspectRatio, uuidString);
}
/**
* @description 生成模板包
* @param {} innerAssetDir 内置资源路径
* @param {} uuidString 字符串唯一标识
* @param {} outputPath 输出路径
* @return {}
*/
generateTemplatePackage(innerAssetDir, uuidString, outputPath) {
return Module.nvs_assetPackageManager_generateTemplatePackage(innerAssetDir, uuidString, outputPath);
}
/**
* @description 获取资源包根路径
* @return {}
*/
getAssetPackageRootDir() {
return Module.nvs_assetPackageManager_getAssetPackageRootDir();
}
/**
* @description 改变模板纵横比
* @param {} uuidString 字符串唯一标识
* @param {} aspectRatio 纵横比
* @return {}
*/
changeTemplateAspectRatio(uuidString, aspectRatio) {
return Module.nvs_assetPackageManager_changeTemplateAspectRatio(uuidString, aspectRatio);
}
}
/**
* @classdesc 区域信息类
*/
class NvsRegionInfo {
/**
* @constructor
*/
constructor() {
this.type = '';
this.center = undefined;
this.a = undefined;
this.b = undefined;
this.theta = undefined;
this.points = [];
}
}
/**
* @classdesc 特效类。特效类是视频特效(Video Fx)，音频特效(Audio Fx)，音频转场(Audio Transition)，视频转场(Video Transition)等不同类型特效的基类。 在SDK框架中，特效是很关键的一部分，派生自NvsFx的每种不同类型的特效，或通过片段实例，或时间线实例，或轨道实例来添加，移除和获取。 同时，特效类中提供了不同的API接口来设置和获取特效参数类型。
* @extends NvsProjObj
*/
class NvsFx extends NvsProjObj {
/**
* @constructor
*/
constructor() {
super();
}
/**
* @description 获取描述信息
* @return {}
*/
getDescription() {
return Module.nvs_fx_getDescription(this.internalObj);
}
/**
* @description 设置整数值
* @param {} fxParam 特效参数
* @param {} val 值
* @return {}
*/
setIntVal(fxParam, val) {
Module.nvs_fx_setIntVal(this.internalObj, fxParam, val);
}
/**
* @description 获取整数值
* @param {} fxParam 特效参数
* @return {}
*/
getIntVal(fxParam) {
return Module.nvs_fx_getIntVal(this.internalObj, fxParam);
}
/**
* @description 在某个时间设置整数值
* @param {} fxParam 特效参数
* @param {} val 值
* @param {} time 时间
* @return {}
*/
setIntValAtTime(fxParam, val, time) {
Module.nvs_fx_setIntValAtTime(this.internalObj, fxParam, val, time);
}
/**
* @description 在某个时间获取整数值
* @param {} fxParam 特效参数
* @param {} time 时间
* @return {}
*/
getIntValAtTime(fxParam, time) {
return Module.nvs_fx_getIntValAtTime(this.internalObj, fxParam, time);
}
/**
* @description 设置浮点值
* @param {} fxParam 特效参数
* @param {} val 值
* @return {}
*/
setFloatVal(fxParam, val) {
Module.nvs_fx_setFloatVal(this.internalObj, fxParam, val);
}
/**
* @description 获取浮点值
* @param {} fxParam 特效参数
* @return {}
*/
getFloatVal(fxParam) {
return Module.nvs_fx_getFloatVal(this.internalObj, fxParam);
}
/**
* @description 在某个时间设置浮点值
* @param {} fxParam 特效参数值
* @param {} val 值
* @param {} time 时间点
* @return {}
*/
setFloatValAtTime(fxParam, val, time) {
Module.nvs_fx_setFloatValAtTime(this.internalObj, fxParam, val, time);
}
/**
* @description 在某个时间获取浮点值
* @param {} fxParam 特效参数
* @param {} time 时间
* @return {}
*/
getFloatValAtTime(fxParam, time) {
return Module.nvs_fx_getFloatValAtTime(this.internalObj, fxParam, time);
}
/**
* @description 设置布尔值
* @param {} fxParam 特效参数
* @param {} val 具体值
* @return {}
*/
setBooleanVal(fxParam, val) {
Module.nvs_fx_setBooleanVal(this.internalObj, fxParam, val);
}
/**
* @description 获取布尔值
* @param {} fxParam 特效参数
* @return {}
*/
getBooleanVal(fxParam) {
return Module.nvs_fx_getBooleanVal(this.internalObj, fxParam);
}
/**
* @description 在某个时间设置布尔值
* @param {} fxParam 特效参数
* @param {} val 具体值
* @param {} time 时间
* @return {}
*/
setBooleanValAtTime(fxParam, val, time) {
Module.nvs_fx_setBooleanValAtTime(this.internalObj, fxParam, val, time);
}
/**
* @description 在某个时间获取布尔值
* @param {} fxParam 特效参数
* @param {} time 时间
* @return {}
*/
getBooleanValAtTime(fxParam, time) {
return Module.nvs_fx_getBooleanValAtTime(this.internalObj, fxParam, time);
}
/**
* @description 设置菜单值
* @param {} fxParam 特效参数
* @param {} val 菜单值
* @return {}
*/
setMenuVal(fxParam, val) {
Module.nvs_fx_setMenuVal(this.internalObj, fxParam, val);
}
/**
* @description 获取菜单值
* @param {} fxParam 特效参数
* @return {}
*/
getMenuVal(fxParam) {
return Module.nvs_fx_getMenuVal(this.internalObj, fxParam);
}
/**
* @description 在某个时间设置菜单值
* @param {} fxParam 特效参数
* @param {} val 值
* @param {} time 时间点
* @return {}
*/
setMenuValAtTime(fxParam, val, time) {
Module.nvs_fx_setMenuValAtTime(this.internalObj, fxParam, val, time);
}
/**
* @description 在某个时间获取菜单值
* @param {} fxParam 特效参数
* @param {} time 时间点
* @return {}
*/
getMenuValAtTime(fxParam, time) {
return Module.nvs_fx_getMenuValAtTime(this.internalObj, fxParam, time);
}
/**
* @description 设置字符串值
* @param {} fxParam 特效参数
* @param {} val 字符串值
* @return {}
*/
setStringVal(fxParam, val) {
Module.nvs_fx_setStringVal(this.internalObj, fxParam, val);
}
/**
* @description 获取字符串值
* @param {} fxParam 特效参数
* @return {}
*/
getStringVal(fxParam) {
return Module.nvs_fx_getStringVal(this.internalObj, fxParam);
}
/**
* @description 在某个时间点设置字符串值
* @param {} fxParam 特效参数
* @param {} val 字符串值
* @param {} time 时间点
* @return {}
*/
setStringValAtTime(fxParam, val, time) {
Module.nvs_fx_setStringValAtTime(this.internalObj, fxParam, val, time);
}
/**
* @description 在某个时间获取字符串值
* @param {} fxParam 特效参数
* @param {} time 时间点
* @return {}
*/
getStringValAtTime(fxParam, time) {
return Module.nvs_fx_getStringValAtTime(this.internalObj, fxParam, time);
}
/**
* @description 设置颜色值
* @param {} fxParam 特效参数
* @param {} val 颜色值
* @return {}
*/
setColorVal(fxParam, val) {
Module.nvs_fx_setColorVal(this.internalObj, fxParam, val);
}
/**
* @description 获取颜色值
* @param {} fxParam 特效参数
* @return {}
*/
getColorVal(fxParam) {
return Module.nvs_fx_getColorVal(this.internalObj, fxParam);
}
/**
* @description 在某个时间设置颜色
* @param {} fxParam 特效参数
* @param {} val 颜色值
* @param {} time 时间点
* @return {}
*/
setColorValAtTime(fxParam, val, time) {
Module.nvs_fx_setColorValAtTime(this.internalObj, fxParam, val, time);
}
/**
* @description 在某个时间点获取颜色值
* @param {} fxParam 特效参数
* @param {} time 时间点
* @return {}
*/
getColorValAtTime(fxParam, time) {
return Module.nvs_fx_getColorValAtTime(this.internalObj, fxParam, time);
}
/**
* @description 在某个时间删除关键帧
* @param {} fxParam 特效参数
* @param {} time 时间点
* @return {}
*/
removeKeyframeAtTime(fxParam, time) {
return Module.nvs_fx_removeKeyframeAtTime(this.internalObj, fxParam, time);
}
/**
* @description 删除所有关键帧
* @param {} fxParam 特效参数
* @return {}
*/
removeAllKeyframe(fxParam) {
return Module.nvs_fx_removeAllKeyframe(this.internalObj, fxParam);
}
/**
* @description 是否有关键帧列表
* @param {} fxParam 特效参数
* @return {}
*/
hasKeyframeList(fxParam) {
return Module.nvs_fx_hasKeyframeList(this.internalObj, fxParam);
}
/**
* @description 在某个时间查询关键帧
* @param {} fxParam 特效参数
* @param {} time 时间点
* @param {} flags 标识
* @return {}
*/
findKeyframeTime(fxParam, time, flags) {
return Module.nvs_fx_findKeyframeTime(this.internalObj, fxParam, time, flags);
}
/**
* @description 设置滤镜强度
* @param {} intensity 强度值
* @return {}
*/
setFilterIntensity(intensity) {
Module.nvs_fx_setFilterIntensity(this.internalObj, intensity);
}
/**
* @description 获取滤镜强度
* @return {}
*/
getFilterIntensity() {
return Module.nvs_fx_getFilterIntensity(this.internalObj);
}
/**
* @description 设置区域
* @param {} isRegional 是区域的
* @return {}
*/
setRegional(isRegional) {
Module.nvs_fx_setRegional(this.internalObj, isRegional);
}
/**
* @description 获取区域范围
* @return {}
*/
getRegional() {
return Module.nvs_fx_getRegional(this.internalObj);
}
/**
* @description 设置忽略背景
* @param {} isIgnoreBackground 是否忽略背景
* @return {}
*/
setIgnoreBackground(isIgnoreBackground) {
Module.nvs_fx_setIgnoreBackground(this.internalObj, isIgnoreBackground);
}
/**
* @description 获取忽略背景
* @return {}
*/
getIgnoreBackground() {
return Module.nvs_fx_getIgnoreBackground(this.internalObj);
}
/**
* @description 设置反转区域
* @param {} isInverseRegion 是否反转区域
* @return {}
*/
setInverseRegion(isInverseRegion) {
Module.nvs_fx_setInverseRegion(this.internalObj, isInverseRegion);
}
/**
* @description 获取反转区域
* @return {}
*/
getInverseRegion() {
return Module.nvs_fx_getInverseRegion(this.internalObj);
}
/**
* @description 设置区域
* @param {} region 区域对象
* @return {}
*/
setRegion(region) {
Module.nvs_fx_setRegion(this.internalObj, region);
}
/**
* @description 在某个时间设置区域
* @param {} region 区域对象
* @param {} time 时间点
* @return {}
*/
setRegionAtTime(region, time) {
Module.nvs_fx_setRegionAtTime(this.internalObj, region, time);
}
/**
* @description 设置椭圆区域
* @param {} center 居中
* @param {} a 长半轴
* @param {} b 短半轴
* @param {} angle 角度
* @return {}
*/
setEllipseRegion(center, a, b, angle) {
Module.nvs_fx_setEllipseRegion(this.internalObj, center, a, b, angle);
}
/**
* @description 在某个时间点设置椭圆区域
* @param {} center 居中
* @param {} a 长半轴
* @param {} b 短半轴
* @param {} angle 角度
* @param {} time 时间
* @return {}
*/
setEllipseRegionAtTime(center, a, b, angle, time) {
Module.nvs_fx_setEllipseRegionAtTime(this.internalObj, center, a, b, angle, time);
}
/**
* @description 获取区域信息
* @return {}
*/
getRegionInfos() {
return Module.nvs_fx_getRegionInfos(this.internalObj);
}
/**
* @description 在某个时间点获取区域信息
* @param {} time 时间点
* @return {}
*/
getRegionInfosAtTime(time) {
return Module.nvs_fx_getRegionInfosAtTime(this.internalObj, time);
}
/**
* @description 设置区域羽化宽度
* @param {} featherWidth 宽度值
* @return {}
*/
setRegionalFeatherWidth(featherWidth) {
Module.nvs_fx_setRegionalFeatherWidth(this.internalObj, featherWidth);
}
/**
* @description 获取区域羽化宽度
* @return {}
*/
getRegionalFeatherWidth() {
return Module.nvs_fx_getRegionalFeatherWidth(this.internalObj);
}
/**
* @description 获取粒子系统上下文
* @return {}
*/
getParticleSystemContext() {
return Module.nvs_fx_getParticleSystemContext(this.internalObj);
}
/**
* @description 获取ARScene操作
* @return {}
*/
getARSceneManipulate() {
return Module.nvs_fx_getARSceneManipulate(this.internalObj);
}
/**
* @description 设置Expr变量
* @param {} varName 变量名字
* @param {} varValue 变量值
* @return {}
*/
setExprVar(varName, varValue) {
Module.nvs_fx_setExprVar(this.internalObj, varName, varValue);
}
/**
* @description 获取Expr值
* @param {} varName 变量名字
* @return {}
*/
getExprVar(varName) {
return Module.nvs_fx_getExprVar(this.internalObj, varName);
}
/**
* @description 清除Expr值
* @return {}
*/
clearExprVar() {
Module.nvs_fx_clearExprVar(this.internalObj);
}
/**
* @description 清空表达式中定义的全部参数的值，并设置为默认值0
* @return {}
*/
clearExprVarCtx() {
Module.nvs_fx_clearExprVarCtx(this.internalObj);
}
}
/**
* @classdesc 时间线视频特效 时间线视频特效是作用于时间线实例上的视频特效。 时间线视频特效分为內建特效、包裹特效和自定义特效三种类型。 內建特效是集成在sdk内部的，不需要授权即可直接使用。包裹特效是将特效资源整合成了特效包，每个特效包都有其一一对应的授权文件，并且要先安装再使用，具体情况请参见素材包安装 自定义特效是用户通过编写代码实现的特效 时间线视频特效包含特效入点和出点，通过入点和出点我们可以指定特效作用于时间线的位置和长度，入点要小于出点，单位为微秒。 时间线视频特效允许叠加，渲染顺序通过预设Z值控制。
* @extends NvsFx
*/
class NvsTimelineVideoFx extends NvsFx {
/**
* @constructor
*/
constructor() {
super();
}
/**
* @description 获取时间线视频特效类型
* @return {}
*/
getTimelineVideoFxType() {
return Module.nvs_timelineVideoFx_getTimelineVideoFxType(this.internalObj);
}
/**
* @description 获取内置时间线视频特效名字
* @return {}
*/
getBuiltinTimelineVideoFxName() {
return Module.nvs_timelineVideoFx_getBuiltinTimelineVideoFxName(this.internalObj);
}
/**
* @description 获取时间线视频特效包ID
* @return {}
*/
getTimelineVideoFxPackageId() {
return Module.nvs_timelineVideoFx_getTimelineVideoFxPackageId(this.internalObj);
}
/**
* @description 获取入点
* @return {}
*/
getInPoint() {
return Module.nvs_timelineVideoFx_getInPoint(this.internalObj);
}
/**
* @description 获取出点
* @return {}
*/
getOutPoint() {
return Module.nvs_timelineVideoFx_getOutPoint(this.internalObj);
}
/**
* @description 改变入点
* @param {} newInPoint 新的入点
* @return {}
*/
changeInPoint(newInPoint) {
return Module.nvs_timelineVideoFx_changeInPoint(this.internalObj, newInPoint);
}
/**
* @description 改变出点
* @param {} newOutPoint 新的出点
* @return {}
*/
changeOutPoint(newOutPoint) {
return Module.nvs_timelineVideoFx_changeOutPoint(this.internalObj, newOutPoint);
}
/**
* @description 移动位置
* @param {} offset 偏移量
* @return {}
*/
movePosition(offset) {
Module.nvs_timelineVideoFx_movePosition(this.internalObj, offset);
}
/**
* @description 设置Z值
* @param {} value Z值
* @return {}
*/
setZValue(value) {
Module.nvs_timelineVideoFx_setZValue(this.internalObj, value);
}
/**
* @description 获取Z值
* @return {}
*/
getZValue() {
return Module.nvs_timelineVideoFx_getZValue(this.internalObj);
}
/**
* @description 将点从规范映射到粒子系统
* @param {} ptCanonical
* @return {}
*/
mapPointFromCanonicalToParticleSystem(ptCanonical) {
return Module.nvs_timelineVideoFx_mapPointFromCanonicalToParticleSystem(this.internalObj, ptCanonical);
}
}
/**
* @classdesc 时间线字幕是视频上叠加的自定义文字。编辑视频时，可以添加和移除时间线字幕，并对字幕位置进行调整处理。添加完字幕，还可以进行样式设置，包括字体大小，颜色，阴影，描边等。
* @extends NvsFx
*/
class NvsTimelineCaption extends NvsFx {
/**
* @constructor
*/
constructor() {
super();
}
/**
* @description 获取入点
* @return {}
*/
getInPoint() {
return Module.nvs_caption_getInPoint(this.internalObj);
}
/**
* @description 获取出点
* @return {}
*/
getOutPoint() {
return Module.nvs_caption_getOutPoint(this.internalObj);
}
/**
* @description 改变入点
* @param {} newInPoint 新的入点
* @return {}
*/
changeInPoint(newInPoint) {
return Module.nvs_caption_changeInPoint(this.internalObj, newInPoint);
}
/**
* @description 改变出点
* @param {} newOutPoint 新的出点
* @return {}
*/
changeOutPoint(newOutPoint) {
return Module.nvs_caption_changeOutPoint(this.internalObj, newOutPoint);
}
/**
* @description 移动位置
* @param {} offset 偏移量
* @return {}
*/
movePosition(offset) {
Module.nvs_caption_movePosition(this.internalObj, offset);
}
/**
* @description 获取主题角色
* @return {}
*/
getRoleInTheme() {
return Module.nvs_caption_getRoleInTheme(this.internalObj);
}
/**
* @description 获取分类
* @return {}
*/
getCategory() {
return Module.nvs_caption_getCategory(this.internalObj);
}
/**
* @description 获取字幕风格包ID
* @return {}
*/
getCaptionStylePackageId() {
return Module.nvs_caption_getCaptionStylePackageId(this.internalObj);
}
/**
* @description 获取模块化字幕上下文包 ID
* @return {}
*/
getModularCaptionContextPackageId() {
return Module.nvs_caption_getModularCaptionContextPackageId(this.internalObj);
}
/**
* @description 获取模块字幕渲染包ID
* @return {}
*/
getModularCaptionRendererPackageId() {
return Module.nvs_caption_getModularCaptionRendererPackageId(this.internalObj);
}
/**
* @description 获取模块字幕动画包ID
* @return {}
*/
getModularCaptionAnimationPackageId() {
return Module.nvs_caption_getModularCaptionAnimationPackageId(this.internalObj);
}
/**
* @description 获取模块字幕入动画包ID
* @return {}
*/
getModularCaptionInAnimationPackageId() {
return Module.nvs_caption_getModularCaptionInAnimationPackageId(this.internalObj);
}
/**
* @description 获取模块字幕出动画包ID
* @return {}
*/
getModularCaptionOutAnimationPackageId() {
return Module.nvs_caption_getModularCaptionOutAnimationPackageId(this.internalObj);
}
/**
* @description 应用字幕风格
* @param {} captionStylePackageId 字幕风格包ID
* @param {} isUseDefaultAssetParam 使用默认的资源参数
* @return {}
*/
applyCaptionStyle(captionStylePackageId, isUseDefaultAssetParam) {
Module.nvs_caption_applyCaptionStyle(this.internalObj, captionStylePackageId, isUseDefaultAssetParam);
}
/**
* @description 应用模块字幕上下文
* @param {} captionContextPackageId 字幕上下文包ID
* @return {}
*/
applyModularCaptionContext(captionContextPackageId) {
Module.nvs_caption_applyModularCaptionContext(this.internalObj, captionContextPackageId);
}
/**
* @description 应用模块字幕渲染
* @param {} captionRendererPackageId 字幕渲染包ID
* @return {}
*/
applyModularCaptionRenderer(captionRendererPackageId) {
Module.nvs_caption_applyModularCaptionRenderer(this.internalObj, captionRendererPackageId);
}
/**
* @description 应用模块字幕动画
* @param {} captionAnimationPackageId 字幕动画包ID
* @return {}
*/
applyModularCaptionAnimation(captionAnimationPackageId) {
Module.nvs_caption_applyModularCaptionAnimation(this.internalObj, captionAnimationPackageId);
}
/**
* @description 应用模块字幕入动画
* @param {} captionInAnimationPackageId 字幕入动画包ID
* @return {}
*/
applyModularCaptionInAnimation(captionInAnimationPackageId) {
Module.nvs_caption_applyModularCaptionInAnimation(this.internalObj, captionInAnimationPackageId);
}
/**
* @description 应用模块字幕出动画
* @param {} captionOutAnimationPackageId 字幕出动画包ID
* @return {}
*/
applyModularCaptionOutAnimation(captionOutAnimationPackageId) {
Module.nvs_caption_applyModularCaptionOutAnimation(this.internalObj, captionOutAnimationPackageId);
}
/**
* @description 设置模块字幕动画周期
* @param {} periodInMS 周期时间，毫秒计数
* @return {}
*/
setModularCaptionAnimationPeroid(periodInMS) {
Module.nvs_caption_setModularCaptionAnimationPeroid(this.internalObj, periodInMS);
}
/**
* @description 获取模块字幕动画周期
* @return {}
*/
getModularCaptionAnimationPeroid() {
return Module.nvs_caption_getModularCaptionAnimationPeroid(this.internalObj);
}
/**
* @description 设置模块字幕入动画时长
* @param {} inAnimationDurationInMS 入动画时长，毫秒计数
* @return {}
*/
setModularCaptionInAnimationDuration(inAnimationDurationInMS) {
Module.nvs_caption_setModularCaptionInAnimationDuration(this.internalObj, inAnimationDurationInMS);
}
/**
* @description 设置模块字幕入动画时长
* @return {}
*/
getModularCaptionInAnimationDuration() {
return Module.nvs_caption_getModularCaptionInAnimationDuration(this.internalObj);
}
/**
* @description 设置模块字幕出动画时长
* @param {} outAnimationDurationInMS 出动画时长，毫秒计数
* @return {}
*/
setModularCaptionOutAnimationDuration(outAnimationDurationInMS) {
Module.nvs_caption_setModularCaptionOutAnimationDuration(this.internalObj, outAnimationDurationInMS);
}
/**
* @description 获取模块字幕出动画持续时长
* @return {}
*/
getModularCaptionOutAnimationDuration() {
return Module.nvs_caption_getModularCaptionOutAnimationDuration(this.internalObj);
}
/**
* @description 设置字幕文本
* @param {} text 文本字符串
* @return {} text
*/
setText(text) {
Module.nvs_caption_setText(this.internalObj, text);
}
/**
* @description 获取字幕文本
* @return {}
*/
getText() {
return Module.nvs_caption_getText(this.internalObj);
}
/**
* @description 设置文本对齐方式
* @param {} textAlign 对齐方式
* @return {}
*/
setTextAlignment(textAlign) {
Module.nvs_caption_setTextAlignment(this.internalObj, textAlign);
}
/**
* @description 获取文本对齐方式
* @return {}
*/
getTextAlignment() {
return Module.nvs_caption_getTextAlignment(this.internalObj);
}
/**
* @description 设置粗体
* @param {} bold 粗体
* @return {}
*/
setBold(bold) {
Module.nvs_caption_setBold(this.internalObj, bold);
}
/**
* @description 获取粗体
* @return {}
*/
getBold() {
return Module.nvs_caption_getBold(this.internalObj);
}
/**
* @description 设置斜体
* @param {} italic 斜体
* @return {}
*/
setItalic(italic) {
Module.nvs_caption_setItalic(this.internalObj, italic);
}
/**
* @description 获取斜体
* @return {}
*/
getItalic() {
return Module.nvs_caption_getItalic(this.internalObj);
}
/**
* @description 设置下划线
* @param {} underline 下划线
* @return {}
*/
setUnderline(underline) {
Module.nvs_caption_setUnderline(this.internalObj, underline);
}
/**
* @description 获取下划线
* @return {}
*/
getUnderline() {
return Module.nvs_caption_getUnderline(this.internalObj);
}
/**
* @description 设置字符间距类型
* @param {} letterSpacingType 类型标识
* @return {}
*/
setLetterSpacingType(letterSpacingType) {
Module.nvs_caption_setLetterSpacingType(this.internalObj, letterSpacingType);
}
/**
* @description 获取字符间距类型
* @return {}
*/
getLetterSpacingType() {
return Module.nvs_caption_getLetterSpacingType(this.internalObj);
}
/**
* @description 设置字符间距
* @param {} letterSpacing 字符间距
* @return {}
*/
setLetterSpacing(letterSpacing) {
Module.nvs_caption_setLetterSpacing(this.internalObj, letterSpacing);
}
/**
* @description 获取字符间距
* @return {}
*/
getLetterSpacing() {
return Module.nvs_caption_getLetterSpacing(this.internalObj);
}
/**
* @description 设置行距
* @param {} lineSpacing 行间距
* @return {}
*/
setLineSpacing(lineSpacing) {
Module.nvs_caption_setLineSpacing(this.internalObj, lineSpacing);
}
/**
* @description 获取行距
* @return {}
*/
getLineSpacing() {
return Module.nvs_caption_getLineSpacing(this.internalObj);
}
/**
* @description 设置字重
* @param {} weight 字重
* @return {}
*/
setWeight(weight) {
Module.nvs_caption_setWeight(this.internalObj, weight);
}
/**
* @description 获取字重
* @return {}
*/
getWeight() {
return Module.nvs_caption_getWeight(this.internalObj);
}
/**
* @description 设置文本颜色
* @param {} color 文字颜色
* @return {}
*/
setTextColor(color) {
if (color === undefined || color === null || color === '')
return;
Module.nvs_caption_setTextColor(this.internalObj, color);
}
/**
* @description 获取文本颜色
* @return {}
*/
getTextColor() {
return Module.nvs_caption_getTextColor(this.internalObj);
}
/**
* @description 设置绘制轮廓
* @param {} drawOutline 下划线
* @return {}
*/
setDrawOutline(drawOutline) {
Module.nvs_caption_setDrawOutline(this.internalObj, drawOutline);
}
/**
* @description 获取绘制轮廓
* @return {}
*/
getDrawOutline() {
return Module.nvs_caption_getDrawOutline(this.internalObj);
}
/**
* @description 设置轮廓宽度
* @param {} outlineWidth 轮廓宽度
* @return {}
*/
setOutlineWidth(outlineWidth) {
Module.nvs_caption_setOutlineWidth(this.internalObj, outlineWidth);
}
/**
* @description 获取轮廓宽度
* @return {}
*/
getOutlineWidth() {
return Module.nvs_caption_getOutlineWidth(this.internalObj);
}
/**
* @description 设置轮廓颜色
* @param {} color 颜色
* @return {}
*/
setOutlineColor(color) {
if (color === undefined || color === null || color === '')
return;
Module.nvs_caption_setOutlineColor(this.internalObj, color);
}
/**
* @description 获取轮廓颜色
* @return {}
*/
getOutlineColor() {
return Module.nvs_caption_getOutlineColor(this.internalObj);
}
/**
* @description 设置绘制阴影
* @param {} drawShadow 绘制阴影
* @return {}
*/
setDrawShadow(drawShadow) {
Module.nvs_caption_setDrawShadow(this.internalObj, drawShadow);
}
/**
* @description 获取绘制阴影
* @return {}
*/
getDrawShadow() {
return Module.nvs_caption_getDrawShadow(this.internalObj);
}
/**
* @description 设置阴影偏移
* @param {} offset 偏移量
* @return {}
*/
setShadowOffset(offset) {
Module.nvs_caption_setShadowOffset(this.internalObj, offset);
}
/**
* @description 获得阴影偏移
* @return {}
*/
getShadowOffset() {
return Module.nvs_caption_getShadowOffset(this.internalObj);
}
/**
* @description 设置阴影颜色
* @param {} color 背景颜色
* @return {}
*/
setShadowColor(color) {
if (color === undefined || color === null || color === '')
return;
Module.nvs_caption_setShadowColor(this.internalObj, color);
}
/**
* @description 获取阴影颜色
* @return {}
*/
getShadowColor() {
return Module.nvs_caption_getShadowColor(this.internalObj);
}
/**
* @description 设置阴影羽化
* @param {} feather 羽化
* @return {}
*/
setShadowFeather(feather) {
Module.nvs_caption_setShadowFeather(this.internalObj, feather);
}
/**
* @description 获取阴影羽化
* @return {}
*/
getShadowFeather() {
return Module.nvs_caption_getShadowFeather(this.internalObj);
}
/**
* @description 设置字体大小
* @param {} fontSize 字体大小
* @return {}
*/
setFontSize(fontSize) {
Module.nvs_caption_setFontSize(this.internalObj, fontSize);
}
/**
* @description 获取字体大小
* @return {}
*/
getFontSize() {
return Module.nvs_caption_getFontSize(this.internalObj);
}
/**
* @description 根据文件路径设置字体
* @param {} filePath 文件路径
* @return {}
*/
setFontByFilePath(filePath) {
Module.nvs_caption_setFontByFilePath(this.internalObj, filePath);
}
/**
* @description 获取字体文件路径
* @return {}
*/
getFontFilePath() {
return Module.nvs_caption_getFontFilePath(this.internalObj);
}
/**
* @description 设置字体家族
* @param {} family 字体家族
* @return {}
*/
setFontFamily(family) {
Module.nvs_caption_setFontFamily(this.internalObj, family);
}
/**
* @description 获取字体家族
* @return {}
*/
getFontFamily() {
return Module.nvs_caption_getFontFamily(this.internalObj);
}
/**
* @description 设置字幕转场
* @param {} translation 转场
* @return {}
*/
setCaptionTranslation(translation) {
Module.nvs_caption_setCaptionTranslation(this.internalObj, translation);
}
/**
* @description 获取字幕转场
* @return {}
*/
getCaptionTranslation() {
return Module.nvs_caption_getCaptionTranslation(this.internalObj);
}
/**
* @description 字幕转场
* @param {} translationOffset 转场偏移
* @return {}
*/
translateCaption(translationOffset) {
Module.nvs_caption_translateCaption(this.internalObj, translationOffset);
}
/**
* @description 设置锚点
* @param {} anchor 锚点
* @return {}
*/
setAnchorPoint(anchor) {
Module.nvs_caption_setAnchorPoint(this.internalObj, anchor);
}
/**
* @description 获取锚点
* @return {}
*/
getAnchorPoint() {
return Module.nvs_caption_getAnchorPoint(this.internalObj);
}
/**
* @description 设置X方向缩放
* @param {} scale 缩放比例
* @return {}
*/
setScaleX(scale) {
Module.nvs_caption_setScaleX(this.internalObj, scale);
}
/**
* @description 获取X方向缩放
* @return {}
*/
getScaleX() {
return Module.nvs_caption_getScaleX(this.internalObj);
}
/**
* @description 设置Y方向缩放
* @param {} scale 缩放比例
* @return {}
*/
setScaleY(scale) {
Module.nvs_caption_setScaleY(this.internalObj, scale);
}
/**
* @description 获取Y方向缩放
* @return {}
*/
getScaleY() {
return Module.nvs_caption_getScaleY(this.internalObj);
}
/**
* @description 缩放字幕
* @param {} scaleFactor 缩放因子
* @param {} anchor 锚点
* @return {}
*/
scaleCaption(scaleFactor, anchor) {
Module.nvs_caption_scaleCaption(this.internalObj, scaleFactor, anchor);
}
/**
* @description 缩放字幕
* @param {} scaleFactor 缩放因子
* @return {}
*/
scaleCaption2(scaleFactor) {
var rect = this.getTextBoundingRect();
this.scaleCaption(scaleFactor, new NvsPointF((rect.left + rect.right) / 2, (rect.top + rect.bottom) / 2));
}
/**
* @description 设置Z方向旋转
* @param {} angle 角度
* @return {}
*/
setRotationZ(angle) {
Module.nvs_caption_setRotationZ(this.internalObj, angle);
}
/**
* @description 获取Z方向旋转
* @return {}
*/
getRotationZ() {
return Module.nvs_caption_getRotationZ(this.internalObj);
}
/**
* @description 旋转字幕
* @param {} angle 角度
* @param {} anchor 锚点
* @return {}
*/
rotateCaption(angle, anchor) {
Module.nvs_caption_rotateCaption(this.internalObj, angle, anchor);
}
/**
* @description 旋转字幕
* @param {} angle 角度
* @return {}
*/
rotateCaption2(angle) {
var rect = this.getTextBoundingRect();
this.rotateCaption(angle, new NvsPointF((rect.left + rect.right) / 2, (rect.top + rect.bottom) / 2));
}
/**
* @description 获取文本边界矩形
* @return {}
*/
getTextBoundingRect() {
return Module.nvs_caption_getTextBoundingRect(this.internalObj);
}
/**
* @description 获取边界矩形顶点
* @return {}
*/
getBoundingRectangleVertices() {
return Module.nvs_caption_getBoundingRectangleVertices(this.internalObj);
}
/**
* @description 获取字幕边界顶点
* @param {} boundingType 边界类型
* @return {}
*/
getCaptionBoundingVertices(boundingType) {
return Module.nvs_caption_getCaptionBoundingVertices(this.internalObj, boundingType);
}
/**
* @description 设置Z值
* @param {} value Z值
* @return {}
*/
setZValue(value) {
Module.nvs_caption_setZValue(this.internalObj, value);
}
/**
* @description 获取Z值
* @return {}
*/
getZValue() {
return Module.nvs_caption_getZValue(this.internalObj);
}
/**
* @description 设置录制用户操作
* @param {} recordingUserOperation 记录用户操作
* @return {}
*/
setRecordingUserOperation(recordingUserOperation) {
Module.nvs_caption_setRecordingUserOperation(this.internalObj, recordingUserOperation);
}
/**
* @description 设置不透明度
* @param {} opacity 不透明度
* @return {}
*/
setOpacity(opacity) {
Module.nvs_caption_setOpacity(this.internalObj, opacity);
}
/**
* @description 获取不透明度
* @return {}
*/
getOpacity() {
return Module.nvs_caption_getOpacity(this.internalObj);
}
/**
* @description 是否帧字幕
* @return {}
*/
isFrameCaption() {
return Module.nvs_caption_isFrameCaption(this.internalObj);
}
/**
* @description 是否文本颜色改变
* @return {}
*/
isTextColorChanged() {
return Module.nvs_caption_isTextColorChanged(this.internalObj);
}
/**
* @description 是否是模块化
* @return {}
*/
isModular() {
return Module.nvs_caption_isModular(this.internalObj);
}
/**
* @description 设置背景颜色
* @param {} backgroundColor 背景颜色
* @return {}
*/
setBackgroundColor(backgroundColor) {
Module.nvs_caption_setBackgroundColor(this.internalObj, backgroundColor);
}
/**
* @description 获取背景颜色
* @return {}
*/
getBackgroundColor() {
return Module.nvs_caption_getBackgroundColor(this.internalObj);
}
/**
* @description 设置背景半径
* @param {} radius 半径
* @return {}
*/
setBackgroundRadius(radius) {
Module.nvs_caption_setBackgroundRadius(this.internalObj, radius);
}
/**
* @description 获取背景半径
* @return {}
*/
getBackgroundRadius() {
return Module.nvs_caption_getBackgroundRadius(this.internalObj);
}
/**
* @description 设置当前关键帧时间
* @param {} time 时间
* @return {}
*/
setCurrentKeyFrameTime(time) {
Module.nvs_caption_setCurrentKeyFrameTime(this.internalObj, time);
}
/**
* @description 设置是否是歌词
* @param {} isLyrics 是否是歌词
* @return {}
*/
setIsLyrics(isLyrics) {
Module.nvs_caption_setIsLyrics(this.internalObj, isLyrics);
}
/**
* @description 是否是歌词
* @return {}
*/
isLyrics() {
return Module.nvs_caption_isLyrics(this.internalObj);
}
/**
* @description 设置帧字幕最大字体大小
* @param {} maxFontSize 最大字体大小
* @return {}
*/
setFrameCaptionMaxFontSize(maxFontSize) {
Module.nvs_caption_setFrameCaptionMaxFontSize(this.internalObj, maxFontSize);
}
/**
* @description 设置文本框原点矩形
* @param {} rect 矩形
* @return {}
*/
setTextFrameOriginRect(rect) {
Module.nvs_caption_setTextFrameOriginRect(this.internalObj, rect);
}
}
/**
* @classdesc 运动参数
*/
class NvsMotionParameters {
/**
* @constructor
*/
constructor() {
this.anchorX = 0;
this.anchorY = 0;
this.scaleX = 1;
this.scaleY = 1;
this.rotationZ = 0;
this.transX = 0;
this.transY = 0;
}
}
/**
* @classdesc 时间线复合字幕。时间线复合字幕是视频上叠加的组合型文字，每个复合字幕包含若干个子字幕。编辑视频时，可以添加和移除时间线复合字幕，并对字幕位置进行调整处理，还可以对字体，颜色属性进行修改。
* @extends NvsFx
*/
class NvsTimelineCompoundCaption extends NvsFx {
/**
* @constructor
*/
constructor() {
super();
}
/**
* @description 获取字幕数量
* @return {}
*/
getCaptionCount() {
return Module.nvs_compoundCaption_getCaptionCount(this.internalObj);
}
/**
* @description 获取入点
* @return {}
*/
getInPoint() {
return Module.nvs_compoundCaption_getInPoint(this.internalObj);
}
/**
* @description 获取出点
* @return {}
*/
getOutPoint() {
return Module.nvs_compoundCaption_getOutPoint(this.internalObj);
}
/**
* @description 改变入点
* @param {} newInPoint 新入点
* @return {}
*/
changeInPoint(newInPoint) {
return Module.nvs_compoundCaption_changeInPoint(this.internalObj, newInPoint);
}
/**
* @description 改变出点
* @param {} newOutPoint 新出点
* @return {}
*/
changeOutPoint(newOutPoint) {
return Module.nvs_compoundCaption_changeOutPoint(this.internalObj, newOutPoint);
}
/**
* @description 移动位置
* @param {} offset 偏移量
* @return {}
*/
movePosition(offset) {
Module.nvs_compoundCaption_movePosition(this.internalObj, offset);
}
/**
* @description 设置文本
* @param {} captionIndex 字幕索引
* @param {} text 文本
* @return {}
*/
setText(captionIndex, text) {
Module.nvs_compoundCaption_setText(this.internalObj, captionIndex, text);
}
/**
* @description 获取文本
* @param {} captionIndex 字幕索引
* @return {}
*/
getText(captionIndex) {
return Module.nvs_compoundCaption_getText(this.internalObj, captionIndex);
}
/**
* @description 设置文本颜色
* @param {} captionIndex 字幕索引
* @param {} color 颜色
* @return {}
*/
setTextColor(captionIndex, color) {
if (color === undefined || color === null || color === '')
return;
Module.nvs_compoundCaption_setTextColor(this.internalObj, captionIndex, color);
}
/**
* @description 获取文本颜色
* @param {} captionIndex 字幕索引
* @return {}
*/
getTextColor(captionIndex) {
return Module.nvs_compoundCaption_getTextColor(this.internalObj, captionIndex);
}
/**
* @description 设置字体家族
* @param {} captionIndex 字幕索引
* @param {} family 字体家族
* @return {}
*/
setFontFamily(captionIndex, family) {
Module.nvs_compoundCaption_setFontFamily(this.internalObj, captionIndex, family);
}
/**
* @description 获取字体家族
* @param {} captionIndex 字幕索引
* @return {}
*/
getFontFamily(captionIndex) {
return Module.nvs_compoundCaption_getFontFamily(this.internalObj, captionIndex);
}
/**
* @description 设置字幕平移
* @param {} translation 转场
* @return {}
*/
setCaptionTranslation(translation) {
Module.nvs_compoundCaption_setCaptionTranslation(this.internalObj, translation);
}
/**
* @description 获取字幕平移
* @return {}
*/
getCaptionTranslation() {
return Module.nvs_compoundCaption_getCaptionTranslation(this.internalObj);
}
/**
* @description 平移字幕
* @param {} translationOffset 转场偏移
* @return {}
*/
translateCaption(translationOffset) {
Module.nvs_compoundCaption_translateCaption(this.internalObj, translationOffset);
}
/**
* @description 设置锚点
* @param {} anchor 锚点
* @return {}
*/
setAnchorPoint(anchor) {
Module.nvs_compoundCaption_setAnchorPoint(this.internalObj, anchor);
}
/**
* @description 获取锚点
* @return {}
*/
getAnchorPoint() {
return Module.nvs_compoundCaption_getAnchorPoint(this.internalObj);
}
/**
* @description 设置X方向缩放
* @param {} scale 缩放
* @return {}
*/
setScaleX(scale) {
Module.nvs_compoundCaption_setScaleX(this.internalObj, scale);
}
/**
* @description 获取X方向缩放
* @return {}
*/
getScaleX() {
return Module.nvs_compoundCaption_getScaleX(this.internalObj);
}
/**
* @description 设置Y方向缩放
* @param {} scale 缩放
* @return {}
*/
setScaleY(scale) {
Module.nvs_compoundCaption_setScaleY(this.internalObj, scale);
}
/**
* @description 获取Y方向缩放
* @return {}
*/
getScaleY() {
return Module.nvs_compoundCaption_getScaleY(this.internalObj);
}
/**
* @description 缩放字幕
* @param {} scaleFactor 缩放因子
* @param {} anchor 锚点
* @return {}
*/
scaleCaption(scaleFactor, anchor) {
Module.nvs_compoundCaption_scaleCaption(this.internalObj, scaleFactor, anchor);
}
/**
* @description 设置Z方向旋转
* @param {} angle 角度
* @return {}
*/
setRotationZ(angle) {
Module.nvs_compoundCaption_setRotationZ(this.internalObj, angle);
}
/**
* @description 获取Z方向旋转
* @return {}
*/
getRotationZ() {
return Module.nvs_compoundCaption_getRotationZ(this.internalObj);
}
/**
* @description 旋转字幕
* @param {} angle 角度
* @param {} anchor 锚点
* @return {}
*/
rotateCaption(angle, anchor) {
Module.nvs_compoundCaption_rotateCaption(this.internalObj, angle, anchor);
}
/**
* @description 旋转字幕
* @param {} angle 角度
* @return {}
*/
rotateCaption2(angle) {
var vertices = this.getCompoundBoundingVertices(1);
if (!vertices || vertices.size() !== 4) return;
var cx = 0;
var cy = 0;
for (var i = 0; i < 4; ++i) {
var pt = vertices.get(i);
cx += pt.x;
cy += pt.y;
}
this.rotateCaption(angle, new NvsPointF(cx / 4, cy / 4));
}
/**
* @description 获取字幕边界顶点
* @param {} captionIndex 字幕索引
* @param {} boudingType 边界类型
* @param {} motionParams 运动参数
* @return {}
*/
getCaptionBoundingVertices(captionIndex, boudingType, motionParams) {
return Module.nvs_compoundCaption_getCaptionBoundingVertices(this.internalObj, captionIndex, boudingType, motionParams);
}
/**
* @description 获取组合边界顶点
* @param {} boudingType 边界类型
* @param {} motionParams 运动参数
* @return {}
*/
getCompoundBoundingVertices(boudingType, motionParams) {
return Module.nvs_compoundCaption_getCompoundBoundingVertices(this.internalObj, boudingType, motionParams);
}
/**
* @description 设置Z值
* @param {} value Z值大小
* @return {}
*/
setZValue(value) {
Module.nvs_compoundCaption_setZValue(this.internalObj, value);
}
/**
* @description 获取Z值
* @return {}
*/
getZValue() {
return Module.nvs_compoundCaption_getZValue(this.internalObj);
}
/**
* @description 设置不透明度
* @param {} value 不透明度大小
* @return {}
*/
setOpacity(value) {
Module.nvs_compoundCaption_setOpacity(this.internalObj, value);
}
/**
* @description 获取不透明度
* @return {}
*/
getOpacity() {
return Module.nvs_compoundCaption_getOpacity(this.internalObj);
}
/**
* @description 是否帧字幕
* @param {} captionIndex 字幕索引
* @return {}
*/
isFrameCaption(captionIndex) {
return Module.nvs_compoundCaption_isFrameCaption(this.internalObj, captionIndex);
}
/**
* @description 获取字幕风格包ID
* @return {}
*/
getCaptionStylePackageId() {
return Module.nvs_compoundCaption_getCaptionStylePackageId(this.internalObj);
}
}
/**
* @classdesc 时间线动画贴纸类。时间线动画贴纸是视频编辑时使用的一种美化特效，可以产生动画效果。 用户可以在时间线上添加和移除动画贴纸，也可以通过各种API调整贴纸的各种属性，如位置、大小、显示时间等等。注：动画贴纸在时间线上的入点和出点单位都为微秒。
* @extends NvsFx
*/
class NvsTimelineAnimatedSticker extends NvsFx {
/**
* @constructor
*/
constructor() {
super();
}
/**
* @description 获取入点
* @return {}
*/
getInPoint() {
return Module.nvs_animatedSticker_getInPoint(this.internalObj);
}
/**
* @description 获取出点
* @return {}
*/
getOutPoint() {
return Module.nvs_animatedSticker_getOutPoint(this.internalObj);
}
/**
* @description 改变入点
* @param {} newInPoint 新的入点
* @return {}
*/
changeInPoint(newInPoint) {
return Module.nvs_animatedSticker_changeInPoint(this.internalObj, newInPoint);
}
/**
* @description 改变出点
* @param {} newOutPoint 新的出点
* @return {}
*/
changeOutPoint(newOutPoint) {
return Module.nvs_animatedSticker_changeOutPoint(this.internalObj, newOutPoint);
}
/**
* @description 移动位置
* @param {} offset 偏移量
* @return {}
*/
movePosition(offset) {
Module.nvs_animatedSticker_movePosition(this.internalObj, offset);
}
/**
* @description 设置转场
* @param {} translation 转场
* @return {}
*/
setTranslation(translation) {
Module.nvs_animatedSticker_setTranslation(this.internalObj, translation);
}
/**
* @description 获取转场
* @return {}
*/
getTranslation() {
return Module.nvs_animatedSticker_getTranslation(this.internalObj);
}
/**
* @description 转场动画贴纸
* @param {} translationOffset 转场偏移量
* @return {}
*/
translateAnimatedSticker(translationOffset) {
Module.nvs_animatedSticker_translateAnimatedSticker(this.internalObj, translationOffset);
}
/**
* @description 设置缩放
* @param {} scale 缩放值
* @return {}
*/
setScale(scale) {
Module.nvs_animatedSticker_setScale(this.internalObj, scale);
}
/**
* @description 获取缩放
* @return {}
*/
getScale() {
return Module.nvs_animatedSticker_getScale(this.internalObj);
}
/**
* @description 缩放动画贴纸
* @param {} scaleFactor 缩放因子
* @param {} anchor 锚点
* @return {}
*/
scaleAnimatedSticker(scaleFactor, anchor) {
Module.nvs_animatedSticker_scaleAnimatedSticker(this.internalObj, scaleFactor, anchor);
}
/**
* @description 缩放动画贴纸
* @param {} scaleFactor 缩放因子
* @return {}
*/
scaleAnimatedSticker2(scaleFactor) {
var left, right, top, bottom;
var list = this.getBoundingRectangleVertices();
var point = list.get(0);
left = right = point.x;
top = bottom = point.y;
for (var i = 1; i < 4; i++) {
point = list.get(i);
if (point.x < left)
left = point.x;
else if (point.x > right)
right = point.x;
if (point.y < bottom)
bottom = point.y;
else if (point.y > top)
top = point.y;
}
this.scaleAnimatedSticker(scaleFactor, new NvsPointF((left + right) / 2, (top + bottom) / 2));
}
/**
* @description 设置Z方向旋转
* @param {} angle 角度
* @return {}
*/
setRotationZ(angle) {
Module.nvs_animatedSticker_setRotationZ(this.internalObj, angle);
}
/**
* @description 获取Z方向旋转
* @return {}
*/
getRotationZ() {
return Module.nvs_animatedSticker_getRotationZ(this.internalObj);
}
/**
* @description 旋转动画贴纸
* @param {} angle 角度
* @param {} anchor 锚点
* @return {}
*/
rotateAnimatedSticker(angle, anchor) {
Module.nvs_animatedSticker_rotateAnimatedSticker(this.internalObj, angle, anchor);
}
/**
* @description 旋转动画贴纸
* @param {} angle 角度
* @return {}
*/
rotateAnimatedSticker2(angle) {
var left, right, top, bottom;
var list = this.getBoundingRectangleVertices();
var point = list.get(0);
left = right = point.x;
top = bottom = point.y;
for (var i = 1; i < 4; i++) {
point = list.get(i);
if (point.x < left)
left = point.x;
else if (point.x > right)
right = point.x;
if (point.y < bottom)
bottom = point.y;
else if (point.y > top)
top = point.y;
}
this.rotateAnimatedSticker(angle, new NvsPointF((left + right) / 2, (top + bottom) / 2));
}
/**
* @description 设置水平翻转
* @param {} flip 翻转
* @return {}
*/
setHorizontalFlip(flip) {
Module.nvs_animatedSticker_setHorizontalFlip(this.internalObj, flip);
}
/**
* @description 获取水平翻转
* @return {}
*/
getHorizontalFlip() {
return Module.nvs_animatedSticker_getHorizontalFlip(this.internalObj);
}
/**
* @description 设置垂直翻转
* @param {} flip 翻转
* @return {}
*/
setVerticalFlip(flip) {
Module.nvs_animatedSticker_setVerticalFlip(this.internalObj, flip);
}
/**
* @description 获取垂直翻转
* @return {}
*/
getVerticalFlip() {
return Module.nvs_animatedSticker_getVerticalFlip(this.internalObj);
}
/**
* @description 获取边界矩形顶点
* @return {}
*/
getBoundingRectangleVertices() {
return Module.nvs_animatedSticker_getBoundingRectangleVertices(this.internalObj);
}
/**
* @description 获取动画贴纸包ID
* @return {}
*/
getAnimatedStickerPackageId() {
return Module.nvs_animatedSticker_getAnimatedStickerPackageId(this.internalObj);
}
/**
* @description 设置Z值
* @param {} value Z值大小
* @return {}
*/
setZValue(value) {
Module.nvs_animatedSticker_setZValue(this.internalObj, value);
}
/**
* @description 获取Z值
* @return {}
*/
getZValue() {
return Module.nvs_animatedSticker_getZValue(this.internalObj);
}
/**
* @description 是否是音频
* @return {}
*/
hasAudio() {
return Module.nvs_animatedSticker_hasAudio(this.internalObj);
}
/**
* @description 设置音量增益
* @param {} leftVolumeGain 左音量增益
* @param {} rightVolumeGain 右音量增益
* @return {}
*/
setVolumeGain(leftVolumeGain, rightVolumeGain) {
Module.nvs_animatedSticker_setVolumeGain(this.internalObj, leftVolumeGain, rightVolumeGain);
}
/**
* @description 获取音量增益
* @return {}
*/
getVolumeGain() {
return Module.nvs_animatedSticker_getVolumeGain(this.internalObj);
}
/**
* @description 设置不透明度
* @param {} opacity 不透明度值
* @return {}
*/
setOpacity(opacity) {
Module.nvs_animatedSticker_setOpacity(this.internalObj, opacity);
}
/**
* @description 获取不透明度
* @return {}
*/
getOpacity() {
return Module.nvs_animatedSticker_getOpacity(this.internalObj);
}
/**
* @description 设置当前关键帧时间
* @param {} time 时间
* @return {}
*/
setCurrentKeyFrameTime(time) {
Module.nvs_animatedSticker_setCurrentKeyFrameTime(this.internalObj, time);
}
}
/**
* @classdesc 视频转场，片段间切换的特效。轨道上有多个片段，转场是从一个视频片段播放到另一个视频片段的衔接过渡效果，而在有间隙的片段之间不能添加视频转场。目前支持多种视频转场， 包括Fade(淡入淡出)、Turning(翻转)、Swap(层叠)、Stretch In(伸展进入)、Page Curl(卷页)、Lens Flare(镜头眩光)、Star(星形)、Dip To Black(闪黑)、Dip To White(闪白)、 Push To Right(右推拉)、Push To Top(上推拉)、Upper Left Into(斜推)。每种视频转场都可通过视频轨道(NvsVideoTrack)来设置和获取。默认转场是Fade(淡入淡出)。
* @extends NvsFx
*/
class NvsVideoTransition extends NvsFx {
/**
* @constructor
*/
constructor() {
super();
}
/**
* @description 获取视频转场类型
* @return {}
*/
getVideoTransitionType() {
return Module.nvs_videoTransition_getVideoTransitionType(this.internalObj);
}
/**
* @description 获取内置视频转场名字
* @return {}
*/
getBuiltinVideoTransitionName() {
return Module.nvs_videoTransition_getBuiltinVideoTransitionName(this.internalObj);
}
/**
* @description 获取视频转场包ID
* @return {}
*/
getVideoTransitionPackageId() {
return Module.nvs_videoTransition_getVideoTransitionPackageId(this.internalObj);
}
/**
* @description 设置视频转场持续时间
* @param {} duration 持续时间
* @param {} matchMode 比较模式
* @return {}
*/
setVideoTransitionDuration(duration, matchMode) {
return Module.nvs_videoTransition_setVideoTransitionDuration(this.internalObj, duration, matchMode);
}
/**
* @description 获取视频转场持续时间
* @return {}
*/
getVideoTransitionDuration() {
return Module.nvs_videoTransition_getVideoTransitionDuration(this.internalObj);
}
}
/**
* @classdesc 音频转场,音频片段间切换的特效。一般通过音频轨道(Audio Track)来设置和获取音频转场。目前默认音频转场是淡入淡出转场(fade)。
* @extends NvsFx
*/
class NvsAudioTransition extends NvsFx {
/**
* @constructor
*/
constructor() {
super();
}
}
/**
* @classdesc 视频特效。视频特效是显示在视频片段上的特效，能够改变视频图像整体或者局部的颜色、亮度、透明度等，使视频显示出特殊的效果。在视频片段(Video Clip)上，可以添加、移除、获取多个视频特效。
* @extends NvsFx
*/
class NvsVideoFx extends NvsFx {
/**
* @constructor
*/
constructor() {
super();
}
/**
* @description 获取视频特效类型
* @return {}
*/
getVideoFxType() {
return Module.nvs_videoFx_getVideoFxType(this.internalObj);
}
/**
* @description 获取视频特效索引
* @return {}
*/
getIndex() {
return Module.nvs_videoFx_getIndex(this.internalObj);
}
/**
* @description 获取内置视频特效名字
* @return {}
*/
getBuiltinVideoFxName() {
return Module.nvs_videoFx_getBuiltinVideoFxName(this.internalObj);
}
/**
* @description 获取视频特效包ID
* @return {}
*/
getVideoFxPackageId() {
return Module.nvs_videoFx_getVideoFxPackageId(this.internalObj);
}
/**
* @description 将点从规范映射到粒子系统
* @param {} ptCanonical
* @return {}
*/
mapPointFromCanonicalToParticleSystem(ptCanonical) {
return Module.nvs_videoFx_mapPointFromCanonicalToParticleSystem(this.internalObj, ptCanonical);
}
}
/**
* @classdesc 音频特效。音频特效是叠加显示在音频片段上的特效，可以改变音频片段的声调和速率。获取音频片段(Audio Clip)对象实例后，根据需要来添加或者移除多个音频特效。
* @extends NvsFx
*/
class NvsAudioFx extends NvsFx {
/**
* @constructor
*/
constructor() {
super();
}
/**
* @description 获取音频特效索引
* @return {}
*/
getIndex() {
return Module.nvs_audioFx_getIndex(this.internalObj);
}
/**
* @description 获取内置音频特效名字
* @return {}
*/
getBuiltinAudioFxName() {
return Module.nvs_audioFx_getBuiltinAudioFxName(this.internalObj);
}
}
/**
* @classdesc 参数信息对象类
*/
class NvsParamInfoObject {
/**
* @constructor
*/
constructor() {
this.paramName = '';
this.paramType = '';
this.intDefVal = 0;
this.intMinVal = 0;
this.intMaxVal = 0;
this.floatDefVal = 0;
this.floatMinVal = 0;
this.floatMaxVal = 0;
this.boolDefVal = false;
this.colorDefR = 0;
this.colorDefG = 0;
this.colorDefB = 0;
this.colorDefA = 0;
this.stringType = 0;
this.stringDef = '';
}
}
/**
* @classdesc 特效参数描述类。在视频拍摄和编辑时会设置各种不同参数类型的特效，特效参数描述类就是专门用来获取各种特效参数值的，以便查看和了解。
*/
class NvsFxDescription {
/**
* @constructor
*/
constructor() {
this.internalObj = 0;
}
/**
* @description 获取名字
* @return {}
*/
getName() {
return Module.nvs_fxDescription_getName(this.internalObj);
}
/**
* @description 获取所有参数信息
* @return {}
*/
getAllParamsInfo() {
return Module.nvs_fxDescription_getAllParamsInfo(this.internalObj);
}
}
/**
* @classdesc 粒子特效上下文 粒子系统的由若干粒子发生器和子粒子发生器构成。粒子发生器会随着时间推移不断发射出粒子，而子粒子发生器则会在粒子发生器发射出的粒子上面发射出粒子。
*/
class NvsParticleSystemContext {
/**
* @constructor
*/
constructor() {
this.contextInterface = 0;
}
/**
* @description 设置发射器启用
* @param {} emitterName 发射器名称
* @param {} enable 启动标记
* @return {}
*/
setEmitterEnabled(emitterName, enable) {
Module.nvs_particleSystemContext_setEmitterEnabled(this.contextInterface, emitterName, enable);
}
/**
* @description 设置发射器位置
* @param {} emitterName 发射器名称
* @param {} emitterPositionX 发射器位置X坐标
* @param {} emitterPositionY 发射器位置Y坐标
* @return {}
*/
setEmitterPosition(emitterName, emitterPositionX, emitterPositionY) {
Module.nvs_particleSystemContext_setEmitterPosition(this.contextInterface, emitterName, emitterPositionX, emitterPositionY);
}
/**
* @description 将位置附加到发射器位置曲线
* @param {} emitterName 发射器名称
* @param {} timeSec
* @param {} emitterPositionX
* @param {} emitterPositionY
* @return {}
*/
appendPositionToEmitterPositionCurve(emitterName, timeSec, emitterPositionX, emitterPositionY) {
Module.nvs_particleSystemContext_appendPositionToEmitterPositionCurve(this.contextInterface, emitterName, timeSec, emitterPositionX, emitterPositionY);
}
/**
* @description 设置发射器速率增益
* @param {} emitterName 发射器名称
* @param {} emitterGain 发和气增益
* @return {}
*/
setEmitterRateGain(emitterName, emitterGain) {
Module.nvs_particleSystemContext_setEmitterRateGain(this.contextInterface, emitterName, emitterGain);
}
/**
* @description 设置发射粒子大小增益
* @param {} emitterName 发射器名称
* @param {} emitterGain 发射器增益
* @return {}
*/
setEmitterParticleSizeGain(emitterName, emitterGain) {
Module.nvs_particleSystemContext_setEmitterParticleSizeGain(this.contextInterface, emitterName, emitterGain);
}
}
/**
* @classdesc ARScene 操作。
*/
class NvsARSceneManipulate {
/**
* @constructor
*/
constructor() {
this.contextInterface = 0;
}
/**
* @description 设置检测模式
* @param {} mode 检测模式
* @return {}
*/
setDetectionMode(mode) {
Module.nvs_arSceneManipulate_setDetectionMode(this.contextInterface, mode);
}
}
/**
* @description 使用模板
*/
const NvsParticleTypeEnum = Object.freeze({
"PARTICLE_TYPE_NORMAL" : 0,
"PARTICLE_TYPE_TOUCH" : 1,
"PARTICLE_TYPE_GESTURE" : 2,
"PARTICLE_TYPE_EYE" : 3,
"PARTICLE_TYPE_MOUTH" : 4});
/**
* @description 使用模板
*/
const NvsEmitterPlaceEnum = Object.freeze({
"EMITTER_PLACE_LEFT" : 0,
"EMITTER_PLACE_RIGHT" : 1,
"EMITTER_PLACE_TOP" : 2,
"EMITTER_PLACE_BOTTOM" : 3,
"EMITTER_PLACE_CENTER" : 4});
/**
* @classdesc 粒子发生器描述文件类。包含该粒子发生器放置的位置以及其子粒子发生器名称列表
*/
class NvsParticleEmitterDesc {
constructor() {
this.emitterPlace = NvsEmitterPlaceEnum.EMITTER_PLACE_CENTER;
this.emitterNames = [];
}
}
/**
* @classdesc 粒子特效包解析类
*/
class NvsAssetPackageParticleDescParser {
/**
* @constructor
* @param {} fxDescription
*/
constructor(fxDescription) {
this.particleType = NvsParticleTypeEnum.PARTICLE_TYPE_NORMAL;
this.emitters = [];
var fxDescobj = JSON.parse(fxDescription);
if (typeof(fxDescobj.particleType) !== 'undefined') {
if (fxDescobj.particleType === 'touch') {
this.particleType = NvsParticleTypeEnum.PARTICLE_TYPE_TOUCH
} else if (fxDescobj.particleType === 'gesture') {
this.particleType = NvsParticleTypeEnum.PARTICLE_TYPE_GESTURE
} else if (fxDescobj.particleType === 'eye') {
this.particleType = NvsParticleTypeEnum.PARTICLE_TYPE_EYE
} else if (fxDescobj.particleType === 'mouth') {
this.particleType = NvsParticleTypeEnum.PARTICLE_TYPE_MOUTH
}
}
var array = fxDescobj.emitterDesc;
for (var i = 0; i < array.length; i++) {
var emitterDesc = array[i];
var placeDesc = new NvsParticleEmitterDesc();
placeDesc.emitterPlace = NvsEmitterPlaceEnum.EMITTER_PLACE_CENTER;
if (typeof(emitterDesc.place) !== 'undefined') {
if (emitterDesc.place === 'left') {
placeDesc.emitterPlace = NvsEmitterPlaceEnum.EMITTER_PLACE_LEFT;
} else if (emitterDesc.place === 'right') {
placeDesc.emitterPlace = NvsEmitterPlaceEnum.EMITTER_PLACE_RIGHT;
} else if (emitterDesc.place === 'top') {
placeDesc.emitterPlace = NvsEmitterPlaceEnum.EMITTER_PLACE_TOP;
} else if (emitterDesc.place === 'bottom') {
placeDesc.emitterPlace = NvsEmitterPlaceEnum.EMITTER_PLACE_BOTTOM;
}
}
if (typeof(emitterDesc.emitterName) !== 'undefined') {
var emitterNames = emitterDesc.emitterName;
for (var j = 0; j < emitterNames.length; j++) {
var name = emitterNames[j];
placeDesc.emitterNames.push(name);
}
}
this.emitters.push(placeDesc);
}
}
/**
* @description 获取粒子分区发射器
* @param {} partitionIndex 分区索引
* @return {}
*/
getParticlePartitionEmitter(partitionIndex) {
if (partitionIndex >= this.emitters.length)
return undefined;
var emitterDesc = this.emitters[partitionIndex];
return emitterDesc.emitterNames;
}
}
/**
* @classdesc 视频流信息
*/
class NvsVideoStreamInfo {
/**
* @constructor
*/
constructor() {
this.width = 0;
this.height = 0;
this.duration = 0;
this.frameRate = new NvsRational(0, 0);
this.pixelAspectRatio = new NvsRational(1, 1);
this.codecType = 0;
this.rotation = 0;
}
}
/**
* @classdesc 音频流信息
*/
class NvsAudioStreamInfo {
/**
* @constructor
*/
constructor() {
this.channelCount = 0;
this.sampleRate = 0;
this.duration = 0;
}
}
/**
* @classdesc 音视频文件信息。显示音视频文件的信息，包括音视频文件的时长，数据速率，像素横纵比，音视频流数目等。
*/
class NvsAVFileInfo {
/**
* @constructor
*/
constructor() {
this.duration = 0;
this.videoStreamInfo = undefined;
this.audioStreamInfo = [];
}
}
/**
* @classdesc 播放速率控制区域
*/
class NvsPlaybackRateControlRegion {
/**
* @constructor
*/
constructor() {
this.startTime = 0;
this.endTime = 0;
this.playbackRate = 1;
this.audioGain = 1;
}
}
/**
* @classdesc XML流书写类
*/
class NvsXmlStreamWriter {
/**
* @constructor
* @param {} filePath 文件路径
*/
constructor(filePath) {
this.filePath = filePath;
}
/**
* @description 打开书写器
* @return {}
*/
open() {
return Module.nvs_xmlStreamWriter_open(this.filePath);
}
/**
* @description 关闭，释放资源
* @return {}
*/
close() {
return Module.nvs_xmlStreamWriter_close(this.filePath);
}
/**
* @description 写开始文档
* @return {}
*/
writeStartDocument() {
return Module.nvs_xmlStreamWriter_writeStartDocument(this.filePath);
}
/**
* @description 写结束文档
* @return {}
*/
writeEndDocument() {
return Module.nvs_xmlStreamWriter_writeEndDocument(this.filePath);
}
/**
* @description 写开始元素
* @param {} element 开始元素
* @return {}
*/
writeStartElement(element) {
return Module.nvs_xmlStreamWriter_writeStartElement(this.filePath, element);
}
/**
* @description 写结束元素
* @param {}
* @param {}
* @return {}
*/
writeEndElement() {
return Module.nvs_xmlStreamWriter_writeEndElement(this.filePath);
}
/**
* @description 根据属性名字，设置属性值
* @param {} name 属性名字
* @param {} value 属性值
* @return {}
*/
writeAttribute(name, value) {
return Module.nvs_xmlStreamWriter_writeAttribute(this.filePath, name, value)
}
/**
* @description DTD书写
* @param {} dtd
* @return {}
*/
writeDTD(dtd) {
return Module.nvs_xmlStreamWriter_writeDTD(this.filePath, dtd)
}
/**
* @description 写文本元素
* @param {} name 元素名字
* @param {} text 元素值
* @return {}
*/
writeTextElement(name, text) {
return Module.nvs_xmlStreamWriter_writeTextElement(this.filePath, name, text)
}
}
/**
* @classdesc 读XML流
*/
class NvsXmlStreamReader {
/**
* @constructor
* @param {} filePath
*/
constructor(filePath) {
this.filePath = filePath;
}
/**
* @description 打开流阅读器
* @return {}
*/
open() {
return Module.nvs_xmlStreamReader_open(this.filePath);
}
/**
* @description 关闭，是否资源
* @return {}
*/
close() {
return Module.nvs_xmlStreamReader_close(this.filePath);
}
/**
* @description 获取结束点
* @return {}
*/
atEnd() {
return Module.nvs_xmlStreamReader_atEnd(this.filePath);
}
/**
* @description 是否有错误
* @return {}
*/
hasError() {
return Module.nvs_xmlStreamReader_hasError(this.filePath);
}
/**
* @description 读取下一个
* @return {}
*/
readNext() {
return Module.nvs_xmlStreamReader_readNext(this.filePath);
}
/**
* @description 读取下一个开始元素
* @return {}
*/
readNextStartElement() {
return Module.nvs_xmlStreamReader_readNextStartElement(this.filePath);
}
/**
* @description 获取读取器名字
* @return {}
*/
name() {
return Module.nvs_xmlStreamReader_name(this.filePath);
}
/**
* @description 是否是文档开始
* @return {}
*/
isStartDocument() {
return Module.nvs_xmlStreamReader_isStartDocument(this.filePath)
}
/**
* @description 是否是文档结束
* @return {}
*/
isEndDocument() {
return Module.nvs_xmlStreamReader_isEndDocument(this.filePath)
}
/**
* @description 是否是开始元素
* @return {}
*/
isStartElement() {
return Module.nvs_xmlStreamReader_isStartElement(this.filePath)
}
/**
* @description 是否是结束元素
* @return {}
*/
isEndElement() {
return Module.nvs_xmlStreamReader_isEndElement(this.filePath)
}
/**
* @description 根据属性名字，获取属性值
* @param {} attributeName 属性名字
* @return {}
*/
getAttributeValue(attributeName) {
return Module.nvs_xmlStreamReader_getAttributeValue(this.filePath, attributeName)
}
}
/**
* @classdesc 音频文件写入器
*/
class NvsAudioFileWriter {
/**
* @constructor
* @param {} sampleRate 采样率
* @param {} channelCount 通道数
* @param {} outputAudioFilePath 输出音频文件路径
*/
constructor(sampleRate, channelCount, outputAudioFilePath) {
this.internalObj = 0;
Module.nvs_audioFileWriter_init(this, sampleRate, channelCount, outputAudioFilePath);
}
/**
* @description 设置内部对象
* @param {} obj 内置对象
* @return {}
*/
setInternalObject(obj) {
this.internalObj = obj;
}
/**
* @description 获取内部对象
* @return {}
*/
getInternalObject() {
return this.internalObj;
}
/**
* @description 写音频数据
* @param {} audioData 音频数据
* @return {}
*/
writeAudioData(audioData) {
return Module.nvs_audioFileWriter_writeAudioData(this, audioData);
}
/**
* @description 关闭。您必须调用 close() 来生成最终的音频文件并释放 wasm 持有的资源！
* @return {}
*/
// NOTE: You must call close() to generate the final audio file and release resources hold by wasm!
close() {
return Module.nvs_audioFileWriter_close(this);
}
}
/**
* @description 使用模板
*/
const NvsFootageTypeEnum = Object.freeze({
"VideoImage" : 0,
"Video" : 1,
"Image" : 2,
"Audio" : 3});
/**
* @classdesc 模板资源包里footage对应的片段信息
*/
class NvsTemplateFootageCorrespondingClipInfo {
/**
* @constructor
*/
constructor() {
this.trackIndex = 0;
this.clipIndex = 0;
}
}
/**
* @classdesc 模板资源包里footage信息(TEIMPLATE_FOOTAGE_TYPE)
*/
class NvsTemplateFootageDesc {
/**
* @constructor
*/
constructor() {
this.id = '';
this.type = 0;
this.canReplace = false;
this.name = '';
this.tags = [];
this.correspondingClipInfos = [];
}
}
/**
* @classdesc 模板资源包里footage对应的字幕信息
*/
class NvsTemplateCaptionDesc {
/**
* @constructor
*/
constructor() {
this.replaceId = 0;
this.text = '';
this.fontFamily = '';
}
}
/**
* @classdesc 模板资源包里footage对应的组合字幕信息
*/
class NvsTemplateCompoundCaptionItemDesc {
/**
* @constructor
*/
constructor() {
this.index = 0;
this.text = '';
this.fontFamily = '';
}
}
/**
* @classdesc 模板资源包里footage包含的全部组合字幕信息
*/
class NvsTemplateCompoundCaptionDesc {
/**
* @constructor
*/
constructor() {
this.replaceId = 0;
this.itemList = [];
}
}
function nvsInitClasses() {
Module.Meishe.classMap = {
NvsSdkVersion,
NvsRational,
NvsVideoResolution,
NvsAudioResolution,
NvsLiveWindow,
NvsAIToningInfo,
NvsStreamingContext,
NvsProjObj,
NvsTimeline,
NvsTrack,
NvsVideoTrack,
NvsAudioTrack,
NvsClip,
NvsVideoClip,
NvsAudioClip,
NvsPanAndScan,
NvsVolume,
NvsColor,
NvsPointF,
NvsRectF,
NvsWatermarkInfo,
NvsAssetPackageManager,
NvsRegionInfo,
NvsFx,
NvsTimelineVideoFx,
NvsTimelineCaption,
NvsMotionParameters,
NvsTimelineCompoundCaption,
NvsTimelineAnimatedSticker,
NvsVideoTransition,
NvsAudioTransition,
NvsVideoFx,
NvsAudioFx,
NvsParamInfoObject,
NvsFxDescription,
NvsParticleSystemContext,
NvsARSceneManipulate,
NvsVideoStreamInfo,
NvsAudioStreamInfo,
NvsAVFileInfo,
NvsPlaybackRateControlRegion,
NvsTemplateFootageCorrespondingClipInfo,
NvsTemplateFootageDesc,
NvsTemplateCaptionDesc
};
Module.Meishe.getClassByName = function(className) {
return Module.Meishe.classMap[className];
}
}