大牛直播SDK
Android平台除RTMP、RTSP直播播放外，有些场景可输出编码后（视频：H.264/H.265，音频：AAC/PCMA/PCMU）的数据，比如无人机或类似智能硬件设备，回调出来的H.264/H.265数据，编码后的H.264/H.265数据除了正常转推到RTMP、轻量级RTSP服务或GB28181外，还需要本地预览甚至对数据做二次处理（视频分析、实时水印字符叠加等），大概流程如下：
基于这样的场景诉求，我们开发了Android平台外部编码数据实时预览播放模块（以RTSP拉流，然后回调上来编码后数据，再投递到Android平台编码数据实时预览播放SDK为例）。
Android平台外部编码数据实时预览模块可实现本地低延迟的预览播放，支持软解码和特定机型硬解码，支持等比例或铺满显示，感兴趣的开发者可参看：Android平台外部编码数据(H264/H265/AAC/PCMA/PCMU)实时预览播放技术实现
电网视频监控系统是智能电网的一个重要组成部分，广泛应用于电网的建设、生产、运行、经营等方面。由于视频监控系统在不同的建设时期选用了不同的技术和不同厂家的产品，导致了标准不统一、技术路线不一致。目前国家电网公司智能电网建设，对视频监控系统提出了新的要求，因此实现统一监控、统一存储、分级控制、分域管理，使不同的视频监视系统能够互联互通，满足视频监控系统全局化、整体化的发展需求，已成为亟待解决的问题。
为此，大牛直播SDK推出的Android平台国网B接口接入SDK，可实现不具备国网B接口音视频能力的 Android终端，通过平台注册接入到现有的平台。
Android终端除支持常规的音视频数据接入外，还可以支持移动设备位置(MobilePosition)订阅和通知、语音广播，支持对接数据类型如下：
大牛直播SDK推出的Android平台GB28181接入SDK，可实现不具备国标音视频能力的 Android终端，通过平台注册接入到现有的GB/T28181—2016服务，可用于如执法记录仪、智能安全帽、智能监控、智慧零售、智慧教育、远程办公、明厨亮灶、智慧交通、智慧工地、雪亮工程、平安乡村、生产运输、车载终端等场景。
Android终端除支持常规的音视频数据接入外，还可以支持移动设备位置(MobilePosition)订阅和通知、语音广播和语音对讲，支持对接数据类型如下：
除了Windows/Linux/Android/iOS Native SDK，大牛直播SDK发布了Unity环境下的RTMP推流（Windows平台+Linux平台+Android平台）和RTMP|RTSP拉流（Windows、Linux、Android和iOS平台全覆盖）低延迟的解决方案。
目前，大牛直播SDK的Unity3D环境下，已覆盖以下SDK：
Unity环境下，不管是camera还是窗体数据也好，主要是高效率的拿到原始数据，采集端可用的数据格式是RGB的，拿到之后，通过高效率的数据传递，发给封装后的原生SDK，完成数据编码和RTMP推送。
需要注意的地方有几点：
1. 数据采集投递，确保高效率；
2. 屏幕分辨率发生变化，可实时适配；
3. Unity和原生SDK之间通信，比如event回调等；
4. 屏幕数据如有水平或垂直翻转，需要有一定的矫正。
Unity环境下RTMP或RTSP直播播放我们前几年就有发布，并已应用在好多传统行业领域，比如教育或工业仿真或一些低延迟的控制场景。
相关实现逻辑如下：
1. Native RTSP或RTSP直播播放SDK回调RGB/YUV420/NV12等其中的一种未压缩的图像格式；
2. Unity3D创建相应的RGB/YUV420等Shader；
3.Unity3D从各个平台获取图像数据来填充纹理即可；
需要注意的有几点：
1. 多实例支持：播放端和推送不一样，比如智慧城市，播放端有多路场景，所以多实例支持是必备功能，多实例环境下，需要能有好的区分event状态回调等；
2. 尽可能高效率的数据传递，确保资源占有最小化；
3. 视频分辨率变化后，能自动适配；
4. Unity和原生SDK之间通信，比如event回调等；
5. 长时间运行稳定性。
Unity3d RTSP/RTMP直播播放端SDK视频演示1
Unity3d RTSP/RTMP直播播放端SDK视频演示2
Windows平台Unity3d下如何同时播放多路RTSP或RTMP流
Windows平台实现Unity下窗体|摄像头|屏幕采集推送
随着Unity3D的应用范围越来越广，越来越多的行业开始基于Unity3D开发产品，如传统行业中虚拟仿真教育、航空工业、室内设计、城市规划、工业仿真等领域。
基于此，好多开发者苦于在Unity环境下，没有低延迟的推拉流解决方案，前几年，我们在Unity环境下推出了跨平台低延迟的RTMP|RTSP直播播放器，很好的解决了好多对延迟要求苛刻的使用场景。
随着时间的推移，越来越多的开发者联系我们，希望我们能推出Unity环境下的RTMP推送模块，获取到unity的实时数据，更低延迟更高效率的实现数据传输推送，基于此，我们发布了Unity环境下的RTMP推送模块。
本文以Windows平台为例，数据源分别为Unity的窗口、摄像头或整个屏幕，编码传输模块，还是调用大牛直播SDK（官方）的原生接口，简单界面先睹为快：
private bool InitSDK()
{
if (!is_pusher_sdk_init_)
{
// 设置日志路径(请确保目录存在)
String log_path = "D:\\pulisherlog";
NTSmartLog.NT_SL_SetPath(log_path);
UInt32 isInited = NTSmartPublisherSDK.NT_PB_Init(0, IntPtr.Zero);
if (isInited != 0)
{
Debug.Log("调用NT_PB_Init失败..");
return false;
}
is_pusher_sdk_init_ = true;
}
return true;
}
public bool OpenPublisherHandle(uint video_option, uint audio_option)
{
if (publisher_handle_ != IntPtr.Zero)
{
return true;
}
publisher_handle_count_ = 0;
if (NTBaseCodeDefine.NT_ERC_OK != NTSmartPublisherSDK.NT_PB_Open(out publisher_handle_,
video_option, audio_option, 0, IntPtr.Zero))
{
return false;
}
if (publisher_handle_ != IntPtr.Zero)
{
pb_event_call_back_ = new NT_PB_SDKEventCallBack(PbEventCallBack);
NTSmartPublisherSDK.NT_PB_SetEventCallBack(publisher_handle_, IntPtr.Zero, pb_event_call_back_);
return true;
}
else
{
return false;
}
}
这里需要注意下，如果要采集unity窗口，需要设置图层模式，先填充一层RGBA黑色背景，然后再添加一层，用于叠加外部数据。
private void SetCommonOptionToPublisherSDK()
{
if (!IsPublisherHandleAvailable())
{
Debug.Log("SetCommonOptionToPublisherSDK, publisher handle with null..");
return;
}
NTSmartPublisherSDK.NT_PB_ClearLayersConfig(publisher_handle_, 0,
0, IntPtr.Zero);
if (video_option == NTSmartPublisherDefine.NT_PB_E_VIDEO_OPTION.NT_PB_E_VIDEO_OPTION_LAYER)
{
// 第0层填充RGBA矩形, 目的是保证帧率, 颜色就填充全黑
int red = 0;
int green = 0;
int blue = 0;
int alpha = 255;
NT_PB_RGBARectangleLayerConfig rgba_layer_c0 = new NT_PB_RGBARectangleLayerConfig();
rgba_layer_c0.base_.type_ = (Int32)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_RGBA_RECTANGLE;
rgba_layer_c0.base_.index_ = 0;
rgba_layer_c0.base_.enable_ = 1;
rgba_layer_c0.base_.region_.x_ = 0;
rgba_layer_c0.base_.region_.y_ = 0;
rgba_layer_c0.base_.region_.width_ = video_width_;
rgba_layer_c0.base_.region_.height_ = video_height_;
rgba_layer_c0.base_.offset_ = Marshal.OffsetOf(rgba_layer_c0.GetType(), "base_").ToInt32();
rgba_layer_c0.base_.cb_size_ = (uint)Marshal.SizeOf(rgba_layer_c0);
rgba_layer_c0.red_ = System.BitConverter.GetBytes(red)[0];
rgba_layer_c0.green_ = System.BitConverter.GetBytes(green)[0];
rgba_layer_c0.blue_ = System.BitConverter.GetBytes(blue)[0];
rgba_layer_c0.alpha_ = System.BitConverter.GetBytes(alpha)[0];
IntPtr rgba_conf = Marshal.AllocHGlobal(Marshal.SizeOf(rgba_layer_c0));
Marshal.StructureToPtr(rgba_layer_c0, rgba_conf, true);
UInt32 rgba_r = NTSmartPublisherSDK.NT_PB_AddLayerConfig(publisher_handle_, 0,
rgba_conf, (int)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_RGBA_RECTANGLE,
0, IntPtr.Zero);
Marshal.FreeHGlobal(rgba_conf);
NT_PB_ExternalVideoFrameLayerConfig external_layer_c1 = new NT_PB_ExternalVideoFrameLayerConfig();
external_layer_c1.base_.type_ = (Int32)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_EXTERNAL_VIDEO_FRAME;
external_layer_c1.base_.index_ = 1;
external_layer_c1.base_.enable_ = 1;
external_layer_c1.base_.region_.x_ = 0;
external_layer_c1.base_.region_.y_ = 0;
external_layer_c1.base_.region_.width_ = video_width_;
external_layer_c1.base_.region_.height_ = video_height_;
external_layer_c1.base_.offset_ = Marshal.OffsetOf(external_layer_c1.GetType(), "base_").ToInt32();
external_layer_c1.base_.cb_size_ = (uint)Marshal.SizeOf(external_layer_c1);
IntPtr external_layer_conf = Marshal.AllocHGlobal(Marshal.SizeOf(external_layer_c1));
Marshal.StructureToPtr(external_layer_c1, external_layer_conf, true);
UInt32 external_r = NTSmartPublisherSDK.NT_PB_AddLayerConfig(publisher_handle_, 0,
external_layer_conf, (int)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_EXTERNAL_VIDEO_FRAME,
0, IntPtr.Zero);
Marshal.FreeHGlobal(external_layer_conf);
}
else if (video_option == NTSmartPublisherDefine.NT_PB_E_VIDEO_OPTION.NT_PB_E_VIDEO_OPTION_CAMERA)
{
CameraInfo camera = cameras_[cur_sel_camera_index_];
NT_PB_VideoCaptureCapability cap = camera.capabilities_[cur_sel_camera_resolutions_index_];
SetVideoCaptureDeviceBaseParameter(camera.id_.ToString(), (UInt32)cap.width_, (UInt32)cap.height_);
}
SetFrameRate((UInt32)CalBitRate(edit_key_frame_, video_width_, video_height_));
Int32 type = 0; //软编码
Int32 encoder_id = 1;
UInt32 codec_id = (UInt32)NTCommonMediaDefine.NT_MEDIA_CODEC_ID.NT_MEDIA_CODEC_ID_H264;
Int32 param1 = 0;
SetVideoEncoder(type, encoder_id, codec_id, param1);
SetVideoQualityV2(CalVideoQuality(video_width_, video_height_, is_h264_encoder));
SetVideoMaxBitRate((CalMaxKBitRate(edit_key_frame_, video_width_, video_height_, false)));
SetVideoKeyFrameInterval((edit_key_frame_));
if (is_h264_encoder)
{
SetVideoEncoderProfile(1);
}
SetVideoEncoderSpeed(CalVideoEncoderSpeed(video_width_, video_height_, is_h264_encoder));
// 音频相关设置
SetAuidoInputDeviceId(0);
SetPublisherAudioCodecType(1);
SetPublisherMute(is_mute);
SetEchoCancellation(0, 0);
SetNoiseSuppression(0);
SetAGC(0);
SetVAD(0);
SetInputAudioVolume(Convert.ToSingle(edit_audio_input_volume_));
}
摄像头和屏幕的数据采集，还是调用原生的SDK接口，本文不再赘述，如果需要采集Unity窗体的数据，可以用参考以下代码：
if ( texture_ == null || video_width_ != Screen.width || video_height_ != Screen.height)
{
Debug.Log("OnPostRender screen changed++ scr_width: " + Screen.width + " scr_height: " + Screen.height);
if (screen_image_ != IntPtr.Zero)
{
Marshal.FreeHGlobal(screen_image_);
screen_image_ = IntPtr.Zero;
}
if (texture_ != null)
{
UnityEngine.Object.Destroy(texture_);
texture_ = null;
}
video_width_ = Screen.width;
video_height_ = Screen.height;
texture_ = new Texture2D(video_width_, video_height_, TextureFormat.BGRA32, false);
screen_image_ = Marshal.AllocHGlobal(video_width_ * 4 * video_height_);
Debug.Log("OnPostRender screen changed--");
return;
}
texture_.ReadPixels(new Rect(0, 0, video_width_, video_height_), 0, 0, false);
texture_.Apply();
从 texture里面，通过调用 GetRawTextureData()，获取到原始数据。
数据对接，通过调用以下接口：
public void OnPostRGBAData(IntPtr data, int length, int stride, int width, int height)
{
NT_PB_Image pb_image = new NT_PB_Image();
pb_image.format_ = (int)NTSmartPublisherDefine.NT_PB_E_IMAGE_FORMAT.NT_PB_E_IMAGE_FORMAT_RGB32;
pb_image.width_ = width;
pb_image.height_ = height;
pb_image.timestamp_ = 0;
pb_image.cb_size_ = (UInt32)Marshal.SizeOf(pb_image);
pb_image.stride_ = new Int32[16];
pb_image.stride_[0] = stride;
pb_image.plane_size_ = new Int32[16];
pb_image.plane_size_[0] = pb_image.stride_[0] * pb_image.height_;
pb_image.plane_ = new IntPtr[16];
pb_image.plane_[0] = data;
IntPtr image_data = Marshal.AllocHGlobal(Marshal.SizeOf(pb_image));
Marshal.StructureToPtr(pb_image, image_data, true);
NTSmartPublisherSDK.NT_PB_PostLayerImage(publisher_handle_, 0,
1, image_data, 0, IntPtr.Zero);
Marshal.FreeHGlobal(image_data);
}
public bool StartPreview()
{
if(CheckPublisherHandleAvailable() == false)
return false;
video_preview_image_callback_ = new NT_PB_SDKVideoPreviewImageCallBack(SDKVideoPreviewImageCallBack);
NTSmartPublisherSDK.NT_PB_SetVideoPreviewImageCallBack(publisher_handle_, (int)NTSmartPublisherDefine.NT_PB_E_IMAGE_FORMAT.NT_PB_E_IMAGE_FORMAT_RGB32, IntPtr.Zero, video_preview_image_callback_);
if (NTBaseCodeDefine.NT_ERC_OK != NTSmartPublisherSDK.NT_PB_StartPreview(publisher_handle_, 0, IntPtr.Zero))
{
if (0 == publisher_handle_count_)
{
NTSmartPublisherSDK.NT_PB_Close(publisher_handle_);
publisher_handle_ = IntPtr.Zero;
}
return false;
}
publisher_handle_count_++;
is_previewing_ = true;
return true;
}
设置preview后，处理preview的数据回调
//预览数据回调
public void SDKVideoPreviewImageCallBack(IntPtr handle, IntPtr user_data, IntPtr image)
{
NT_PB_Image pb_image = (NT_PB_Image)Marshal.PtrToStructure(image, typeof(NT_PB_Image));
NT_VideoFrame pVideoFrame = new NT_VideoFrame();
pVideoFrame.width_ = pb_image.width_;
pVideoFrame.height_ = pb_image.height_;
pVideoFrame.stride_ = pb_image.stride_[0];
Int32 argb_size = pb_image.stride_[0] * pb_image.height_;
pVideoFrame.plane_data_ = new byte[argb_size];
if (argb_size > 0)
{
Marshal.Copy(pb_image.plane_[0],pVideoFrame.plane_data_,0, argb_size);
}
{
cur_image_ = pVideoFrame;
}
}
private void PbEventCallBack(IntPtr handle, IntPtr user_data,
UInt32 event_id,
Int64 param1,
Int64 param2,
UInt64 param3,
UInt64 param4,
[MarshalAs(UnmanagedType.LPStr)] String param5,
[MarshalAs(UnmanagedType.LPStr)] String param6,
IntPtr param7)
{
String event_log = "";
switch (event_id)
{
case (uint)NTSmartPublisherDefine.NT_PB_E_EVENT_ID.NT_PB_E_EVENT_ID_CONNECTING:
event_log = "连接中";
if (!String.IsNullOrEmpty(param5))
{
event_log = event_log + " url:" + param5;
}
break;
case (uint)NTSmartPublisherDefine.NT_PB_E_EVENT_ID.NT_PB_E_EVENT_ID_CONNECTION_FAILED:
event_log = "连接失败";
if (!String.IsNullOrEmpty(param5))
{
event_log = event_log + " url:" + param5;
}
break;
case (uint)NTSmartPublisherDefine.NT_PB_E_EVENT_ID.NT_PB_E_EVENT_ID_CONNECTED:
event_log = "已连接";
if (!String.IsNullOrEmpty(param5))
{
event_log = event_log + " url:" + param5;
}
break;
case (uint)NTSmartPublisherDefine.NT_PB_E_EVENT_ID.NT_PB_E_EVENT_ID_DISCONNECTED:
event_log = "断开连接";
if (!String.IsNullOrEmpty(param5))
{
event_log = event_log + " url:" + param5;
}
break;
default:
break;
}
if(OnLogEventMsg != null) OnLogEventMsg.Invoke(event_id, event_log);
}
public bool StartPublisher(String url)
{
if (CheckPublisherHandleAvailable() == false) return false;
if (publisher_handle_ == IntPtr.Zero)
{
return false;
}
if (!String.IsNullOrEmpty(url))
{
NTSmartPublisherSDK.NT_PB_SetURL(publisher_handle_, url, IntPtr.Zero);
}
if (NTBaseCodeDefine.NT_ERC_OK != NTSmartPublisherSDK.NT_PB_StartPublisher(publisher_handle_, IntPtr.Zero))
{
if (0 == publisher_handle_count_)
{
NTSmartPublisherSDK.NT_PB_Close(publisher_handle_);
publisher_handle_ = IntPtr.Zero;
}
is_publishing_ = false;
return false;
}
publisher_handle_count_++;
is_publishing_ = true;
return true;
}
public void StopPublisher()
{
if (is_publishing_ == false) return;
publisher_handle_count_--;
NTSmartPublisherSDK.NT_PB_StopPublisher(publisher_handle_);
if (0 == publisher_handle_count_)
{
NTSmartPublisherSDK.NT_PB_Close(publisher_handle_);
publisher_handle_ = IntPtr.Zero;
}
is_publishing_ = false;
}
public void Close()
{
if (0 == publisher_handle_count_)
{
NTSmartPublisherSDK.NT_PB_Close(publisher_handle_);
publisher_handle_ = IntPtr.Zero;
}
}
经测试，Unity环境下，通过高效率的数据采集、编码和推送，配合SmartPlayer播放器播放，整体延迟可控制在毫秒级，可适用于大多数Unity环境下对延迟和稳定性要求苛刻的场景。
好多开发者苦于很难在unity3d下实现RTMP直播推送，本次以大牛直播SDK的Windows平台RTMP推送模块（以推摄像头为例，如需推屏幕数据，设置相关参数即可）为例，介绍下unity3d的RTMP推送集成。
简单来说，Unity3D环境下，可以直接调用C#的接口封装，针对此，我们先做了一层封装 （nt_publisher_wrapper.cs），核心代码如下：
初始化和基础参数设置：
private bool InitSDK()
{
if (!is_pusher_sdk_init_)
{
// 设置日志路径(请确保目录存在)
String log_path = "D:\\pulisherlog";
NTSmartLog.NT_SL_SetPath(log_path);
UInt32 isInited = NTSmartPublisherSDK.NT_PB_Init(0, IntPtr.Zero);
if (isInited != 0)
{
Debug.Log("调用NT_PB_Init失败..");
return false;
}
is_pusher_sdk_init_ = true;
}
return true;
}
public bool OpenPublisherHandle(uint video_option, uint audio_option)
{
if (publisher_handle_ != IntPtr.Zero)
{
return true;
}
publisher_handle_count_ = 0;
if (NTBaseCodeDefine.NT_ERC_OK != NTSmartPublisherSDK.NT_PB_Open(out publisher_handle_,
video_option, audio_option, 0, IntPtr.Zero))
{
return false;
}
if (publisher_handle_ != IntPtr.Zero)
{
pb_event_call_back_ = new NT_PB_SDKEventCallBack(PbEventCallBack);
NTSmartPublisherSDK.NT_PB_SetEventCallBack(publisher_handle_, IntPtr.Zero, pb_event_call_back_);
return true;
}
else
{
return false;
}
}
private void SetCommonOptionToPublisherSDK()
{
if (!IsPublisherHandleAvailable())
{
Debug.Log("SetCommonOptionToPublisherSDK, publisher handle with null..");
return;
}
CameraInfo camera = cameras_[cur_sel_camera_index_];
NT_PB_VideoCaptureCapability cap = camera.capabilities_[cur_sel_camera_resolutions_index_];
SetVideoCaptureDeviceBaseParameter(camera.id_.ToString(), (UInt32)cap.width_, (UInt32)cap.height_);
SetFrameRate((UInt32)CalBitRate(edit_key_frame_, cap.width_, cap.height_));
SetVideoEncoderType(is_h264_encoder ? 1 : 2);
SetVideoQualityV2(CalVideoQuality(cap.width_, cap.height_, is_h264_encoder));
SetVideoMaxBitRate((CalMaxKBitRate(edit_key_frame_, cap.width_, cap.height_, false)));
SetVideoKeyFrameInterval((edit_key_frame_));
if (is_h264_encoder)
{
SetVideoEncoderProfile(1);
}
SetVideoEncoderSpeed(CalVideoEncoderSpeed(cap.width_, cap.height_, is_h264_encoder));
// 音频相关设置
SetAuidoInputDeviceId(0);
SetPublisherAudioCodecType(1);
SetPublisherMute(is_mute);
SetInputAudioVolume(Convert.ToSingle(edit_audio_input_volume_));
}
预览、停止预览：
public bool StartPreview()
{
if(CheckPublisherHandleAvailable() == false)
return false;
video_preview_image_callback_ = new NT_PB_SDKVideoPreviewImageCallBack(SDKVideoPreviewImageCallBack);
NTSmartPublisherSDK.NT_PB_SetVideoPreviewImageCallBack(publisher_handle_, (int)NTSmartPublisherDefine.NT_PB_E_IMAGE_FORMAT.NT_PB_E_IMAGE_FORMAT_RGB32, IntPtr.Zero, video_preview_image_callback_);
if (NTBaseCodeDefine.NT_ERC_OK != NTSmartPublisherSDK.NT_PB_StartPreview(publisher_handle_, 0, IntPtr.Zero))
{
if (0 == publisher_handle_count_)
{
NTSmartPublisherSDK.NT_PB_Close(publisher_handle_);
publisher_handle_ = IntPtr.Zero;
}
return false;
}
publisher_handle_count_++;
is_previewing_ = true;
return true;
}
public void StopPreview()
{
if (is_previewing_ == false) return;
is_previewing_ = false;
publisher_handle_count_--;
NTSmartPublisherSDK.NT_PB_StopPreview(publisher_handle_);
if (0 == publisher_handle_count_)
{
NTSmartPublisherSDK.NT_PB_Close(publisher_handle_);
publisher_handle_ = IntPtr.Zero;
}
}
开始推送、停止推送：
public bool StartPublisher(String url)
{
if (CheckPublisherHandleAvailable() == false) return false;
if (publisher_handle_ == IntPtr.Zero)
{
return false;
}
if (!String.IsNullOrEmpty(url))
{
NTSmartPublisherSDK.NT_PB_SetURL(publisher_handle_, url, IntPtr.Zero);
}
if (NTBaseCodeDefine.NT_ERC_OK != NTSmartPublisherSDK.NT_PB_StartPublisher(publisher_handle_, IntPtr.Zero))
{
if (0 == publisher_handle_count_)
{
NTSmartPublisherSDK.NT_PB_Close(publisher_handle_);
publisher_handle_ = IntPtr.Zero;
}
is_publishing_ = false;
return false;
}
publisher_handle_count_++;
is_publishing_ = true;
return true;
}
public void StopPublisher()
{
if (is_publishing_ == false) return;
publisher_handle_count_--;
NTSmartPublisherSDK.NT_PB_StopPublisher(publisher_handle_);
if (0 == publisher_handle_count_)
{
NTSmartPublisherSDK.NT_PB_Close(publisher_handle_);
publisher_handle_ = IntPtr.Zero;
}
is_publishing_ = false;
}
相关event事件回调：
private void PbEventCallBack(IntPtr handle, IntPtr user_data,
UInt32 event_id,
Int64 param1,
Int64 param2,
UInt64 param3,
UInt64 param4,
[MarshalAs(UnmanagedType.LPStr)] String param5,
[MarshalAs(UnmanagedType.LPStr)] String param6,
IntPtr param7)
{
String event_log = "";
switch (event_id)
{
case (uint)NTSmartPublisherDefine.NT_PB_E_EVENT_ID.NT_PB_E_EVENT_ID_CONNECTING:
event_log = "连接中";
if (!String.IsNullOrEmpty(param5))
{
event_log = event_log + " url:" + param5;
}
break;
case (uint)NTSmartPublisherDefine.NT_PB_E_EVENT_ID.NT_PB_E_EVENT_ID_CONNECTION_FAILED:
event_log = "连接失败";
if (!String.IsNullOrEmpty(param5))
{
event_log = event_log + " url:" + param5;
}
break;
case (uint)NTSmartPublisherDefine.NT_PB_E_EVENT_ID.NT_PB_E_EVENT_ID_CONNECTED:
event_log = "已连接";
if (!String.IsNullOrEmpty(param5))
{
event_log = event_log + " url:" + param5;
}
break;
case (uint)NTSmartPublisherDefine.NT_PB_E_EVENT_ID.NT_PB_E_EVENT_ID_DISCONNECTED:
event_log = "断开连接";
if (!String.IsNullOrEmpty(param5))
{
event_log = event_log + " url:" + param5;
}
break;
default:
break;
}
if(OnLogEventMsg != null) OnLogEventMsg.Invoke(event_id, event_log);
}
SmartPublishWinMono.cs 调用上述封装的代码即可，本地预览的话，拿到回调的RGB数据，在unity3d上层刷下即可，如下图：
经测试，unity3d下，RTMP推送，配合RTMP播放端，依然可以实现毫秒级延迟的推拉流体验。
好多开发者在集成大牛直播SDK （官方）的Windows平台RTMP推送模块时吓一跳，怎么这么多接口？本文做个简单的拆分：
初始化之前，如需设置日志路径，调用NTSmartLog.NT_SL_SetPath(log_path); 设置日志存放路径。
设置过后，调用NT_PB_Init()接口，完成SDK初始化动作，注意，哪怕多实例推送，Init()接口也仅需调一次，同理，UnInit()接口也是。
然后，代码会判断系统是不是支持WR模式采集窗口，WR这种只有Win10高版本的才支持，如果不需要用到采集窗口，这个接口可忽略。
/*
* 检查是否支持WR方式采集窗口
* is_supported: 输出参数, 输出1表示支持, 0表示不支持
* 注意:这个需要win10较高版本才支持
* 成功返回 NT_ERC_OK
*/
[DllImport(@"SmartPublisherSDK.dll")]
public static extern UInt32 NT_PB_IsWRCaptureWindowSupported(ref Int32 is_supported);
再往下，是遍历系统支持的硬解、摄像头等信息，比如LoadHWVideoEncoderInfos()：
private void LoadHWVideoEncoderInfos()
{
hw_video_encoder_infos_.Clear();
Int32 count = 0;
UInt32 ret = NTSmartPublisherSDK.NT_PB_GetHWVideoEncoderInfoCount(ref count);
if (NTBaseCodeDefine.NT_ERC_OK == ret && count > 0)
{
IntPtr ptr_hw_video_encoder_infos = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(NT_PB_HWVideoEncoderInfo)) * count);
Int32 out_count = 0;
ret = NTSmartPublisherSDK.NT_PB_GetHWVideoEncoderInfos(ptr_hw_video_encoder_infos, count, ref out_count);
if (ret != NTBaseCodeDefine.NT_ERC_OK || out_count < 1)
{
hw_video_encoder_infos_.Clear();
}
else
{
for (int i = 0; i < out_count; i++)
{
NT_PB_HWVideoEncoderInfo hw_video_encoder_info = (NT_PB_HWVideoEncoderInfo)Marshal.PtrToStructure(ptr_hw_video_encoder_infos + i * Marshal.SizeOf(typeof(NT_PB_HWVideoEncoderInfo)), typeof(NT_PB_HWVideoEncoderInfo));
hw_video_encoder_infos_.Add(hw_video_encoder_info);
}
}
Marshal.FreeHGlobal(ptr_hw_video_encoder_infos);
}
}
if (hw_video_encoder_infos_.Count > 0)
{
EnableHWVideoEncoderControls(true);
FillVideoEncodersControl((uint)NTCommonMediaDefine.NT_MEDIA_CODEC_ID.NT_MEDIA_CODEC_ID_H264);
}
紧接着是Audio和camera相关：
int auido_devices = 0;
if (NTBaseCodeDefine.NT_ERC_OK == NTSmartPublisherSDK.NT_PB_GetAuidoInputDeviceNumber(ref auido_devices))
{
if (auido_devices > 0)
{
btn_check_auido_mic_input_.Enabled = true;
for (int i = 0; i < auido_devices; ++i)
{
byte[] deviceNameBuffer = new byte[512];
string name = "";
if (NTBaseCodeDefine.NT_ERC_OK == NTSmartPublisherSDK.NT_PB_GetAuidoInputDeviceName((uint)i, deviceNameBuffer, 512))
{
int count = 0;
for (int j = 0; j < deviceNameBuffer.Length; ++j )
{
if ( deviceNameBuffer[j] != 0 )
{
count++;
}
else
{
break;
}
}
if ( count > 0 )
{
name = Encoding.UTF8.GetString(deviceNameBuffer, 0, count);
}
}
var audio_name = "";
if (name.Length == 0)
{
audio_name = "音频采集设备-";
}
else
{
audio_name = name + "-";
}
audio_name = audio_name + (i + 1);
combox_auido_input_devices_.Items.Add(name);
}
combox_auido_input_devices_.SelectedIndex = 0;
}
}
publisher_handle_ = new IntPtr();
region_choose_tool_handle_ = new IntPtr();
win_form_wnd_ = GetForegroundWindow();
cameras_ = new List<CameraInfo>();
btn_check_video_bitrate_.CheckState = CheckState.Checked;
if (IsCanCaptureSpeaker())
{
btn_check_auido_speaker_input_.Enabled = true;
}
else
{
btn_check_auido_speaker_input_.Enabled = false;
}
if (btn_check_auido_mic_input_.Checked
|| btn_check_auido_speaker_input_.Checked)
{
btn_check_speex_encoder_.Enabled = true;
edit_speex_quality_.Enabled = true;
btn_check_noise_suppression_.Enabled = true;
btn_check_agc_.Enabled = true;
btn_check_vad_.Enabled = true;
}
if ( btn_check_auido_mic_input_.Checked
&& btn_check_auido_speaker_input_.Checked)
{
btn_check_echo_cancel_.Enabled = false;
edit_echo_delay_.Enabled = false;
}
edit_audio_input_volume_.Text = "1.0";
edit_audio_speaker_input_volume_.Text = "1.0";
FillCameraInfo();
InitCameraControl();
OpenPublisherHandle()主要是确认选择数据源类型，然后获取推送句柄，等待做下一步的操作。
选择video option和 audio option
// 视频
UInt32 video_option = (UInt32)NTSmartPublisherDefine.NT_PB_E_VIDEO_OPTION.NT_PB_E_VIDEO_OPTION_NO_VIDEO;
if (btn_desktop_camera_switch.Checked
|| btn_camera_overlay_to_desktop.Checked
|| btn_desktop_overlay_to_camera.Checked)
{
// 使用叠加模式
video_option = (UInt32)NTSmartPublisherDefine.NT_PB_E_VIDEO_OPTION.NT_PB_E_VIDEO_OPTION_LAYER;
}
else if (btn_check_window_input_.Checked)
{
video_option = (UInt32)NTSmartPublisherDefine.NT_PB_E_VIDEO_OPTION.NT_PB_E_VIDEO_OPTION_WINDOW;
}
else if (btn_check_desktop_input_.Checked && btn_check_scale_desktop_.Checked)
{
// 使用叠加模式来实现缩放
video_option = (UInt32)NTSmartPublisherDefine.NT_PB_E_VIDEO_OPTION.NT_PB_E_VIDEO_OPTION_LAYER;
}
else if (btn_check_desktop_input_.Checked && !btn_check_scale_desktop_.Checked)
{
//屏幕模式
video_option = (UInt32)NTSmartPublisherDefine.NT_PB_E_VIDEO_OPTION.NT_PB_E_VIDEO_OPTION_SCREEN;
}
else if (btn_check_camera_input_.Checked)
{
//摄像头模式
video_option = (UInt32)NTSmartPublisherDefine.NT_PB_E_VIDEO_OPTION.NT_PB_E_VIDEO_OPTION_CAMERA;
}
// 音频
UInt32 audio_option = (UInt32)NTSmartPublisherDefine.NT_PB_E_AUDIO_OPTION.NT_PB_E_AUDIO_OPTION_NO_AUDIO;
if (btn_check_auido_mic_input_.Checked
&& btn_check_auido_speaker_input_.Checked)
{
audio_option = (UInt32)NTSmartPublisherDefine.NT_PB_E_AUDIO_OPTION.NT_PB_E_AUDIO_OPTION_CAPTURE_MIC_SPEAKER_MIXER;
}
else if (btn_check_auido_mic_input_.Checked)
{
//麦克风模式
audio_option = (UInt32)NTSmartPublisherDefine.NT_PB_E_AUDIO_OPTION.NT_PB_E_AUDIO_OPTION_CAPTURE_MIC;
}
else if (btn_check_auido_speaker_input_.Checked)
{
//扬声器模式
audio_option = (UInt32)NTSmartPublisherDefine.NT_PB_E_AUDIO_OPTION.NT_PB_E_AUDIO_OPTION_CAPTURE_SPEAKER;
}
调用Open接口获取publisher handle，然设置event callback
if (NTBaseCodeDefine.NT_ERC_OK != NTSmartPublisherSDK.NT_PB_Open(out publisher_handle_,
video_option, audio_option, 0, IntPtr.Zero))
{
MessageBox.Show("Call open failed!");
return false;
}
if (publisher_handle_ != IntPtr.Zero)
{
pb_event_call_back_ = new NT_PB_SDKEventCallBack(PbSDKEventCallBack);
NTSmartPublisherSDK.NT_PB_SetEventCallBack(publisher_handle_, win_form_wnd_, pb_event_call_back_);
return true;
}
else
{
return false;
}
/*事件ID*/
public enum NT_PB_E_EVENT_ID : uint
{
NT_PB_E_EVENT_ID_BASE = NTBaseCodeDefine.NT_EVENT_ID_SMART_PUBLISHER_SDK,
NT_PB_E_EVENT_ID_CONNECTING = NT_PB_E_EVENT_ID_BASE | 0x2, /*连接中, param5表示推送URL */
NT_PB_E_EVENT_ID_CONNECTION_FAILED = NT_PB_E_EVENT_ID_BASE | 0x3, /*连接失败, param5表示推送URL*/
NT_PB_E_EVENT_ID_CONNECTED = NT_PB_E_EVENT_ID_BASE | 0x4, /*已连接, param5表示推送URL*/
NT_PB_E_EVENT_ID_DISCONNECTED = NT_PB_E_EVENT_ID_BASE | 0x5, /*断开连接, param5表示推送URL*/
NT_PB_E_EVENT_ID_RECORDER_START_NEW_FILE = NT_PB_E_EVENT_ID_BASE | 0x7, /*录像写入新文件, param5表示录像文件名*/
NT_PB_E_EVENT_ID_ONE_RECORDER_FILE_FINISHED = NT_PB_E_EVENT_ID_BASE | 0x8, /*一个录像文件完成, param5表示录像文件名*/
NT_PB_E_EVENT_ID_CAPTURE_WINDOW_INVALID = NT_PB_E_EVENT_ID_BASE | 0xd, /*捕获窗口时，如果窗口句柄无效则通知用户, param1为窗口句柄*/
NT_PB_E_EVENT_ID_RTSP_URL = NT_PB_E_EVENT_ID_BASE | 0xe, /* 通知rtsp url, param1表示rtsp server handle, param5 表示rtsp url */
NT_PB_E_EVENT_ID_PUSH_RTSP_SERVER_RESPONSE_STATUS_CODE = NT_PB_E_EVENT_ID_BASE | 0xf, /* 推送rtsp时服务端相应的status code上报，目前只上报401, param1表示status code, param5表示推送URL */
NT_PB_E_EVENT_ID_PUSH_RTSP_SERVER_NOT_SUPPORT = NT_PB_E_EVENT_ID_BASE | 0x10, /* 推送rtsp时服务器不支持rtsp推送, param5表示推送URL */
}
SetCommonOptionToPublisherSDK()主要是指定具体采集的音视频数据类型，比如摄像头数据、屏幕数据、摄像头和屏幕叠加后的数据（以层级模式实现）、窗口等，这块比较复杂，好在作为SDK调用者，你只要搞清楚你需要采集的类型，直接移植就可以了。
// 视频相关设置
if (btn_desktop_camera_switch.Checked
|| btn_camera_overlay_to_desktop.Checked
|| btn_desktop_overlay_to_camera.Checked
|| btn_check_desktop_input_.Checked
|| btn_check_window_input_.Checked
|| btn_check_camera_input_.Checked)
{
if (btn_desktop_camera_switch.Checked)
{
//摄像头和屏幕相互切换
int left = Int32.Parse(edit_clip_left_.Text);
int top = Int32.Parse(edit_clip_top_.Text);
int w = Int32.Parse(edit_clip_width_.Text);
int h = Int32.Parse(edit_clip_height_.Text);
// 有一个是0， 就使用全屏
if (w == 0 || h == 0)
{
left = 0;
top = 0;
w = screenArea_.Width;
h = screenArea_.Height;
}
else
{
// 保证4字节对齐
w = NT_ByteAlign(w, 4);
h = NT_ByteAlign(h, 4);
}
NTSmartPublisherSDK.NT_PB_ClearLayersConfig(publisher_handle_, 0,
0, IntPtr.Zero);
// 第0层填充RGBA矩形, 目的是保证帧率, 颜色就填充全黑
int red = 0;
int green = 0;
int blue = 0;
int alpha = 255;
NT_PB_RGBARectangleLayerConfig rgba_layer_c0 = new NT_PB_RGBARectangleLayerConfig();
rgba_layer_c0.base_.type_ = (Int32)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_RGBA_RECTANGLE;
rgba_layer_c0.base_.index_ = 0;
rgba_layer_c0.base_.enable_ = 1;
rgba_layer_c0.base_.region_.x_ = left;
rgba_layer_c0.base_.region_.y_ = top;
rgba_layer_c0.base_.region_.width_ = w;
rgba_layer_c0.base_.region_.height_ = h;
rgba_layer_c0.base_.offset_ = Marshal.OffsetOf(rgba_layer_c0.GetType(), "base_").ToInt32();
rgba_layer_c0.base_.cb_size_ = (uint)Marshal.SizeOf(rgba_layer_c0);
rgba_layer_c0.red_ = System.BitConverter.GetBytes(red)[0];
rgba_layer_c0.green_ = System.BitConverter.GetBytes(green)[0];
rgba_layer_c0.blue_ = System.BitConverter.GetBytes(blue)[0];
rgba_layer_c0.alpha_ = System.BitConverter.GetBytes(alpha)[0];
IntPtr rgba_conf = Marshal.AllocHGlobal(Marshal.SizeOf(rgba_layer_c0));
Marshal.StructureToPtr(rgba_layer_c0, rgba_conf, true);
UInt32 rgba_r = NTSmartPublisherSDK.NT_PB_AddLayerConfig(publisher_handle_, 0,
rgba_conf, (int)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_RGBA_RECTANGLE,
0, IntPtr.Zero);
Console.WriteLine("[摄像头和屏幕相互切换] NT_PB_AddLayerConfig, rgba: " + rgba_r + Environment.NewLine);
Marshal.FreeHGlobal(rgba_conf);
//第一层：摄像头
NT_PB_CameraLayerConfigV2 camera_layer_c1 = new NT_PB_CameraLayerConfigV2();
CameraInfo camera = cameras_[cur_sel_camera_index_];
NT_PB_VideoCaptureCapability cap = camera.capabilities_[cur_sel_camera_resolutions_index_];
camera_layer_c1.device_unique_id_utf8_ = camera.id_;
camera_layer_c1.base_.type_ = (Int32)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_CAMERA;
camera_layer_c1.base_.index_ = 1;
camera_layer_index_ = camera_layer_c1.base_.index_;
camera_layer_c1.base_.enable_ = 1;
camera_layer_c1.base_.region_.x_ = left;
camera_layer_c1.base_.region_.y_ = top;
camera_layer_c1.base_.region_.width_ = w;
camera_layer_c1.base_.region_.height_ = h;
if (btn_check_flip_horizontal_camera_.Checked)
{
camera_layer_c1.is_flip_horizontal_ = 1;
}
else
{
camera_layer_c1.is_flip_horizontal_ = 0;
}
if (btn_check_flip_vertical_camera_.Checked)
{
camera_layer_c1.is_flip_vertical_ = 1;
}
else
{
camera_layer_c1.is_flip_vertical_ = 0;
}
// 这种叠加模式下不要旋转，否则变形厉害, 要么就定好一个角度，调整宽高，但不要动态旋转
camera_layer_c1.rotate_degress_ = 0;
camera_layer_c1.base_.offset_ = Marshal.OffsetOf(camera_layer_c1.GetType(), "base_").ToInt32(); //offsetof(T, base_);
camera_layer_c1.base_.cb_size_ = (uint)Marshal.SizeOf(camera_layer_c1);
IntPtr cmr_conf = Marshal.AllocHGlobal(Marshal.SizeOf(camera_layer_c1));
Marshal.StructureToPtr(camera_layer_c1, cmr_conf, true);
UInt32 c_r = NTSmartPublisherSDK.NT_PB_AddLayerConfig(publisher_handle_, 0,
cmr_conf, (int)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_CAMERA,
0, IntPtr.Zero);
Marshal.FreeHGlobal(cmr_conf);
//第二层
NT_PB_ScreenLayerConfig screen_layer_c2 = new NT_PB_ScreenLayerConfig();
screen_layer_c2.base_.type_ = (Int32)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_SCREEN;
screen_layer_c2.base_.index_ = 2;
screen_layer_index_ = screen_layer_c2.base_.index_;
screen_layer_c2.base_.enable_ = 1;
screen_layer_c2.base_.region_.x_ = left;
screen_layer_c2.base_.region_.y_ = top;
screen_layer_c2.base_.region_.width_ = w;
screen_layer_c2.base_.region_.height_ = h;
screen_layer_c2.base_.offset_ = Marshal.OffsetOf(screen_layer_c2.GetType(), "base_").ToInt32(); //offsetof(T, base_);
screen_layer_c2.base_.cb_size_ = (uint)Marshal.SizeOf(screen_layer_c2);
screen_layer_c2.clip_region_.x_ = left;
screen_layer_c2.clip_region_.y_ = top;
screen_layer_c2.clip_region_.width_ = w;
screen_layer_c2.clip_region_.height_ = h;
screen_layer_c2.reserve_ = IntPtr.Zero;
IntPtr scr_conf = Marshal.AllocHGlobal(Marshal.SizeOf(screen_layer_c2));
Marshal.StructureToPtr(screen_layer_c2, scr_conf, true);
UInt32 s_r = NTSmartPublisherSDK.NT_PB_AddLayerConfig(publisher_handle_, 0,
scr_conf, (int)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_SCREEN,
0, IntPtr.Zero);
Marshal.FreeHGlobal(scr_conf);
// 第三层填充RGBA矩形, 目的是保证帧率, 颜色就填充全黑
red = Int32.Parse(edit_rgba_rect_layer_red_.Text);
red = ClipIntValue(red, 0, 255);
green = Int32.Parse(edit_rgba_rect_layer_green_.Text);
green = ClipIntValue(green, 0, 255);
blue = Int32.Parse(edit_rgba_rect_layer_blue_.Text);
blue = ClipIntValue(blue, 0, 255);
alpha = Int32.Parse(edit_rgba_rect_layer_alpha_.Text);
alpha = ClipIntValue(alpha, 0, 255);
NT_PB_RGBARectangleLayerConfig rgba_layer_c3 = new NT_PB_RGBARectangleLayerConfig();
rgba_layer_c3.base_.type_ = (Int32)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_RGBA_RECTANGLE;
rgba_layer_c3.base_.index_ = 3;
rgba_layer_index_ = rgba_layer_c3.base_.index_;
rgba_layer_c3.base_.enable_ = 1;
rgba_layer_c3.base_.region_.x_ = left; //这个只是demo演示，实际以需要遮盖位置为准
rgba_layer_c3.base_.region_.y_ = top;
rgba_layer_c3.base_.region_.width_ = 160;
rgba_layer_c3.base_.region_.height_ = 160;
rgba_layer_c3.base_.offset_ = Marshal.OffsetOf(rgba_layer_c3.GetType(), "base_").ToInt32();
rgba_layer_c3.base_.cb_size_ = (uint)Marshal.SizeOf(rgba_layer_c3);
rgba_layer_c3.red_ = System.BitConverter.GetBytes(red)[0];
rgba_layer_c3.green_ = System.BitConverter.GetBytes(green)[0];
rgba_layer_c3.blue_ = System.BitConverter.GetBytes(blue)[0];
rgba_layer_c3.alpha_ = System.BitConverter.GetBytes(alpha)[0];
IntPtr rgba_conf_3 = Marshal.AllocHGlobal(Marshal.SizeOf(rgba_layer_c3));
Marshal.StructureToPtr(rgba_layer_c3, rgba_conf_3, true);
UInt32 rgba_r_3 = NTSmartPublisherSDK.NT_PB_AddLayerConfig(publisher_handle_, 0,
rgba_conf_3, (int)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_RGBA_RECTANGLE,
0, IntPtr.Zero);
Console.WriteLine("NT_PB_AddLayerConfig, rgba: " + rgba_r_3 + Environment.NewLine);
Marshal.FreeHGlobal(rgba_conf_3);
// 第四层填充png水印(注意，实时开启、关闭水印，是根据图层的index来的，如此demo，png水印的index为4)
// 如果有图片，增加图片层
if (!String.IsNullOrEmpty(image_layer_file_name_utf8_)
&& image_layer_width_ > 0
&& image_layer_height_ > 0)
{
NT_PB_ImageLayerConfig image_layer_c4 = new NT_PB_ImageLayerConfig();
image_layer_c4.base_.type_ = (Int32)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_IMAGE;
image_layer_c4.base_.index_ = 4;
image_layer_index_ = image_layer_c4.base_.index_;
image_layer_c4.base_.enable_ = 1;
image_layer_c4.base_.region_.x_ = image_layer_left_;
image_layer_c4.base_.region_.y_ = image_layer_top_;
image_layer_c4.base_.region_.width_ = image_layer_width_;
image_layer_c4.base_.region_.height_ = image_layer_height_;
image_layer_c4.base_.offset_ = Marshal.OffsetOf(image_layer_c4.GetType(), "base_").ToInt32();
image_layer_c4.base_.cb_size_ = (uint)Marshal.SizeOf(image_layer_c4);
byte[] buffer1 = Encoding.Default.GetBytes(image_layer_file_name_utf8_);
byte[] buffer2 = Encoding.Convert(Encoding.UTF8, Encoding.Default, buffer1, 0, buffer1.Length);
string strBuffer = Encoding.Default.GetString(buffer2, 0, buffer2.Length);
image_layer_c4.file_name_utf8_ = strBuffer;
image_layer_c4.is_setting_background_ = 0;
image_layer_c4.bk_red_ = 0;
image_layer_c4.bk_green_ = 0;
image_layer_c4.bk_blue_ = 0;
image_layer_c4.reserve_ = 0;
IntPtr image_conf = Marshal.AllocHGlobal(Marshal.SizeOf(image_layer_c4));
Marshal.StructureToPtr(image_layer_c4, image_conf, true);
UInt32 image_r = NTSmartPublisherSDK.NT_PB_AddLayerConfig(publisher_handle_, 0,
image_conf, (int)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_IMAGE,
0, IntPtr.Zero);
Console.WriteLine("NT_PB_AddLayerConfig, image: " + image_r + Environment.NewLine);
Marshal.FreeHGlobal(image_conf);
NTSmartPublisherSDK.NT_PB_SetFrameRate(publisher_handle_, UInt32.Parse(edit_frame_rate_.Text));
}
}
else if (btn_camera_overlay_to_desktop.Checked)
{
//摄像头overlay到桌面
int left = Int32.Parse(edit_clip_left_.Text);
int top = Int32.Parse(edit_clip_top_.Text);
int w = Int32.Parse(edit_clip_width_.Text);
int h = Int32.Parse(edit_clip_height_.Text);
// 有一个是0， 就使用全屏
if ( w == 0 || h == 0 )
{
left = 0;
top = 0;
w = screenArea_.Width;
h = screenArea_.Height;
}
else
{
// 保证4字节对齐
w = NT_ByteAlign(w, 4);
h = NT_ByteAlign(h, 4);
}
//第一层：屏幕
NT_PB_ScreenLayerConfig screen_layer_c0 = new NT_PB_ScreenLayerConfig();
screen_layer_c0.base_.type_ = (Int32)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_SCREEN;
screen_layer_c0.base_.index_ = 0;
screen_layer_index_ = screen_layer_c0.base_.index_;
screen_layer_c0.base_.enable_ = 1;
screen_layer_c0.base_.region_.x_ = left;
screen_layer_c0.base_.region_.y_ = top;
screen_layer_c0.base_.region_.width_ = w;
screen_layer_c0.base_.region_.height_ = h;
screen_layer_c0.base_.offset_ = Marshal.OffsetOf(screen_layer_c0.GetType(), "base_").ToInt32(); //offsetof(T, base_);
screen_layer_c0.base_.cb_size_ = (uint)Marshal.SizeOf(screen_layer_c0);
screen_layer_c0.clip_region_.x_ = left;
screen_layer_c0.clip_region_.y_ = top;
screen_layer_c0.clip_region_.width_ = w;
screen_layer_c0.clip_region_.height_ = h;
screen_layer_c0.reserve_ = IntPtr.Zero;
NTSmartPublisherSDK.NT_PB_ClearLayersConfig(publisher_handle_, 0,
0, IntPtr.Zero);
IntPtr scr_conf = Marshal.AllocHGlobal(Marshal.SizeOf(screen_layer_c0));
Marshal.StructureToPtr(screen_layer_c0, scr_conf, true);
UInt32 s_r = NTSmartPublisherSDK.NT_PB_AddLayerConfig(publisher_handle_, 0,
scr_conf, (int)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_SCREEN,
0, IntPtr.Zero);
Marshal.FreeHGlobal(scr_conf);
//第二层：摄像头
if (-1 != cur_sel_camera_index_)
{
int c_l = Int32.Parse(edit_camera_overlay_left_.Text);
int c_t = Int32.Parse(edit_camera_overlay_top_.Text);
int c_w = Int32.Parse(edit_camera_overlay_width_.Text);
int c_h = Int32.Parse(edit_camera_overlay_height_.Text);
if (c_w == 0)
{
c_w = w / 2;
}
if (c_h == 0)
{
c_h = h / 2;
}
ctos_camera_layer_c1_ = new NT_PB_CameraLayerConfigV2();
CameraInfo camera = cameras_[cur_sel_camera_index_];
NT_PB_VideoCaptureCapability cap = camera.capabilities_[cur_sel_camera_resolutions_index_];
ctos_camera_layer_c1_.device_unique_id_utf8_ = camera.id_;
ctos_camera_layer_c1_.base_.type_ = (Int32)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_CAMERA;
ctos_camera_layer_c1_.base_.index_ = 1;
camera_layer_index_ = ctos_camera_layer_c1_.base_.index_;
ctos_camera_layer_c1_.base_.enable_ = 1;
ctos_camera_layer_c1_.base_.region_.x_ = c_l;
ctos_camera_layer_c1_.base_.region_.y_ = c_t;
ctos_camera_layer_c1_.base_.region_.width_ = c_w;
ctos_camera_layer_c1_.base_.region_.height_ = c_h;
if (btn_check_flip_horizontal_camera_.Checked)
{
ctos_camera_layer_c1_.is_flip_horizontal_ = 1;
}
else
{
ctos_camera_layer_c1_.is_flip_horizontal_ = 0;
}
if (btn_check_flip_vertical_camera_.Checked)
{
ctos_camera_layer_c1_.is_flip_vertical_ = 1;
}
else
{
ctos_camera_layer_c1_.is_flip_vertical_ = 0;
}
ctos_camera_layer_c1_.rotate_degress_ = GetCameraRotateDegress();
ctos_camera_layer_c1_.base_.offset_ = Marshal.OffsetOf(ctos_camera_layer_c1_.GetType(), "base_").ToInt32(); //offsetof(T, base_);
ctos_camera_layer_c1_.base_.cb_size_ = (uint)Marshal.SizeOf(ctos_camera_layer_c1_);
IntPtr cmr_conf = Marshal.AllocHGlobal(Marshal.SizeOf(ctos_camera_layer_c1_));
Marshal.StructureToPtr(ctos_camera_layer_c1_, cmr_conf, true);
UInt32 c_r = NTSmartPublisherSDK.NT_PB_AddLayerConfig(publisher_handle_, 0,
cmr_conf, (int)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_CAMERA,
0, IntPtr.Zero);
Marshal.FreeHGlobal(cmr_conf);
}
NTSmartPublisherSDK.NT_PB_SetFrameRate(publisher_handle_, UInt32.Parse(edit_frame_rate_.Text));
}
else if (btn_desktop_overlay_to_camera.Checked)
{
//桌面overlay到摄像头
//第一层：摄像头
if (-1 != cur_sel_camera_index_
&& -1 != cur_sel_camera_resolutions_index_
&& -1 != cur_sel_camera_frame_rate_index_)
{
NT_PB_CameraLayerConfigV2 camera_layer_c0 = new NT_PB_CameraLayerConfigV2();
CameraInfo camera = cameras_[cur_sel_camera_index_];
NT_PB_VideoCaptureCapability cap = camera.capabilities_[cur_sel_camera_resolutions_index_];
camera_layer_c0.device_unique_id_utf8_ = camera.id_;
camera_layer_c0.base_.type_ = (Int32)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_CAMERA;
camera_layer_c0.base_.index_ = 0;
camera_layer_index_ = camera_layer_c0.base_.index_;
camera_layer_c0.base_.enable_ = 1;
camera_layer_c0.base_.region_.x_ = 0;
camera_layer_c0.base_.region_.y_ = 0;
camera_layer_c0.base_.region_.width_ = cap.width_;
camera_layer_c0.base_.region_.height_ = cap.height_;
if (btn_check_flip_horizontal_camera_.Checked)
{
camera_layer_c0.is_flip_horizontal_ = 1;
}
else
{
camera_layer_c0.is_flip_horizontal_ = 0;
}
if (btn_check_flip_vertical_camera_.Checked)
{
camera_layer_c0.is_flip_vertical_ = 1;
}
else
{
camera_layer_c0.is_flip_vertical_ = 0;
}
// 这种叠加模式下不要旋转，否则变形厉害, 要么就定好一个角度，调整宽高，但不要动态旋转
camera_layer_c0.rotate_degress_ = 0;
camera_layer_c0.base_.offset_ = Marshal.OffsetOf(camera_layer_c0.GetType(), "base_").ToInt32(); //offsetof(T, base_);
camera_layer_c0.base_.cb_size_ = (uint)Marshal.SizeOf(camera_layer_c0);
NTSmartPublisherSDK.NT_PB_ClearLayersConfig(publisher_handle_, 0,
0, IntPtr.Zero);
IntPtr cmr_conf = Marshal.AllocHGlobal(Marshal.SizeOf(camera_layer_c0));
Marshal.StructureToPtr(camera_layer_c0, cmr_conf, true);
UInt32 r = NTSmartPublisherSDK.NT_PB_AddLayerConfig(publisher_handle_, 0,
cmr_conf, (int)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_CAMERA,
0, IntPtr.Zero);
Marshal.FreeHGlobal(cmr_conf);
//第二层：屏幕
NT_PB_ScreenLayerConfig screen_layer_c1 = new NT_PB_ScreenLayerConfig();
screen_layer_c1.base_.type_ = (Int32)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_SCREEN;
screen_layer_c1.base_.index_ = 1;
screen_layer_index_ = screen_layer_c1.base_.index_;
screen_layer_c1.base_.enable_ = 1;
screen_layer_c1.base_.region_.x_ = 0;
screen_layer_c1.base_.region_.y_ = 0;
screen_layer_c1.base_.region_.width_ = cap.width_ / 2;
screen_layer_c1.base_.region_.height_ = cap.height_ / 2;
screen_layer_c1.base_.offset_ = Marshal.OffsetOf(screen_layer_c1.GetType(), "base_").ToInt32(); //offsetof(T, base_);
screen_layer_c1.base_.cb_size_ = (uint)Marshal.SizeOf(screen_layer_c1);
screen_layer_c1.clip_region_.x_ = 0;
screen_layer_c1.clip_region_.y_ = 0;
screen_layer_c1.clip_region_.width_ = cap.width_ / 2;
screen_layer_c1.clip_region_.height_ = cap.height_ / 2;
screen_layer_c1.reserve_ = IntPtr.Zero;
IntPtr scr_conf = Marshal.AllocHGlobal(Marshal.SizeOf(screen_layer_c1));
Marshal.StructureToPtr(screen_layer_c1, scr_conf, true);
UInt32 s_r = NTSmartPublisherSDK.NT_PB_AddLayerConfig(publisher_handle_, 0,
scr_conf, (int)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_SCREEN,
0, IntPtr.Zero);
Marshal.FreeHGlobal(scr_conf);
}
NTSmartPublisherSDK.NT_PB_SetFrameRate(publisher_handle_, (uint)(cur_sel_camera_frame_rate_index_ + 1));
}
else if (btn_check_desktop_input_.Checked && btn_check_scale_desktop_.Checked)
{
int left = 0;
int top = 0;
int w = 0;
int h = 0;
int scale_w = 0;
int scale_h = 0;
GetScreenScaleConfigInfo(ref left, ref top, ref w, ref h, ref scale_w, ref scale_h);
NTSmartPublisherSDK.NT_PB_ClearLayersConfig(publisher_handle_, 0,
0, IntPtr.Zero);
// 第0层填充RGBA矩形, 目的是保证帧率, 颜色就填充全黑
int red = 0;
int green = 0;
int blue = 0;
int alpha = 255;
NT_PB_RGBARectangleLayerConfig rgba_layer_c0 = new NT_PB_RGBARectangleLayerConfig();
rgba_layer_c0.base_.type_ = (Int32)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_RGBA_RECTANGLE;
rgba_layer_c0.base_.index_ = 0;
rgba_layer_index_ = rgba_layer_c0.base_.index_;
rgba_layer_c0.base_.enable_ = 1;
rgba_layer_c0.base_.region_.x_ = 0;
rgba_layer_c0.base_.region_.y_ = 0;
rgba_layer_c0.base_.region_.width_ = scale_w;
rgba_layer_c0.base_.region_.height_ = scale_h;
rgba_layer_c0.base_.offset_ = Marshal.OffsetOf(rgba_layer_c0.GetType(), "base_").ToInt32();
rgba_layer_c0.base_.cb_size_ = (uint)Marshal.SizeOf(rgba_layer_c0);
rgba_layer_c0.red_ = 0;
rgba_layer_c0.green_ = 0;
rgba_layer_c0.blue_ = 0;
rgba_layer_c0.alpha_ = 255;
IntPtr rgba_conf_0 = Marshal.AllocHGlobal(Marshal.SizeOf(rgba_layer_c0));
Marshal.StructureToPtr(rgba_layer_c0, rgba_conf_0, true);
UInt32 rgba_r_0 = NTSmartPublisherSDK.NT_PB_AddLayerConfig(publisher_handle_, 0,
rgba_conf_0, (int)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_RGBA_RECTANGLE,
0, IntPtr.Zero);
Console.WriteLine("NT_PB_AddLayerConfig, rgba: " + rgba_r_0 + Environment.NewLine);
Marshal.FreeHGlobal(rgba_conf_0);
//第1层
NT_PB_ScreenLayerConfigV2 screen_layer_c1 = new NT_PB_ScreenLayerConfigV2();
screen_layer_c1.base_.type_ = (Int32)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_SCREEN;
screen_layer_c1.base_.index_ = 1;
screen_layer_index_ = screen_layer_c1.base_.index_;
screen_layer_c1.base_.enable_ = checkbox_black_screen_.Checked?0:1;
screen_layer_c1.base_.region_.x_ = left;
screen_layer_c1.base_.region_.y_ = top;
screen_layer_c1.base_.region_.width_ = scale_w;
screen_layer_c1.base_.region_.height_ = scale_h;
screen_layer_c1.base_.offset_ = Marshal.OffsetOf(screen_layer_c1.GetType(), "base_").ToInt32(); //offsetof(T, base_);
screen_layer_c1.base_.cb_size_ = (uint)Marshal.SizeOf(screen_layer_c1);
screen_layer_c1.clip_region_.x_ = left;
screen_layer_c1.clip_region_.y_ = top;
screen_layer_c1.clip_region_.width_ = w;
screen_layer_c1.clip_region_.height_ = h;
screen_layer_c1.reserve1_ = IntPtr.Zero;
screen_layer_c1.reserve2_ = 0;
screen_layer_c1.scale_filter_mode_ = 3;
IntPtr scr_conf = Marshal.AllocHGlobal(Marshal.SizeOf(screen_layer_c1));
Marshal.StructureToPtr(screen_layer_c1, scr_conf, true);
UInt32 s_r = NTSmartPublisherSDK.NT_PB_AddLayerConfig(publisher_handle_, 0,
scr_conf, (int)NTSmartPublisherDefine.NT_PB_E_LAYER_TYPE.NT_PB_E_LAYER_TYPE_SCREEN,
0, IntPtr.Zero);
Marshal.FreeHGlobal(scr_conf);
NTSmartPublisherSDK.NT_PB_SetSleepMode(publisher_handle_, checkbox_black_screen_.Checked ? 1 : 0, 0);
NTSmartPublisherSDK.NT_PB_SetFrameRate(publisher_handle_, UInt32.Parse(edit_frame_rate_.Text));
}
else if (btn_check_desktop_input_.Checked && !btn_check_scale_desktop_.Checked)
{
//桌面
NTSmartPublisherSDK.NT_PB_SetScreenClip(publisher_handle_,
UInt32.Parse(edit_clip_left_.Text),
UInt32.Parse(edit_clip_top_.Text),
UInt32.Parse(edit_clip_width_.Text),
UInt32.Parse(edit_clip_height_.Text));
NTSmartPublisherSDK.NT_PB_SetFrameRate(publisher_handle_, UInt32.Parse(edit_frame_rate_.Text));
}
else if (btn_check_window_input_.Checked)
{
if (IntPtr.Zero != cur_sel_capture_window_)
{
NTSmartPublisherSDK.NT_PB_SetCaptureWindow(publisher_handle_, cur_sel_capture_window_);
NTSmartPublisherSDK.NT_PB_SetFrameRate(publisher_handle_, UInt32.Parse(edit_frame_rate_.Text));
NTSmartPublisherSDK.NT_PB_ClearLayersConfig(publisher_handle_, 0, 0, IntPtr.Zero);
}
}
else if (btn_check_camera_input_.Checked)
{
//摄像头
if (-1 != cur_sel_camera_index_
&& -1 != cur_sel_camera_resolutions_index_
&& -1 != cur_sel_camera_frame_rate_index_)
{
CameraInfo camera = cameras_[cur_sel_camera_index_];
NT_PB_VideoCaptureCapability cap = camera.capabilities_[cur_sel_camera_resolutions_index_];
NTSmartPublisherSDK.NT_PB_SetVideoCaptureDeviceBaseParameter(publisher_handle_,
camera.id_.ToString(), (UInt32)cap.width_, (UInt32)cap.height_);
NTSmartPublisherSDK.NT_PB_SetFrameRate(publisher_handle_, (UInt32)(cur_sel_camera_frame_rate_index_ + 1));
if (btn_check_flip_vertical_camera_.Checked)
{
NTSmartPublisherSDK.NT_PB_FlipVerticalCamera(publisher_handle_, 1);
}
else
{
NTSmartPublisherSDK.NT_PB_FlipVerticalCamera(publisher_handle_, 0);
}
if (btn_check_flip_horizontal_camera_.Checked)
{
NTSmartPublisherSDK.NT_PB_FlipHorizontalCamera(publisher_handle_, 1);
}
else
{
NTSmartPublisherSDK.NT_PB_FlipHorizontalCamera(publisher_handle_, 0);
}
Int32 degress = GetCameraRotateDegress();
NTSmartPublisherSDK.NT_PB_RotateCamera(publisher_handle_, degress);
}
}
其他音视频相关接口参数设定，比是否启用DXGI， Aero模式，软硬编码模式，帧率关键帧间隔码率等设定。
if (btn_check_dxgi_screen_capturer_.Checked)
{
NTSmartPublisherSDK.NT_PB_EnableDXGIScreenCapturer(publisher_handle_, 1);
}
else
{
NTSmartPublisherSDK.NT_PB_EnableDXGIScreenCapturer(publisher_handle_, 0);
}
if (check_capture_layered_window_.Checked)
{
NTSmartPublisherSDK.NT_PB_EnableScreenCaptureLayeredWindow(publisher_handle_, 1);
}
else
{
NTSmartPublisherSDK.NT_PB_EnableScreenCaptureLayeredWindow(publisher_handle_, 0);
}
if (btn_check_capturer_disable_aero_.Checked)
{
NTSmartPublisherSDK.NT_PB_DisableAeroScreenCapturer(publisher_handle_, 1);
}
else
{
NTSmartPublisherSDK.NT_PB_DisableAeroScreenCapturer(publisher_handle_, 0);
}
if (btn_check_wr_way_capture_window_.Checked)
{
NTSmartPublisherSDK.NT_PB_SetCaptureWindowWay(publisher_handle_, 2);
}
else
{
NTSmartPublisherSDK.NT_PB_SetCaptureWindowWay(publisher_handle_, 1);
}
int cur_video_codec_id = (int)NTCommonMediaDefine.NT_MEDIA_CODEC_ID.NT_MEDIA_CODEC_ID_H264;
if (btn_check_h265_encoder_.Checked)
{
cur_video_codec_id = (int)NTCommonMediaDefine.NT_MEDIA_CODEC_ID.NT_MEDIA_CODEC_ID_H265;
}
bool is_hw_encoder = false;
if ( btn_check_video_hardware_encoder_.Checked)
{
is_hw_encoder = true;
}
Int32 cur_sel_encoder_id = 0;
Int32 cur_sel_gpu = 0;
if (is_hw_encoder)
{
int cur_sel_hw = combobox_video_encoders_.SelectedIndex;
if (cur_sel_hw >= 0)
{
cur_sel_encoder_id = Convert.ToInt32(combobox_video_encoders_.SelectedValue);
cur_sel_gpu = -1;
int cur_sel_hw_dev = combobox_video_hardware_encoder_devices_.SelectedIndex;
if (cur_sel_hw_dev >= 0)
{
cur_sel_gpu = Convert.ToInt32(combobox_video_hardware_encoder_devices_.SelectedValue);
}
}
else
{
is_hw_encoder = false;
}
}
if (!is_hw_encoder)
{
if ((int)NTCommonMediaDefine.NT_MEDIA_CODEC_ID.NT_MEDIA_CODEC_ID_H264 == cur_video_codec_id)
{
cur_sel_encoder_id = btn_check_openh264_encoder_.Checked ? 1 : 0;
}
}
NTSmartPublisherSDK.NT_PB_SetVideoEncoder(publisher_handle_, (int)(is_hw_encoder ? 1 : 0), (int)cur_sel_encoder_id, (uint)cur_video_codec_id, (int)cur_sel_gpu);
if (!btn_check_window_input_.Checked)
{
NTSmartPublisherSDK.NT_PB_SetVideoBitRate(publisher_handle_, Int32.Parse(edit_bit_rate_.Text));
}
else
{
// 窗口的分辨率会变, 所以设置一组码率下去
Int32 frame_rate = Int32.Parse(edit_bit_rate_.Text);
SetBitrateGroup(publisher_handle_, frame_rate);
}
NTSmartPublisherSDK.NT_PB_SetVideoQualityV2(publisher_handle_, Int32.Parse(edit_video_quality_.Text));
NTSmartPublisherSDK.NT_PB_SetVideoMaxBitRate(publisher_handle_, Int32.Parse(edit_video_max_bitrate_.Text));
NTSmartPublisherSDK.NT_PB_SetVideoKeyFrameInterval(publisher_handle_, Int32.Parse(edit_key_frame_.Text));
if (cur_video_codec_id == (int)NTCommonMediaDefine.NT_MEDIA_CODEC_ID.NT_MEDIA_CODEC_ID_H264)
{
int profile_sel = combox_h264_profile_.SelectedIndex;
if (profile_sel != -1)
{
NTSmartPublisherSDK.NT_PB_SetVideoEncoderProfile(publisher_handle_, profile_sel + 1);
}
}
NTSmartPublisherSDK.NT_PB_SetVideoEncoderSpeed(publisher_handle_, Int32.Parse(edit_video_encode_speed_.Text));
// 清除编码器所有的特定的参数
NTSmartPublisherSDK.NT_PB_ClearVideoEncoderSpecialOptions(publisher_handle_);
if (cur_sel_encoder_id == 1)
{
// qp_max 和 qp_min 当前只对openh264有效, 这里也就只在openh264使用的场景下设置配置值
NTSmartPublisherSDK.NT_PB_SetVideoEncoderQPMax(publisher_handle_, Int32.Parse(edit_qp_max_.Text));
NTSmartPublisherSDK.NT_PB_SetVideoEncoderQPMin(publisher_handle_, Int32.Parse(edit_qp_min_.Text));
// openh264 配置特定参数
NTSmartPublisherSDK.NT_PB_SetVideoEncoderSpecialInt32Option(publisher_handle_, "usage_type", btn_check_openh264_ppt_usage_type_.Checked ? 1 : 0);
NTSmartPublisherSDK.NT_PB_SetVideoEncoderSpecialInt32Option(publisher_handle_, "rc_mode", btn_check_openh264_rc_bitrate_mode_.Checked ? 1 : 0);
NTSmartPublisherSDK.NT_PB_SetVideoEncoderSpecialInt32Option(publisher_handle_, "enable_frame_skip", btn_check_openh264_frame_skip_.Checked ? 1 : 0);
}
else
{
NTSmartPublisherSDK.NT_PB_SetVideoEncoderQPMax(publisher_handle_, -1);
NTSmartPublisherSDK.NT_PB_SetVideoEncoderQPMin(publisher_handle_, -1);
}
// 音频相关设置
if (btn_check_auido_mic_input_.Checked)
{
int count = combox_auido_input_devices_.Items.Count;
if (count != -1 && count > 0)
{
int cur_sel = combox_auido_input_devices_.SelectedIndex;
if (cur_sel != -1)
{
NTSmartPublisherSDK.NT_PB_SetAuidoInputDeviceId(publisher_handle_, (uint)cur_sel);
}
}
}
// 只采集扬声器时做静音补偿
if (!btn_check_auido_mic_input_.Checked
&& btn_check_auido_speaker_input_.Checked)
{
NTSmartPublisherSDK.NT_PB_SetCaptureSpeakerCompensateMute(publisher_handle_, 1);
}
if (btn_check_speex_encoder_.Checked)
{
NTSmartPublisherSDK.NT_PB_SetPublisherAudioCodecType(publisher_handle_, 2);
NTSmartPublisherSDK.NT_PB_SetPublisherSpeexEncoderQuality(publisher_handle_, Int32.Parse(edit_speex_quality_.Text));
}
else
{
NTSmartPublisherSDK.NT_PB_SetPublisherAudioCodecType(publisher_handle_, 1);
}
if (btn_check_auido_mic_input_.Checked
|| btn_check_auido_speaker_input_.Checked)
{
if (btn_check_set_mute_.Checked)
{
NTSmartPublisherSDK.NT_PB_SetMute(publisher_handle_, 1);
}
}
if (btn_check_echo_cancel_.Checked)
{
NTSmartPublisherSDK.NT_PB_SetEchoCancellation(publisher_handle_, 1, Int32.Parse(edit_echo_delay_.Text));
}
else
{
NTSmartPublisherSDK.NT_PB_SetEchoCancellation(publisher_handle_, 0, 0);
}
if (btn_check_noise_suppression_.Checked)
{
NTSmartPublisherSDK.NT_PB_SetNoiseSuppression(publisher_handle_, 1);
}
else
{
NTSmartPublisherSDK.NT_PB_SetNoiseSuppression(publisher_handle_, 0);
}
if (btn_check_agc_.Checked)
{
NTSmartPublisherSDK.NT_PB_SetAGC(publisher_handle_, 1);
}
else
{
NTSmartPublisherSDK.NT_PB_SetAGC(publisher_handle_, 0);
}
if (btn_check_vad_.Checked)
{
NTSmartPublisherSDK.NT_PB_SetVAD(publisher_handle_, 1);
}
else
{
NTSmartPublisherSDK.NT_PB_SetVAD(publisher_handle_, 0);
}
if (btn_check_auido_mic_input_.Checked
&& btn_check_auido_speaker_input_.Checked)
{
NTSmartPublisherSDK.NT_PB_SetInputAudioVolume(publisher_handle_, 0, Convert.ToSingle(edit_audio_input_volume_.Text));
NTSmartPublisherSDK.NT_PB_SetInputAudioVolume(publisher_handle_, 1, Convert.ToSingle(edit_audio_speaker_input_volume_.Text));
}
else if (btn_check_auido_mic_input_.Checked)
{
NTSmartPublisherSDK.NT_PB_SetInputAudioVolume(publisher_handle_, 0, Convert.ToSingle(edit_audio_input_volume_.Text));
}
else if (btn_check_auido_speaker_input_.Checked)
{
NTSmartPublisherSDK.NT_PB_SetInputAudioVolume(publisher_handle_, 0, Convert.ToSingle(edit_audio_speaker_input_volume_.Text));
}
获取视频码率默认值，不是每个开发者都有音视频开发背景，如果不想自行设置码率等一些参数，可参考我们的码率设定。
private void FillBitrateControlDefValue()
{
int w = 640, h = 480;
int frame_rate = 5;
bool is_var_bitrate = false;
GetVideoConfigInfo(ref w, ref h, ref frame_rate, ref is_var_bitrate);
if (btn_check_openh264_encoder_.Checked)
{
is_var_bitrate = false;
}
int kbit_rate = CalBitRate(frame_rate, w, h);
int max_kbit_rate = CalMaxKBitRate(frame_rate, w, h, is_var_bitrate);
if (is_var_bitrate)
{
btn_check_video_bitrate_.CheckState = CheckState.Unchecked;
}
else
{
btn_check_video_bitrate_.CheckState = CheckState.Checked;
}
if (is_var_bitrate)
{
edit_bit_rate_.Enabled = false;
edit_video_quality_.Enabled = true;
}
else
{
edit_bit_rate_.Enabled = true;
edit_video_quality_.Enabled = false;
}
if (btn_check_video_bitrate_.Checked)
{
edit_bit_rate_.Text = kbit_rate.ToString();
edit_video_max_bitrate_.Text = max_kbit_rate.ToString();
}
else
{
edit_bit_rate_.Text = "0";
edit_video_max_bitrate_.Text = max_kbit_rate.ToString();
}
bool is_h264 = false;
if (btn_check_h265_encoder_.Checked)
{
is_h264 = false;
}
else
{
is_h264 = true;
}
edit_video_quality_.Text = CalVideoQuality(w, h, is_h264).ToString();
combox_h264_profile_.SelectedIndex = 2;
edit_video_encode_speed_.Text = CalVideoEncoderSpeed(w, h, is_h264).ToString();
// 默认关键帧间隔设置为帧率的2倍
edit_key_frame_.Text = (frame_rate * 2).ToString();
}
设置推送URL后，调用StartPublisher接口开始推流，如需发送扩展SEI用户数据，推送之前设置下数据发送对接大小。
if (publisher_handle_ == IntPtr.Zero)
{
MessageBox.Show("[publish] handle with null");
}
if (!String.IsNullOrEmpty(url))
{
NTSmartPublisherSDK.NT_PB_SetURL(publisher_handle_, url, IntPtr.Zero);
}
//设置用户数据发送队列大小
NTSmartPublisherSDK.NT_PB_SetPostUserDataQueueMaxSize(publisher_handle_, 3, 0);
if (NTBaseCodeDefine.NT_ERC_OK != NTSmartPublisherSDK.NT_PB_StartPublisher(publisher_handle_, IntPtr.Zero))
{
if (0 == publisher_handle_count_)
{
NTSmartPublisherSDK.NT_PB_Close(publisher_handle_);
publisher_handle_ = IntPtr.Zero;
}
is_publishing_ = false;
MessageBox.Show("调用推流接口失败");
return;
}
调用NT_PB_StopPublisher()即可，停止推送后，如果没有录像等，可调用NT_PB_Close()接口，关掉实例，并把handle置 IntPtr.Zero。
private void btn_stop_publish_Click(object sender, EventArgs e)
{
publisher_handle_count_--;
NTSmartPublisherSDK.NT_PB_StopPublisher(publisher_handle_);
rtmp_play_urls_.Clear();
UpdateDisplayURLs();
if (0 == publisher_handle_count_)
{
NTSmartPublisherSDK.NT_PB_Close(publisher_handle_);
publisher_handle_ = IntPtr.Zero;
}
btn_publish.Enabled = true;
btn_stop_publish.Enabled = false;
is_publishing_ = false;
if (0 == publisher_handle_count_)
{
if (btn_check_desktop_input_.Checked)
{
btn_choose_screen_region_.Text = "选择屏幕区域";
}
btn_check_dxgi_screen_capturer_.Enabled = true;
check_capture_layered_window_.Enabled = true;
btn_check_wr_way_capture_window_.Enabled = true;
btn_desktop_camera_switch_.Text = "切换到摄像头";
btn_disable_image_watermark_.Text = "停止水印";
btn_disable_camera_overlay_.Text = "停止叠加摄像头";
btn_disable_desktop_overlay_.Text = "停止叠加屏幕";
btn_desktop_camera_switch.Enabled = true;
btn_camera_overlay_to_desktop.Enabled = true;
btn_desktop_overlay_to_camera.Enabled = true;
btn_desktop_camera_switch.Enabled = true;
btn_check_desktop_input_.Enabled = true;
btn_check_scale_desktop_.Enabled = true;
edit_desktop_scale_.Enabled = true;
btn_check_camera_input_.Enabled = true;
btn_add_image_watermark_.Enabled = true;
timer_clock_.Enabled = false;
if (btn_desktop_camera_switch.Checked
|| btn_camera_overlay_to_desktop.Checked
|| btn_desktop_overlay_to_camera.Checked)
{
btn_check_desktop_input_.CheckState = CheckState.Checked;
btn_check_camera_input_.CheckState = CheckState.Checked;
}
else
{
}
EnableAuidoInputControl();
}
}
设置NT_PB_SetVideoPreviewImageCallBack()，调用NT_PB_StartPreview()接口即可。
private void btn_preview_Click(object sender, EventArgs e)
{
if (btn_check_window_input_.Checked)
{
if (IntPtr.Zero == cur_sel_capture_window_)
{
MessageBox.Show("请先下拉选择采集窗口");
return;
}
}
if (publisher_handle_ == IntPtr.Zero)
{
if (!OpenPublisherHandle())
{
return;
}
}
if (publisher_handle_count_ < 1)
{
SetCommonOptionToPublisherSDK();
}
video_preview_image_callback_ = new NT_PB_SDKVideoPreviewImageCallBack(SDKVideoPreviewImageCallBack);
NTSmartPublisherSDK.NT_PB_SetVideoPreviewImageCallBack(publisher_handle_, (int)NTSmartPublisherDefine.NT_PB_E_IMAGE_FORMAT.NT_PB_E_IMAGE_FORMAT_RGB32, IntPtr.Zero, video_preview_image_callback_);
if (NTBaseCodeDefine.NT_ERC_OK != NTSmartPublisherSDK.NT_PB_StartPreview(publisher_handle_, 0, IntPtr.Zero))
{
if (0 == publisher_handle_count_)
{
NTSmartPublisherSDK.NT_PB_Close(publisher_handle_);
publisher_handle_ = IntPtr.Zero;
}
MessageBox.Show("预览失败, 请确保选择了视频采集选项");
return;
}
publisher_handle_count_++;
btn_preview.Enabled = false;
btn_stop_preview.Enabled = true;
if (1 == publisher_handle_count_)
{
if (btn_check_desktop_input_.Checked)
{
btn_choose_screen_region_.Text = "移动屏幕区域";
}
btn_check_dxgi_screen_capturer_.Enabled = false;
check_capture_layered_window_.Enabled = false;
btn_check_wr_way_capture_window_.Enabled = false;
btn_desktop_camera_switch.Enabled = false;
btn_camera_overlay_to_desktop.Enabled = false;
btn_desktop_overlay_to_camera.Enabled = false;
btn_add_image_watermark_.Enabled = false;
if (btn_desktop_camera_switch.Checked
|| btn_camera_overlay_to_desktop.Checked
|| btn_desktop_overlay_to_camera.Checked)
{
}
else
{
btn_check_desktop_input_.Enabled = false;
btn_check_camera_input_.Enabled = false;
}
DisableAuidoInputControl();
}
if (ui_preview_wnd_ == null)
{
ui_preview_wnd_ = new nt_pb_ui_preview_wnd();
}
ui_preview_wnd_.Show();
}
public void VideoPreviewImageCallBack(NT_VideoFrame frame)
{
if (cur_image_.plane_ != IntPtr.Zero)
{
Marshal.FreeHGlobal(cur_image_.plane_);
cur_image_.plane_ = IntPtr.Zero;
}
cur_image_ = frame;
if (ui_preview_wnd_ != null)
{
ui_preview_wnd_.OnRGBXImage(cur_image_);
}
}
public void SDKVideoPreviewImageCallBack(IntPtr handle, IntPtr user_data, IntPtr image)
{
NT_PB_Image pb_image = (NT_PB_Image)Marshal.PtrToStructure(image, typeof(NT_PB_Image));
NT_VideoFrame pVideoFrame = new NT_VideoFrame();
pVideoFrame.width_ = pb_image.width_;
pVideoFrame.height_ = pb_image.height_;
pVideoFrame.stride_ = pb_image.stride_[0];
Int32 argb_size = pb_image.stride_[0] * pb_image.height_;
pVideoFrame.plane_ = Marshal.AllocHGlobal(argb_size);
CopyMemory(pVideoFrame.plane_, pb_image.plane_[0], (UInt32)argb_size);
if (InvokeRequired)
{
BeginInvoke(set_video_preview_image_callback_, pVideoFrame);
}
else
{
set_video_preview_image_callback_(pVideoFrame);
}
}
停止预览更简单，调用NT_PB_StopPreview()。
private void btn_stop_preview_Click(object sender, EventArgs e)
{
publisher_handle_count_--;
NTSmartPublisherSDK.NT_PB_StopPreview(publisher_handle_);
if (0 == publisher_handle_count_)
{
NTSmartPublisherSDK.NT_PB_Close(publisher_handle_);
publisher_handle_ = IntPtr.Zero;
}
btn_preview.Enabled = true;
btn_stop_preview.Enabled = false;
if (0 == publisher_handle_count_)
{
if (btn_check_desktop_input_.Checked)
{
btn_choose_screen_region_.Text = "选择屏幕区域";
}
btn_check_dxgi_screen_capturer_.Enabled = true;
check_capture_layered_window_.Enabled = true;
btn_check_wr_way_capture_window_.Enabled = true;
btn_desktop_camera_switch_.Text = "切换到摄像头";
btn_disable_image_watermark_.Text = "停止水印";
btn_disable_camera_overlay_.Text = "停止叠加摄像头";
btn_disable_desktop_overlay_.Text = "停止叠加屏幕";
btn_desktop_camera_switch.Enabled = true;
btn_camera_overlay_to_desktop.Enabled = true;
btn_desktop_overlay_to_camera.Enabled = true;
btn_desktop_camera_switch.Enabled = true;
btn_check_desktop_input_.Enabled = true;
btn_check_camera_input_.Enabled = true;
btn_add_image_watermark_.Enabled = true;
timer_clock_.Enabled = false;
if (btn_desktop_camera_switch.Checked
|| btn_camera_overlay_to_desktop.Checked
|| btn_desktop_overlay_to_camera.Checked)
{
btn_check_desktop_input_.CheckState = CheckState.Checked;
btn_check_camera_input_.CheckState = CheckState.Checked;
}
else
{
}
EnableAuidoInputControl();
}
ui_preview_wnd_.Hide();
ui_preview_wnd_ = null;
}
if (String.IsNullOrEmpty(capture_image_path_))
{
MessageBox.Show("请先设置保存截图文件的目录! 点击截图左边的按钮设置!");
return;
}
if (publisher_handle_ == IntPtr.Zero)
{
return;
}
String name = capture_image_path_ + "\\" + DateTime.Now.ToString("hh-mm-ss") + ".png";
byte[] buffer1 = Encoding.Default.GetBytes(name);
byte[] buffer2 = Encoding.Convert(Encoding.Default, Encoding.UTF8, buffer1, 0, buffer1.Length);
byte[] buffer3 = new byte[buffer2.Length + 1];
buffer3[buffer2.Length] = 0;
Array.Copy(buffer2, buffer3, buffer2.Length);
IntPtr file_name_ptr = Marshal.AllocHGlobal(buffer3.Length);
Marshal.Copy(buffer3, 0, file_name_ptr, buffer3.Length);
capture_image_call_back_ = new NT_PB_SDKCaptureImageCallBack(SDKCaptureImageCallBack);
UInt32 ret = NTSmartPublisherSDK.NT_PB_CaptureImage(publisher_handle_, file_name_ptr, IntPtr.Zero, capture_image_call_back_);
Marshal.FreeHGlobal(file_name_ptr);
if (NT.NTBaseCodeDefine.NT_ERC_OK == ret)
{
// 发送截图请求成功
}
else if ((UInt32)NT.NTSmartPublisherDefine.NT_PB_E_ERROR_CODE.NT_ERC_PB_TOO_MANY_CAPTURE_IMAGE_REQUESTS == ret)
{
// 通知用户延时
MessageBox.Show("Too many capture image requests!");
}
else
{
// 其他失败
}
private void ImageCallBack(UInt32 result, String file_name)
{
if (file_name == null && file_name.Length == 0)
return;
MessageBox.Show(file_name);
}
public void SDKCaptureImageCallBack(IntPtr handle, IntPtr userData, UInt32 result, IntPtr file_name)
{
if (file_name == IntPtr.Zero)
return;
int index = 0;
while (true)
{
if (0 == Marshal.ReadByte(file_name, index))
break;
index++;
}
byte[] file_name_buffer = new byte[index];
Marshal.Copy(file_name, file_name_buffer, 0, index);
byte[] dst_buffer = Encoding.Convert(Encoding.UTF8, Encoding.Default, file_name_buffer, 0, file_name_buffer.Length);
String image_name = Encoding.Default.GetString(dst_buffer, 0, dst_buffer.Length);
if (InvokeRequired)
{
BeginInvoke(set_capture_image_call_back_, result, image_name);
}
else
{
set_capture_image_call_back_(result, image_name);
}
}
1视频采集设置
说明：
1. 屏幕和摄像头相互切换：用于在线教育或者无纸化等场景，推送或录像过程中，随时切换屏幕或摄像头数据（切换数据源），如需实时切换，点击页面“切换到摄像头”按钮即可；
2. 设置遮盖层，用于设定一个长方形或正方形区域（可自指定区域大小），遮盖不想给用户展示的部分；
3. 水印：添加PNG水印，支持推送或录像过程中，随时添加、取消水印；
4. 摄像头叠加到屏幕：意在用于同屏过程中，主讲人摄像头悬浮于屏幕之上（可指定叠加坐标），实现双画面展示，推送或录像过程中，可以随时取消摄像头叠加；
5. 屏幕叠加到摄像头：同4，效果展示，实际根据需求实现；
6. 采集桌面：可以通过点击“选择屏幕区域”获取采集区域，并可在采集过程中，随时切换区域位置，如不设定，默认全屏采集；
7. 使用DXGI采集屏幕，采集时停用Aero；
8. 采集窗口：可设定需要采集的窗口，窗口放大或缩小，推送端会自适应码率和分辨率；
9. 采集帧率(帧/秒)：默认屏幕采集12帧，可根据实际场景需求设定到期望帧率；
10. 缩放屏幕大小缩放比：用于高清或超高清屏，通过设定一定的比例因子，缩放屏幕采集分辨率；
11. 采集摄像头：可选择需要采集的摄像头、采集分辨率、帧率、是否需要水平或者垂直反转、是否需要旋转；
追加提问：
问题[确认数据源]：采集桌面还是摄像头？如果桌面，全屏还是部分区域？
回答：
如果是摄像头：可以选择摄像头列表，然后分辨率、帧率。
如果是屏幕：默认帧率是12帧，可以根据实际场景调整，选取屏幕区域，可以实时拉取选择需要采集或录像区域；
如果是叠加模式：可选择摄像头叠加到屏幕，还是屏幕叠加到摄像头；
更高需求的用户，可以设置水印或应用层遮盖。
问题：如果是摄像头，采集到的摄像头角度不对怎么办？
回答：我们支持摄像头镜像和翻转设置，摄像头可通过SDK接口轻松实现水平/垂直翻转、镜像效果。
2 视频码率控制
如何选择适合我的码率？
回答：如果不是有音视频背景的开发人员，可点击“获取视频码率默认值”，参考我们默认的码率推荐，如果觉得推荐码率过高或不够，可根据实际情况酌情调整。
265编码还是H.264编码？
回答：Windows平台支持H.265特定机型硬编码，如果推RTMP流，需要服务器支持RTMP H.265扩展，播放器SDK，也需要同步支持RTMP H.265扩展播放。
如果是轻量级RTSP服务SDK对接的话，只需要播放器支持RTSP H.265即可。
如果推摄像头数据，建议采用可变码率+H.265编码。
如何设置码率参数更合理？
回答：
关键帧间隔：一般来说，设置到帧率的2-4倍，比如帧率20，关键帧间隔可以设置到40-80；
平均码率：可以点击“获取视频码率默认值”，最大码率是平均码率的2倍；
视频质量：如果使用可变码率，建议采用大牛直播SDK默认推荐视频质量值；
编码速度：如高分辨率，建议1-3，值越小，编码速度越快；
H.264 Profile：默认baseline profile，可根据需要，酌情设置High profile；
NOTE：点击“推送”或“录像”或启动内置RTSP服务SDK之前，请务必设置视频码率，如不想手动设置，请点击“获取视频码率默认值”！！！
3 音频采集设置
问答式：采集音频吗？如果采集，采集麦克风还是扬声器的，亦或混音？
回答：
如果想采集电脑输出的音频（比如音乐之类），可以选择“采集扬声器”；
如果想采集麦克风音频，可以选择“采集麦克风”，并选择相关设备；
如果两个都想采集，可以两个都选择，混音输出。
4 实时音量调节
问答式：采集过程中可以改变麦克风或扬声器采集音量吗？
回答：可以，如果二者都选中，处于混音模式，也可单独调整麦克风或扬声器音量。
5 音频编码
问题：是AAC还是SPEEX？
回答：我们默认是AAC编码模式，如果需要码率更低，可以选择SPEEX编码模式，当然我们的AAC编码码率也不高，如果没有太高要求，考虑到通用性，建议使用AAC。
6 音频处理
问题：我想过滤背景噪音怎么办？
回答：选中“噪音抑制”，“噪音抑制“请和“自动增益控制”组合使用，“端点检测(VAD)”可选设置。
问题：我想做一对一互动怎么办？
回答：选中“回音消除”，可以和“噪音抑制”、“自动增益控制”组合使用，具体可参看回音消除的demo工程：WIN-EchoCancellation-CSharp-Demo。
问题：我推送或者录像过程中，随时静音怎么办？
回答：推送过程中，随时选择或取消选择“静音”功能。
7多路推送
问题：我想同时推送到多个url怎么办(比如一个内网服务器，一个外网服务器)？
回答：同时填写多个url（最多3个），然后点推送即可。
8 截图(快照)
问题：我想推送或者录像过程中，截取当前图像怎么办？
回答：那就设置好截图路径，推送或录像过程中，随时点击“截图”。
9 录像
问题：我还想录像，怎么办？
回答：设置录像文件存放目录，文件前缀、单个文件大小，是否加日期、时间，随时录制即可，此外，我们的SDK还支持录像过程中，暂停录像，恢复录像。
10 实时预览
问题：我还想看看推出去视频，特别是合成后的效果，怎么办？
回答：点击页面的“预览”按钮，就可以看到。
最近发现好多开发者都在搜索可用的RTSP测试URL，目前公网实际可测试的RTSP URL非常少，即便是可用，分辨率和网络也非常差，不适合长期测试。
针对此，我们的建议是最好直接网上买个海康或大华的摄像头，一般来说，海康大华的RTSP URL格式如下：
主码流：rtsp://admin:daniulive12345@192.168.0.120:554/h265/ch1/main/av_stream
子码流：rtsp://admin:daniulive12345@192.168.0.120:554/h264/ch1/sub/av_stream
rtsp://[username]:[password]@[ip]:[port]/[codectype]/[channel]/[subtype]/av_stream
URL组成说明：
username: 用户名；
password: 密码；
ip: 网络摄像机IP地址；
port: 端口号，默认554；
codectype：有h264/h265/mjpeg；
channel: 通道号。
subtype: 码流类型，主码流：main，子码流：sub。
主码流：rtsp://admin:admin123456@192.168.0.121:554/cam/realmonitor?channel=1&subtype=0
子码流：rtsp://admin:admin123456@192.168.0.121:554/cam/realmonitor?channel=1&subtype=1
rtsp://[username]:[password]@[ip]:[port]/cam/realmonitor?/[channel]&/[subtype]
URL组成说明：
username: 用户名；
password: 密码；
ip: 网络摄像机IP地址；
port: 端口号，默认554；
codectype：有h264/h265/mjpeg；
channel: 通道号。
subtype: 码流类型，主码流：0，子码流：1。
如果想采集PC摄像头或者屏幕，也可以本地用轻量级RTSP服务，本地生成个RTSP测试URL。常用的方式，比如VLC串流，或者大牛直播SDK（URL）的Windows平台SmartPublisherDemo生成即可。
本文就以SmartPublisherDemo轻量级RTSP服务采集本地摄像头为例，说明下如何创建个本地测试的RTSP地址。
1. 选中采集摄像头，并选择需要测试的分辨率、帧率，点击“获取视频码率默认值”，得到系统推荐的码率（高级用户也可自行配置），如需要采集audio，看采集麦克风还是扬声器的，如果二者均需采集，同时选中即可（混音模式）。
2. 点击“配置查看Rtsp服务”按钮，在弹出框点击“启动服务”即可，可启动一组也可启动多组，每个服务对应一个RTSP URL。
3. 确定后，点击“发布RTSP流”按钮即可，发布后，可本地生成个RTSP URL，以本机为例，生成的URL是“rtsp://192.168.0.211:8554/stream1”。
4. 启动播放端，输入生成的RTSP URL，测试即可。
5.服务器负载查看：再次点击“配置查看RTSP服务”，即可看到每个服务连接的会话数：
6. 如需停止服务，点击页面的“停止RTSP流”即可；
是不是非常方便？
轻量级RTSP服务解决的核心痛点是避免用户或者开发者单独部署RTSP或者RTMP服务，实现本地的音视频数据（如摄像头、麦克风），编码后，汇聚到内置RTSP服务，对外提供可供拉流的RTSP URL，轻量级RTSP服务，适用于内网环境下，对并发要求不高的场景，支持H.264/H.265，支持RTSP鉴权、单播、组播模式，考虑到单个服务承载能力，我们支持同时创建多个RTSP服务，并支持获取当前RTSP服务会话连接数。
设计功能：
感兴趣的开发者，可以自行尝试。
欢迎使用上海视沃信息科技有限公司（以下简称“视沃科技”）旗下“大牛直播SDK”，试用测试前，请您仔细阅读视沃科技官方网站公布的相关规范和使用流程及本协议的全部内容，如您不同意前述任意内容，请不要进行后续操作。如您实际使用了“大牛直播SDK”，我方将视为您已完全理解并认同规范、流程及服务协议的全部内容。
本服务协议是因您使用大牛直播SDK与视沃科技所订立的有效合约。
一旦您选择试用、测试大牛直播SDK并进行后续操作，即表示您同意遵循本服务协议之所有约定，本协议即成为双方之间就大牛直播SDK软件包服务达成的有效合约。
3.1 在试用测试大牛直播SDK软件包服务前，您应知悉阅读视沃科技官网页面上的相关规范、使用流程，并理解相关内容及可能发生的后果，在使用大牛直播SDK软件包服务的过程中，您应依照相关操作指引进行操作，请您自行把握风险谨慎操作。
3.2您理解并同意，使用大牛直播SDK软件服务包是您自行独立审慎判断的结果，您将自行对此负责，包括但不限于：
3.2.1在使用过程中，您将对自行操作的行为及产生的结果负责；
3.2.1在试用、测试大牛直播SDK软件服务包阶段可免费使用，但正式授权版需签订购买合同并支付相关费用；
3.2.3在使用大牛直播SDK软件包过程中，您不应进行任何破坏或试图破坏网络安全的行为，您承诺SDK试用、测试及授权后的使用场景保持一致且视频内容合法合规，不得含有我国法律、行政法规禁止发布或传输的信息，为履行法律赋予的安全管理义务，请您下载填写附件1并将签章后的附件1发至指定邮箱；
3.2.4除视沃科技明示许可外，不得修改、翻译、改编、转许可、转让大牛直播SDK软件服务包，也不得逆向工程、反编译或试图以其他方式发现大牛直播SDK软件服务包或软件源代码；
3.2.5您不应以任何将违反国家、地方法律法规、行业管理和社会公共道德、及影响、损害或可能影响、损害视沃科技利益的方式或目的使用大牛直播SDK。
您理解并同意，在免费测试、试用其间，视沃科技虽然对大牛直播SDK软件包服务提供可用性支撑，但不对其中任何错误或漏洞提供任何担保，并不对您使用大牛直播SDK软件服务包的工作和结果承担任何责任。
5.1 您理解并认可，视沃科技保留随时修改、取消、增强大牛直播SDK软件包服务一项或多项功能的权利；
5.2如您有任何违反本服务协议的情形，或根据视沃科技自己的独立判断认为您对大牛直播SDK的使用行为不符合我司要求，我司有权随时中断您使用大牛直播SDK而无需通知您，并将相关情况向有关主管部门报告；同时，如给我司造成损失，我司有权要求赔偿。
您及视沃科技都应对对方的保密信息承担保密责任，除非经国家行政、司法等有权机关要求披露或该信息已进入公有领域。
7.1视沃科技有权随时根据有关法律、法规的变化及公司经营状况和经营策略的调整等修改本服务协议。修改后的服务协议会在视沃科技官网公布。如果不同意修改的内容，您应停止使用大牛直播SDK软件包服务。如果继续使用大牛直播SDK软件包，则视为您接受本服务协议的变动。
7.2如果本服务协议中的任何条款无论因何种原因完全或部分无效或不具有执行力，或违反任何适用的法律，则该条款被视为删除，但本服务协议的其余条款仍应有效并且有约束力。
7.3本服务协议受中华人民共和国法律管辖。在执行本服务协议过程中如发生纠纷，双方应及时协商解决。协商不成时，任何一方可直接向上海市长宁区人民法院提起诉讼。
附件1：
附件1请发送至 1130758427@qq.com
甲方签章
xxxx年xx月xx日
C++头文件：
C#头文件：
相关Lib：
集成步骤：
lib目录如下：
2. 相关cs头文件，加入需要集成的工程；
3. 在需要集成的工程，右键->Properties->
Application->Assembly name，大牛直播SDK按照APP名称授权，未授权版本，此处请改成“SmartPlayer”，如需授权，可直接联系商务；
4. 正式授权版，需要在Init()接口调用之前添加设置license的代码（相关Key和CID请根据正式授权版邮件说明填写）：
C#的SDK，请在在NT.NTSmartPlayerSDK.NT_SP_Init之前添加下面的代码：
C++的SDK，请在player_api_.Init之前添加下面的代码：
需要在player_api_.Init之前添加下面的代码：
如目录存在，并具备文件写入权限，关闭应用程序后，相关文件夹下会有smart_sdk.log生成。
NT_SP_Init：SDK初始化，多实例播放，此接口仅需调用一次即可。
如系统用于特定机型环境下，特别是多路播放场景，需用到硬解码的话，可以用以下两组接口检测系统是否支持硬解。
注：在软解性能满足系统需求的前提下，一般建议优先使用软解。
如需使用硬解码，调用如下接口即可：
NT_SP_Open：每调用一次Open接口，对应一个播放实例，如需播放多实例，对应多个player handler。
注意：视频宽高回上来或绘制窗口发生变化时，记得调用NT_SP_OnWindowSize()更新，如不调用可能会引起视频模糊。
目前，几乎很少存在不支持D3D绘制的情况，考虑到系统通用性，我们在播放之前，先做检测，具体调用接口如下：
对于不支持D3D绘制的情况下，设置回调YUV数据，上层直接用GDI模式绘制，注意：GDI绘制效率偏低。
NT_SP_SetURL：支持rtsp/rtmp/本地FLV文件(全路径)。
NT_SP_SetIsOutputAudioDevice：设置是否播放出声音，这个和静音接口是有区别的，这个接口的主要目的是为了用户设置了外部PCM回调接口后，又不想让SDK播放出声音时使用。
具体可参照Demo源码里面InitCommonSDKParam()：
2.4.10.1 播放前可选设置接口
* is_report: 上报开关, 1: 表上报. 0: 表示不上报. 其他值无效.
* report_interval： 上报时间间隔（上报频率），单位是秒，最小值是1秒1次. 如果小于1且设置了上报，将调用失败
* 注意：如果设置上报的话，请设置SetEventCallBack, 然后在回调函数里面处理这个事件.
* 上报事件是：NT_SP_E_EVENT_ID_DOWNLOAD_SPEED
2.4.10.2 播放前后可实时调用的接口
NT_SP_StartPlay
开始播放RTMP或RTSP流数据。
NT_SP_CaptureImage
用于播放端实时截取当前播放图片，图片以PNG形式保存至本地。
NT_SP_SwitchURL
快速切换URL，用于不用析构整个player实例的前提下，实时切换播放的URL。
NT_SP_SetUserDataCallBack
设置用户数据回调，用于接收扩展SEI模块发送的用户数据信息，如不是配合我们扩展SEI发送DK，此接口无需调用。
NT_SP_SetSEIDataCallBack
设置视频sei数据回调，用于接收SEI数据回调，如流数据不存在SEI或不准备处理SEI数据，此接口无需调用。
NT_SP_StopPlay
停止播放RTMP或RTSP流数据。
NT_SP_Close
调用Close接口后，player handler置空。
NT_SP_UnInit
UnInit() 是SDK最后一个调用的接口，多实例环境下，只需要调用一次即可。
好多开发者一直反馈，Windows平台，做个推屏或者推摄像头，推RTMP或者RTSP出去，不知道哪些功能是必须的，哪些设计是可有可无的，还有就是，不知道如何选技术方案，以下是基于我们设计的Windows平台RTSP、RTMP直播推送模块，设计和使用说明，供大家参考。
Windows平台RTMP或RTSP推送，系采集端模块，主要完成，屏幕或者摄像头数据、麦克风或扬声器数据的采集，编码，然后按照特定格式打包，通过RTMP或者RTSP传输出去，实现直播目的。
对应设计架构图的“发布端”，编码后的音视频数据，按照协议打包后，推送到流媒体服务器（如RTMP服务器，自建服务，可以考虑SRS或者nginx服务器，如果是RTSP服务器，可以考虑苹果官方的darwin streaming server）。
这种方案的设计，一般是一对多设计模型，接收端接收RTMP或RTSP流，然后解析音视频数据，解码、同步音视频数据，并绘制，实现整体的直播解决方案。
以下是设计架构图：
demo说明
C++头文件：
C#头文件：
相关Lib：
lib目录如下：
2. 相关cs头文件，加入需要集成的工程；
3. 在需要集成的工程，右键->Properties->Application->Assembly name，写入“SmartPulisherDemo”。
考虑到Windows平台推送端SDK功能相对复杂，以问答式：
1视频采集设置
1. 屏幕和摄像头相互切换：用于在线教育或者无纸化等场景，推送或录像过程中，随时切换屏幕或摄像头数据（切换数据源），如需实时切换，点击页面“切换到摄像头”按钮即可；
2. 设置遮盖层，用于设定一个长方形或正方形区域（可自指定区域大小），遮盖不想给用户展示的部分；
3. 水印：添加PNG水印，支持推送或录像过程中，随时添加、取消水印；
4. 摄像头叠加到屏幕：意在用于同屏过程中，主讲人摄像头悬浮于屏幕之上（可指定叠加坐标），实现双画面展示，推送或录像过程中，可以随时取消摄像头叠加；
5. 屏幕叠加到摄像头：同4，效果展示，实际根据需求实现；
6. 采集桌面：可以通过点击“选择屏幕区域”获取采集区域，并可在采集过程中，随时切换区域位置，如不设定，默认全屏采集；
7. 使用DXGI采集屏幕，采集时停用Aero；
8. 采集窗口：可设定需要采集的窗口，窗口放大或缩小，推送端会自适应码率和分辨率；
9. 采集帧率(帧/秒)：默认屏幕采集8帧，可根据实际场景需求设定到期望帧率；
10. 缩放屏幕大小缩放比：用于高清或超高清屏，通过设定一定的比例因子，缩放屏幕采集分辨率；
11. 采集摄像头：可选择需要采集的摄像头、采集分辨率、帧率、是否需要水平或者垂直反转、是否需要旋转；
追加提问：
问题[确认数据源]：采集桌面还是摄像头？如果桌面，全屏还是部分区域？
回答：
如果是摄像头：可以选择摄像头列表，然后分辨率、帧率。
如果是屏幕：默认帧率是5帧，可以根据实际场景调整，选取屏幕区域，可以实时拉取选择需要采集或录像区域；
如果是叠加模式：可选择摄像头叠加到屏幕，还是屏幕叠加到摄像头；
更高需求的用户，可以设置水印或应用层遮盖。
问题：如果是摄像头，采集到的摄像头角度不对怎么办？
回答：我们支持摄像头镜像和翻转设置，摄像头可通过SDK接口轻松实现水平/垂直翻转、镜像效果。
2 视频码率控制
我选可变码率还是平均码率？
回答：可变码率的优势在于，如果屏幕或摄像头变化不大，码率超低，特别是H.265编码，平均码率，码率比较均匀，需设置平均码率+最大码率，一般摄像头采集建议选择可变码率，屏幕采集选择平均码率，如需采用可变码率，请取消“使用平均码率”选项。
265编码还是H.264编码？
回答：Windows 64位库支持H.265编码，如果推RTMP流，需要服务器支持RTMP H.265扩展，播放器SDK，也需要同步支持RTMP H.265扩展播放。
如果是轻量级RTSP服务SDK对接的话，只需要播放器支持RTSP H.265即可。
如果推摄像头数据，建议采用可变码率+H.265编码。
如何设置码率参数更合理？
回答：
关键帧间隔：一般来说，设置到帧率的2-4倍，比如帧率20，关键帧间隔可以设置到40-80；
平均码率：可以点击“获取视频码率默认值”，最大码率是平均码率的2倍；
视频质量：如果使用可变码率，建议采用大牛直播SDK默认推荐视频质量值；
编码速度：如高分辨率，建议1-3，值越小，编码速度越快；
H.264 Profile：默认baseline profile，可根据需要，酌情设置High profile；
NOTE：点击“推送”或“录像”或启动内置RTSP服务SDK之前，请务必设置视频码率，如不想手动设置，请点击“获取视频码率默认值”！！！
3 音频采集设置
问答式：采集音频吗？如果采集，采集麦克风还是扬声器的，亦或混音？
回答：
如果想采集电脑输出的音频（比如音乐之类），可以选择“采集扬声器”；
如果想采集麦克风音频，可以选择“采集麦克风”，并选择相关设备；
如果两个都想采集，可以两个都选择，混音输出。
4 音频编码
问题：是AAC还是SPEEX？
回答：我们默认是AAC编码模式，如果需要码率更低，可以选择SPEEX编码模式，当然我们的AAC编码码率也不高。
5 音频处理
问题：我想过滤背景噪音怎么办？
回答：选中“噪音抑制”，“噪音抑制“请和“自动增益控制”组合使用，“端点检测(VAD)”可选设置。
问题：我想做一对一互动怎么办？
回答：选中“回音消除”，可以和“噪音抑制”、“自动增益控制”组合使用。
问题：我推送或者录像过程中，随时静音怎么办？
回答：推送过程中，随时选择或取消选择“静音”功能。
6多路推送
问题：我想同时推送到多个url怎么办(比如一个内网服务器，一个外网服务器)？
回答：同时填写多个url，然后点推送即可。
7 截图(快照)
问题：我想推送或者录像过程中，截取当前图像怎么办？
回答：那就设置好截图路径，推送或录像过程中，随时点击“截图”。
8 录像
问题：我还想录像，怎么办？
回答：设置录像文件存放目录，文件前缀、单个文件大小，是否加日期、时间，随时录制即可，此外，我们的SDK还支持录像过程中，暂停录像，恢复录像。
9 实时预览
问题：我还想看看视频特别是合成后的效果，怎么办？
回答：点击页面的“预览”按钮，就可以看到。
如需下载demo源码工程，可以到 Github 下载 “Windows平台RTMP|RTSP推送SDK、内置RTSP服务SDK、录像SDK”，C++或者C#的都有。
NT_PB_Init
如需配置log路径，请在NT_PB_Init之前，做如下设置（目录可自行指定）：
// 设置日志路径(请确保目录存在)
//String log_path = “D:\\pulisherlog”;
//NTSmartLog.NT_SL_SetPath(log_path);
NT_PB_Open
在多个实例推送多路时，对于一个摄像头来说,所有实例只能共享摄像头，那么只有一个实例可以改变摄像头分辨率，其他实例使用这个缩放后的图像；
在使用多实例时，调用这个接口禁止掉实例的分辨率设置能力.只留一个实例能改变分辨，如果不设置，行为未定义；
这个接口必须在 SetLayersConfig, AddLayerConfig 之前调用。
public enum NT_PB_E_LAYER_TYPE : int
{
NT_PB_E_LAYER_TYPE_SCREEN = 1, // 屏幕层
NT_PB_E_LAYER_TYPE_CAMERA = 2, // 摄像头层
NT_PB_E_LAYER_TYPE_RGBA_RECTANGLE = 3, // RGBA矩形
NT_PB_E_LAYER_TYPE_IMAGE = 4, // 图片层
NT_PB_E_LAYER_TYPE_EXTERNAL_VIDEO_FRAME = 5, // 外部视频数据层
NT_PB_E_LAYER_TYPE_WINDOW = 6, // 窗口层
}
/*定义Video源选项*/
public enum NT_PB_E_VIDEO_OPTION : uint
{
NT_PB_E_VIDEO_OPTION_NO_VIDEO = 0x0,
NT_PB_E_VIDEO_OPTION_SCREEN = 0x1, // 采集屏幕
NT_PB_E_VIDEO_OPTION_CAMERA = 0x2, // 摄像头采集
NT_PB_E_VIDEO_OPTION_LAYER = 0x3, // 视频合并，比如桌面叠加摄像头等
NT_PB_E_VIDEO_OPTION_ENCODED_DATA = 0x4, // 已经编码的视频数据，目前支持H264
NT_PB_E_VIDEO_OPTION_WINDOW = 0x5, // 采集窗口
}
/*定义Auido源选项*/
public enum NT_PB_E_AUDIO_OPTION : uint
{
NT_PB_E_AUDIO_OPTION_NO_AUDIO = 0x0,
NT_PB_E_AUDIO_OPTION_CAPTURE_MIC = 0x1, // 采集麦克风音频
NT_PB_E_AUDIO_OPTION_CAPTURE_SPEAKER = 0x2, // 采集扬声器
NT_PB_E_AUDIO_OPTION_CAPTURE_MIC_SPEAKER_MIXER = 0x3, // 麦克风扬声器混音
NT_PB_E_AUDIO_OPTION_ENCODED_DATA = 0x4, // 编码后的音频数据，目前支持AAC, speex宽带(wideband mode)
}
* 在一些特殊场景下, 视频分辨率会改变, 如果设置一个固定码率的的话,当视频分辨率变大的时候会变的模糊,变小的话又会浪费码率
* 所以提供可以设置一组码率的接口,满足不同分辨率切换的需求
* 规则: 比如设置两组分辨率 640*360, 640*480, 那么当分辨率小于等于640*360时都使用640*360的码率,
* 当分辨率大于640*360且小于等于640*480时，就使用640*480的码率,如果分辨率大于640*480 那就使用640*480的分辨率
* 为了设置的更准确, 建议多划分几组, 让区间变小
* 调用这个接口每次设置一组,设置多组就调用多次
* item对应 NT_PB_VideoEncoderBitrateGroupItem
NT_PB_SetURL：rtmp推送url设置
NT_PB_StartPublisher
NT_PB_StopPublisher：注意，此接口和NT_PB_StartPublisher配套使用
NT_PB_SetPushRtspTransportProtocol：设置推送rtsp传输方式，一般服务器可同时支持RTSP TCP或UDP传输模式，部分服务器只支持TCP或UDP模式。其中，transport_protocol: 1表示UDP传输rtp包; 2表示TCP传输rtp包. 默认是1, UDP传输。
NT_PB_SetPushRtspURL：注意，RTSP推送时，确保服务器推送URL可用。
NT_PB_StartPushRtsp
NT_PB_StopPushRtsp：注意，此接口和NT_PB_StartPushRtsp配套使用。
NT_PB_SetMute：设置推送实时静音
NT_PB_CaptureImage：推送或者录像过程中，实时快照
NT_PB_Close：调用这个接口之后handle失效
NT_PB_UnInit：这个是最后一个调用的接口
以上是我们的设计模块部分资料，感兴趣的开发者，可以酌情参考。
2015年，当我们试图在市面上找一款专供直播播放使用的低延迟播放器，来配合测试我们的RTMP推送模块使用时，居然发现没有一款好用的，市面上的，如VLC或Vitamio，说白了都是基于FFMPEG，在点播这块支持格式很多，也非常优异，但是直播这块，特别是RTMP，延迟要几秒钟，对如纯音频、纯视频播放，快速启播、网络异常状态处理、集成复杂度等各方面，支持非常差，而且因为功能强大，bug很多，除了行业内资深的开发者能驾驭，好多开发者甚至连编译整体环境，都要耗费很大的精力。
我们的直播播放器，始于Windows平台，Android和iOS同步开发，基于上述开源播放器的各种缺点，我们考虑全自研框架，确保整体设计跨平台，再保障播放流程度的前提下，尽可能的做到毫秒级延迟，接口设计三个平台统一化，确保多平台集成复杂度降到最低。
RTMP或RTSP直播播放器，目标很明确，从RTMP服务器（自建服务器或CDN）或RTSP服务器（或NVR/IPC/编码器等）拉取流数据，完成数据解析、解码、音视频数据同步、绘制。
具体对应下图“接收端”部分：
1. 低延迟：大多数RTSP的播放都面向直播场景，所以，如果延迟过大，严重影响体验，所以，低延迟是衡量一个好的RTSP播放器非常重要的指标，目前大牛直播SDK的RTSP直播播放延迟比开源播放器更优异，而且长时间运行下，不会造成延迟累积；
2. 音视频同步处理：有些播放器为了追求低延迟，甚至不做音视频同步，拿到audio video直接播放，导致a/v不同步，还有就是时间戳乱跳等各种问题，大牛直播SDK提供的播放器，具备好的时间戳同步和异常时间戳矫正机制；
3. 支持多实例：大牛直播SDK提供的播放器支持同时播放多路音视频数据，比如4-8-9窗口，大多开源播放器对多实例支持不太友好；
4. 支持buffer time设置：在一些有网络抖动的场景，播放器需要支持buffer time设置，一般来说，以毫秒计，开源播放器对此支持不够友好；
5. TCP/UDP模式设定、自动切换：考虑到好多服务器仅支持TCP或UDP模式，一个好的RTSP播放器需要支持TCP/UDP模式设置，如链接不支持TCP或UDP，大牛直播SDK可自动切换，，开源播放器不具备自动切换TCP/UDP能力；
6. 实时静音：比如，多窗口播放RTSP流，如果每个audio都播放出来，体验非常不好，所以实时静音功能非常必要，开源播放器不具备实时静音功能；
7. 视频view旋转：好多摄像头由于安装限制，导致图像倒置，所以一个好的RTSP播放器应该支持如视频view实时旋转(0° 90° 180° 270°)、水平反转、垂直反转，开源播放器不具备此功能；
8. 支持解码后audio/video数据输出：大牛直播SDK接触到好多开发者，希望能在播放的同时，获取到YUV或RGB数据，进行人脸匹配等算法分析，开源播放器不具备此功能；
9. 实时快照：感兴趣或重要的画面，实时截取下来非常必要，一般播放器不具备快照能力，开源播放器不具备此功能；
10. 网络抖动处理(如断网重连)：稳定的网络处理机制、支持如断网重连等，开源播放器对网络异常处理支持较差；
11. 长期运行稳定性：不同于市面上的开源播放器，大牛直播SDK提供的Windows平台RTSP直播播放SDK适用于数天长时间运行，开源播放器对长时间运行稳定性支持较差；
12. log信息记录：整体流程机制记录到LOG文件，确保出问题时，有据可依，开源播放器几无log记录。
13. 实时下载速度反馈：大牛直播SDK提供音视频流实时下载回调，并可设置回调时间间隔，确保实时下载速度反馈，以此来监听网络状态，开源播放器不具备此能力；
14. 异常状态处理、Event状态回调：如播放的过程中，断网、网络抖动、等各种场景，大牛直播SDK提供的播放器可实时回调相关状态，确保上层模块感知处理，开源播放器对此支持不好；
15. 关键帧/全帧播放实时切换：特别是播放多路画面的时候，如果路数过多，全部解码、绘制，系统资源占用会加大，如果能灵活的处理，可以随时只播放关键帧，全帧播放切换，对系统性能要求大幅降低。
好多开发者，在初期设计接口的时候，如果没有足够的音视频背景，很容易反复推翻之前的设计，我们以Windows平台为例，共享我们的设计思路，如需要下载demo工程源码，可以到 GitHub 下载参考：
总的来说，无论是基于开源播放器二次开发，还是全自研，一个好的RTMP播放器或RTSP播放器，设计的时候，更多考虑的应该是如何做的更灵活、稳定，单纯的几个接口，很难满足通用化的产品诉求。
以下共勉：厚积薄发，登上山顶，不是为了饱览风光，是为了寻找更高的山峰！
好多开发者一直搞不清我们轻量级RTSP服务SDK和RTSP推流SDK的区别，以下是相关区别：
1. 轻量级RTSP服务模块：轻量级RTSP服务解决的核心痛点是避免用户或者开发者单独部署RTSP或者RTMP服务，实现本地的音视频数据（如摄像头、麦克风），编码后，汇聚到内置RTSP服务，对外提供可供拉流的RTSP URL，轻量级RTSP服务，适用于内网环境下，对并发要求不高的场景，支持H.264/H.265，支持RTSP鉴权、单播、组播模式，考虑到单个服务承载能力，我们支持同时创建多个RTSP服务，并支持获取当前RTSP服务会话连接数。
以下是接口详解（以Android平台为例）：
|
Android内置轻量级RTSP服务SDK接口详解 |
||
|---|---|---|
|
调用描述 |
接口 |
接口描述 |
|
常规功能 |
Android RTMP推送端所有功能依然有效，亦可同时推送RTMP |
|
|
SmartRTSPServerSDK |
||
|
初始化RTSP Server |
InitRtspServer |
Init rtsp server(和UnInitRtspServer配对使用，即便是启动多个RTSP服务，也只需调用一次InitRtspServer，请确保在OpenRtspServer之前调用) |
|
创建一个rtsp server |
OpenRtspServer |
创建一个rtsp server，返回rtsp server句柄 |
|
设置端口 |
SetRtspServerPort |
设置rtsp server 监听端口, 在StartRtspServer之前必须要设置端口 |
|
设置鉴权用户名、密码 |
SetRtspServerUserNamePassword |
设置rtsp server 鉴权用户名和密码, 这个可以不设置，只有需要鉴权的再设置 |
|
获取rtsp server当前会话数 |
GetRtspServerClientSessionNumbers |
获取rtsp server当前的客户会话数, 这个接口必须在StartRtspServer之后再调用 |
|
启动rtsp server |
StartRtspServer |
启动rtsp server |
|
停止rtsp server |
StopRtspServer |
停止rtsp server |
|
关闭rtsp server |
CloseRtspServer |
关闭rtsp server |
|
UnInit rtsp server |
UnInitRtspServer |
UnInit rtsp server(和InitRtspServer配对使用，即便是启动多个RTSP服务，也只需调用一次UnInitRtspServer) |
|
SmartRTSPServerSDK供Publisher调用的接口 |
||
|
设置rtsp的流名称 |
SetRtspStreamName |
设置rtsp的流名称 |
|
给要发布的rtsp流设置rtsp server |
AddRtspStreamServer |
给要发布的rtsp流设置rtsp server, 一个流可以发布到多个rtsp server上，rtsp server的创建启动请参考OpenRtspServer和StartRtspServer接口 |
|
清除设置的rtsp server |
ClearRtspStreamServer |
清除设置的rtsp server |
|
启动rtsp流 |
StartRtspStream |
启动rtsp流 |
|
停止rtsp流 |
StopRtspStream |
停止rtsp流 |
2. RTSP推流模块：RTSP推流模块，和RTMP推流模块类似，适用于内网或公网环境下，主要适用于第三方RTSP服务对接，如darwin stream server，或者第三方RTSP服务平台，如视频分析平台等特定场景的服务器，支持H.264/H.265，支持TCP、UDP传输模式设定，也支持鉴权服务，RTSP协议的优势主要在于UDP这块，但是UDP数据包，公网容易被block住，而且，网络不稳定容易丢包，所以，能用RTMP推流的场景，一般建议走RTMP，需要特定系统对接的，再走RTSP。
以下是接口详解（以Android平台为例）：
|
调用描述 |
接口 |
接口描述 |
|---|---|---|
|
设置推送RTSP传输方式 |
SetPushRtspTransportProtocol |
transport_protocol:1表示UDP传输rtp包; 2表示TCP传输rtp包 |
|
设置推送RTSP的URL |
SetPushRtspURL |
设置推送RTSP的URL |
|
开始RTSP推送 |
StartPushRtsp |
启动推送RTSP流 |
|
停止RTSP推送 |
StopPushRtsp |
停止推送RTSP流 |
基于智慧教室或是会议的技术方案，一般主要是涉及到屏幕采集和推送，整体技术方案这块，一般建议走RTMP，说到这里，好人开发者提到，市面上也有RTSP的技术方案，甚至RTSP组播方案，这块，大牛直播SDK Github 也做过相关对比，总的来说60人智慧教室或类似同屏场景下，最可靠的还是RTMP的解决方案（不赘述，具体可自行测试对比）。
有人说，RTMP延迟大，这种说法，相对片面，好多是由于推拉流模块本身问题导致（如果服务器系NIGNX或SRS，基本可排除服务器转发导致的大时延，不要再赖服务器了），从我们官方和实际场景来看，RTMP整体技术方案，延迟可做到1秒内，毫秒级。
1. 组网：无线组网，需要好的AP模块才能撑得住大的并发流量，推送端到AP，最好是有线网链接；
2. 服务器部署：如果Windows平台，可以考虑NGINX，如果是Linux，可以考虑SRS或NGINX，服务器可以和Windows平台的教师机部署在一台机器；
3. 教师端：如教师有移动的PAD，可以直接推到RTMP服务器，然后共享出去；
4. 学生端：直接拉取RTMP流播放即可；
5. 教师和学生互动：学生端如需作为示范案例，屏幕数据共享给其他同学，只需请求同屏，数据反推到RTMP服务器，其他学生查看即可。
6. 扩展监控：如果需要更进一步的技术方案，如教师端想监控学生端的屏幕情况，可以有两种方案，如学生端直接推RTMP过来，或者，学生端启动内置RTSP服务，教师端想看的时候，随时看即可（亦可轮询播放）。
对应DEMO：SmartPublisherDemo.exe
1. 如果采集屏幕，只要采集部分区域的话，可以点击“选取屏幕区域”按钮，选择需要采集的区域，采集推送过程中，可以移动采集区域；
2. 如果是高分屏（如有些采集设备，是4K屏，原始分辨率过高），用户又不想推这么高的分辨率的话，可以选中“缩放屏幕大小”，并指定缩放比例，可以先缩放，后编码推送数据；
3. 设置采集帧率：如果是PPT/Word文档类，一般8-12帧足矣，如果是电影之类，可以设置到20-30帧不等，关键帧间隔一般设置到帧率的2-4倍，屏幕推送的话，建议平均码率模式；
4. 如果需要采集电脑端输出的声音，可以选中“采集扬声器”，如果需要采集外部麦克风的音频，选择“采集麦克风”即可，并选择对应的采集设备；
5. 设置下推送的RTMP URL，然后，点击“推送”，就可以了；
6. 如果想预览推送出去的数据，点击“预览”即可，想停止预览的话，点击“停止预览”即可。
需要注意的事项：
1. Android 8.0及以上版本设备，需要加入省电优化白名单，6.0以上版本，需要动态获取audio权限，具体代码如下：
//加入省电优化白名单，以免8.0及以上版本设备后台运行超过一分钟被自动停掉 //if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) if (Build.VERSION.SDK_INT >=26) { if(!isIgnoringBatteryOptimizations()) { gotoSettingIgnoringBatteryOptimizations(); } } //6.0及以上版本，动态获取Audio权限 if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { RequestAudioPermission(); } //拉起请求加入省电白名单弹窗 private void gotoSettingIgnoringBatteryOptimizations() { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { try { Intent intent = new Intent(); String packageName = getPackageName(); intent.setAction(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS); intent.setData(Uri.parse("package:" + packageName)); startActivityForResult(intent, REQUEST_IGNORE_BATTERY_CODE); } catch (Exception e) { e.printStackTrace(); } } } //动态获取Audio权限 private void RequestAudioPermission() { if (PackageManager.PERMISSION_GRANTED == ContextCompat.checkSelfPermission(this.getApplicationContext(), android.Manifest.permission.RECORD_AUDIO)) { } else { //提示用户开户权限音频 String[] perms = {"android.permission.RECORD_AUDIO"}; ActivityCompat.requestPermissions(this, perms, RESULT_CODE_STARTAUDIO); } }
2. 持续的补帧策略，防止屏幕不动，没数据下去；
3. 如果需要传部分区域下去，可以用 SmartPublisherOnCaptureVideoClipedRGBAData() 接口；
4. 横竖屏切换，上层无需过问，底层会自动切。
对应工程： SmartServiceCameraPublisherV2
注意事项：ReplayKit2 的直播扩展目前是有50M的内存使用限制，超过此限制系统会直接杀死扩展进程，因此 ReplayKit2 上建议推流分辨率和帧率、码率不要太高。
以下是核心processSampleBuffer() 处理，iOS 11.0以上 加入了横竖屏自动切换适配：
- (void)processSampleBuffer:(CMSampleBufferRef)sampleBuffer withType:(RPSampleBufferType)sampleBufferType { CGFloat cur_memory = [self GetCurUsedMemoryInMB]; if( cur_memory > 20.0f) { //NSLog(@"processSampleBuffer cur: %.2fM", cur_memory); return; } switch (sampleBufferType) { case RPSampleBufferTypeVideo: { if (!CMSampleBufferIsValid(sampleBuffer)) return; NSInteger rotation_degress = 0; //11.1以上支持自动旋转 #ifdef __IPHONE_11_1 if (UIDevice.currentDevice.systemVersion.floatValue > 11.1) { CGImagePropertyOrientation orientation = ((__bridge NSNumber*)CMGetAttachment(sampleBuffer, (__bridge CFStringRef)RPVideoSampleOrientationKey , NULL)).unsignedIntValue; //NSLog(@"cur org: %d", orientation); switch (orientation) { //竖屏 case kCGImagePropertyOrientationUp:{ rotation_degress = 0; } break; case kCGImagePropertyOrientationDown:{ rotation_degress = 180; break; } case kCGImagePropertyOrientationLeft: { //静音键那边向上 所需转90度 rotation_degress = 90; } break; case kCGImagePropertyOrientationRight:{ //关机键那边向上 所需转270 rotation_degress = 270; } break; default: break; } } #endif //NSLog(@"RPSampleBufferTypeVideo"); if(_smart_publisher_sdk) { //[_smart_publisher_sdk SmartPublisherPostVideoSampleBuffer:sampleBuffer]; [_smart_publisher_sdk SmartPublisherPostVideoSampleBufferV2:sampleBuffer rotateDegress:rotation_degress]; } //NSLog(@"video ts:%.2f", CMTimeGetSeconds(CMSampleBufferGetPresentationTimeStamp(sampleBuffer))); } break; case RPSampleBufferTypeAudioApp: //NSLog(@"RPSampleBufferTypeAudioApp"); if (CMSampleBufferDataIsReady(sampleBuffer) != NO) { if(_smart_publisher_sdk) { NSInteger type = 2; [_smart_publisher_sdk SmartPublisherPostAudioSampleBuffer:sampleBuffer inputType:type]; } } //NSLog(@"App ts:%.2f", CMTimeGetSeconds(CMSampleBufferGetPresentationTimeStamp(sampleBuffer))); break; case RPSampleBufferTypeAudioMic: //NSLog(@"RPSampleBufferTypeAudioMic"); if(_smart_publisher_sdk) { NSInteger type = 1; [_smart_publisher_sdk SmartPublisherPostAudioSampleBuffer:sampleBuffer inputType:type]; } //NSLog(@"Mic ts:%.2f", CMTimeGetSeconds(CMSampleBufferGetPresentationTimeStamp(sampleBuffer))); break; default: break; } }
视沃科技（大牛直播SDK）多路RTMP/RTSP转RTMP转发软件，系原有转发SDK基础上，官方推出的Windows平台定制版。在秉承低延迟、灵活稳定、低资源占用的前提下，客户无需关注开发细节，只需图形化配置转发等各类参数，实现产品快速上线目的。
如监控类摄像机、NVR等，通过厂商说明或Onvif工具，获取拉流的RTSP地址，图形化配置，完成拉流转发等操作，轻松实现标准RTMP服务器（或CDN）对接。
视频转发支持H.264、H.265（需要RTMP服务器或CDN支持扩展H.265），音频支持配置PCMA/PCMU转AAC后转发，并支持只转发/录制视频或音频，RTSP拉流端支持鉴权和TCP/UDP模式设置和TCP/UDP模式自动切换，整个拉流、转发模块都有非常完善的自动重连机制。
此外，可以通过点击拉流地址或推流地址栏，实现推拉流地址，同步到左侧预览框，实现推拉流音视频数据预览。
运维方面，官方定制版转发系统支持7*24小时不间断运行，自带守护进程，转发程序被误关等各种操作后，会自动启动运行，此外，还支持开机自动启动转发或录像。
官方测试版有1小时限制，拉流超过一小时会自动停止，如需长期运行或直接授权，请联系我们。
支持从守护进程（如需启动转发程序，可点击SmartStreamRelayToolDaemon.exe，守护进程会自动拉起SmartStreamRelayTool.exe，如需关闭转发程序，请先关闭SmartStreamRelayToolDaemon，转发程序方可正常关闭）：
配置说明：
添加配置项：点击页面“添加”按钮：
² 序号：无需关注，系统自动生成；
² 名称：该路转发配置项的描述信息；
² 拉流地址（必须填）：需要转发的RTSP或RTMP地址；
² 推流RTMP地址：需要转推的RTMP地址；
² 推流播放地址：需要预览的播放地址；
² 音视频转发选项：可选择之转发音频或视频，亦或同时转发音视频；
² 录像参数配置：可选择录制音频或视频，亦或音视频同时录制，并可设定录像文件前缀。
备注：双击列表配置项，可以查看或编辑配置信息；
删除配置项：选中需要删除的配置数据，点击页面“删除”按钮：
如何预览推拉流数据？
点击需要预览的“拉流地址”或“推流地址”，URL会同步到左侧预览框，即可实现推拉流数据本地预览。
如不需播放音频，点击“静音”选项即可。
如何转发数据？
系统配置：
² 支持程序启动后自动开启转发；
² 支持程序启动后自动开启录像（考虑到Windows平台磁盘读写性能，Windows平台不做多路录像承诺）；
² 开机后自动启动（可配置开机自动启动配置名）；
² 支持设置录像存储目录；
² 支持设定单个录像文件大小；
² 支持设置文件是否增加日期、时间；
² 支持设置是否音频自动转AAC编码后存储。
QQ群1（已满）：499687479
QQ群2：294891451
大牛直播SDK提供的RTSP/RTMP转RTMP流模块，具备低延迟、足够稳定、灵活、有状态反馈机制、资源占用低，跨平台，以SDK形式提供，给开发者提供更大的便利，已应用于诸多专业第三方公司。
其中：Windows平台对外提供C++ C#接口，Android提供JNI接口封装，iOS提供object c封装。
Windows/Android/iOS RTMP/RTSP多路流媒体转发SDK功能支持：
对应Demo：
鉴于部分公司人员配备不齐或产品开发周期短，一方面想用好的SDK，另一方面，苦于短期内没有好的人力配备完成上层业务逻辑开发，我们联合第三方开发者实现了Windows转发模块深度定制版本：
1. 启动SmartStreamRelayDemo.exe
2. 输入登陆用户名、密码，其中，用户名 admin 密码123456
3. 如需配置拉流和转发RTSP RTMP url，请直接在relayconfig.ini配置
4. 页面编辑配置：
4.1 读取INI文件，获取relayconfig.ini配置项;
4.2 保存INI文件，把上层编辑后的URL配置保存下来，配置后的，可直接保存，以便下次使用
4.3 增加工作任务：页面添加新的转发配置项
4.4 启动工作任务：启动所有转发
4.5 停止工作任务：停止所有转发
4.6 录制：如需录制流，直接点击“功能选项”->“录制”按钮，默认录制到“record”目录
4.7 移除任务：如需删除某一路流，直接点击“功能选项”->“移除”按钮
4.8 拉流预览：预览拉取的RTMP/RTSP流，预览过程中，可实时静音
4.9 推流预览：转发后的RTMP流，可实时预览，亦可实时静音
4. demo版，有一小时显示，每超过一小时，自动停止运行
5. 提供底层SDK授权，上层系统OEM或上层源码授权
更多资料或demo下载：
Github: https://github.com/daniulive/SmarterStreaming
QQ群：
好多开发者在做产品竞品分析的时候，不知道如何界定一个RTSP播放器，大牛直播SDK认为，一个RTSP播放器，不是说有几个类似于Open/Close接口就够了，好的RTSP播放器需要具备以下功能和性能属性：
1. 低延迟：大多数RTSP的播放都面向直播场景，所以，如果延迟过大，比如监控行业，小偷都走了，客户端才看到，或者别人已经按过门铃几秒，主人才看到图像，严重影响体验，所以，低延迟是衡量一个好的RTSP播放器非常重要的指标，目前大牛直播SDK的RTSP播放延迟控制在几百毫秒，VLC在几秒，这个延迟，是长时间的低延迟，比如运行1天、一周、一个月甚至更久；
2. 音视频同步或跳转：有些开发者为了追求低延迟体验，甚至不做音视频同步，拿到audio video直接播放，导致a/v不同步，还有就是时间戳乱跳；
3. 支持多实例：一个好的播放器，需要支持同时播放多路音视频数据，比如4-8-9-16-32窗口；
4. 支持buffer time设置：在一些有网络抖动的场景，播放器需要支持精准的buffer time设置，一般来说，以毫秒计；
5. H.265的播放和录制：除了H.264，还需要支持H.265，目前市面上的RTSP H.265摄像头越来越多，支持H.265的RTSP播放器迫在眉睫，此外，单纯的播放H.265还不够，还需要可以能把H.265的数据能录制下来；
6. TCP/UDP模式切换：考虑到好多服务器仅支持TCP或UDP模式，一个好的RTSP播放器需要支持TCP/UDP模式自动切换；
7. 静音支持：比如，多窗口播放RTSP流，如果每个audio都播放出来，体验非常不好，所以实时静音功能非常必要；
8. 视频view旋转：好多摄像头由于安装限制，导致图像倒置，所以一个好的RTSP播放器应该支持如视频view实时旋转(0° 90° 180° 270°)、水平反转、垂直反转；
9. 支持解码后audio/video数据输出（可选）：大牛直播SDK接触到好多开发者，希望能在播放的同时，获取到YUV或RGB数据，进行人脸匹配等算法分析，所以音视频回调可选；
10. 快照：感兴趣或重要的画面，实时截取下来非常必要；
11. 网络抖动处理(如断网重连)：基本功能，不再赘述；
12. 跨平台：一个好的播放器，跨平台（Windows/Android/iOS）很有必要，起码为了后续扩展性考虑，开发的时候，有这方面的考虑，目前大牛直播SDK的RTSP播放器，完美支持以上平台；
13. 长期运行稳定性：提到稳定性，好多开发者不以为然，实际上，一个好的产品，稳定是最基本的前提，不容忽视！
14. 可以录像：播放的过程中，随时录制下来感兴趣的视频片断，存档或其他二次处理；
15. log信息记录：整体流程机制实时反馈，不多打log，但是不能一些重要的log，如播放过程中出错等；
16. download速度实时反馈：可以看到实时下载速度反馈，以此来监听网络状态；
17. 异常状态处理：如播放的过程中，断网、网络抖动、来电话、切后台后返回等各种场景的处理。
说了这么多，有开发者会反问，大牛直播SDK到底支持了哪些？以下做个简单功能概述，如不单独说明，系Windows、Android、iOS全平台支持：
相关资料：Github: https://github.com/daniulive/SmarterStreaming
Flutter是谷歌的移动UI框架，可以快速在iOS和Android上构建高质量的原生用户界面。 Flutter可以与现有的代码一起工作。在全世界，Flutter正在被越来越多的开发者和组织使用，并且Flutter是完全免费、开源的。
1. Beautiful – Flutter 允许你控制屏幕上的每一寸像素，这让「设计」不用再对「实现」妥协；
2. Fast – 一个应用不卡顿的标准是什么，你可能会说 16ms 抑或是 60fps，这对桌面端应用或者移动端应用来说已足够，但当面对广阔的 AR/VR 领域，60fps 仍然会成为使人脑产生眩晕的瓶颈，而 Flutter 的目标远不止 60fps；借助 Dart 支持的 AOT 编译以及 Skia 的绘制，Flutter 可以运行的很快；
3. Productive – 前端开发可能已经习惯的开发中 hot reload 模式，但这一特性在移动开发中还算是个新鲜事。Flutter 提供有状态的 hot reload 开发模式，并允许一套 codebase 运行于多端；其他的，再比如开发采用 JIT 编译与发布的 AOT 编译，都使得开发者在开发应用时可以更加高效；
4. Open – Dart / Skia / Flutter (Framework)，这些都是开源的，Flutter 与 Dart 团队也对包括 Web 在内的多种技术持开放态度，只要是优秀的他们都愿意借鉴吸收。而在生态建设上，Flutter 回应 GitHub Issue 的速度更是让人惊叹，因为是真的快（closed 状态的 issue 平均解决时间为 0.29天）；
首先，Flutter则是依靠Flutter Engine虚拟机在iOS和Android上运行，开发人员可以通过Flutter框架和API在内部进行交互。Flutter Engine使用C/C++编写，具有低延迟输入和高帧速率的特点，不像Unity3d一样，我们是回调YUV/RGB数据，在Unity3d里面绘制，Flutter直接调用native SDK，效率更高。
其次，客户和开发者驱动，Flutter发展至今，目前还没有个像样的RTSP或RTMP播放器，一个播放器，不是说，有个界面，有个开始、停止按钮就可以了，一个好用的直播播放器，对功能和性能属性要求很高，特别是稳定性和低延迟这块，不谦虚的说，可能是首款功能强大、真正好用的Flutter RTSP/RTMP直播播放SDK。
以大牛直播SDK的播放器为例：
RTMP直播播放器功能介绍：
RTSP直播播放器功能介绍：
1. 视频播放效果：
http://www.iqiyi.com/w_19s8dv6yht.html
2. 界面截图：
//
// smartplayer.dart
// smartplayer
//
// GitHub: https://github.com/daniulive/SmarterStreaming
// website: https://www.daniulive.com
//
// Created by daniulive on 2019/02/25.
// Copyright © 2014~2019 daniulive. All rights reserved.
//
import 'dart:async';
import 'dart:convert';
import 'package:flutter/services.dart';
class EVENTID {
static const EVENT_DANIULIVE_COMMON_SDK = 0x00000000;
static const EVENT_DANIULIVE_PLAYER_SDK = 0x01000000;
static const EVENT_DANIULIVE_PUBLISHER_SDK = 0x02000000;
static const EVENT_DANIULIVE_ERC_PLAYER_STARTED =
EVENT_DANIULIVE_PLAYER_SDK | 0x1;
static const EVENT_DANIULIVE_ERC_PLAYER_CONNECTING =
EVENT_DANIULIVE_PLAYER_SDK | 0x2;
static const EVENT_DANIULIVE_ERC_PLAYER_CONNECTION_FAILED =
EVENT_DANIULIVE_PLAYER_SDK | 0x3;
static const EVENT_DANIULIVE_ERC_PLAYER_CONNECTED =
EVENT_DANIULIVE_PLAYER_SDK | 0x4;
static const EVENT_DANIULIVE_ERC_PLAYER_DISCONNECTED =
EVENT_DANIULIVE_PLAYER_SDK | 0x5;
static const EVENT_DANIULIVE_ERC_PLAYER_STOP =
EVENT_DANIULIVE_PLAYER_SDK | 0x6;
static const EVENT_DANIULIVE_ERC_PLAYER_RESOLUTION_INFO =
EVENT_DANIULIVE_PLAYER_SDK | 0x7;
static const EVENT_DANIULIVE_ERC_PLAYER_NO_MEDIADATA_RECEIVED =
EVENT_DANIULIVE_PLAYER_SDK | 0x8;
static const EVENT_DANIULIVE_ERC_PLAYER_SWITCH_URL =
EVENT_DANIULIVE_PLAYER_SDK | 0x9;
static const EVENT_DANIULIVE_ERC_PLAYER_CAPTURE_IMAGE =
EVENT_DANIULIVE_PLAYER_SDK | 0xA;
static const EVENT_DANIULIVE_ERC_PLAYER_RECORDER_START_NEW_FILE =
EVENT_DANIULIVE_PLAYER_SDK | 0x21; /*录像写入新文件*/
static const EVENT_DANIULIVE_ERC_PLAYER_ONE_RECORDER_FILE_FINISHED =
EVENT_DANIULIVE_PLAYER_SDK | 0x22; /*一个录像文件完成*/
static const EVENT_DANIULIVE_ERC_PLAYER_START_BUFFERING =
EVENT_DANIULIVE_PLAYER_SDK | 0x81;
static const EVENT_DANIULIVE_ERC_PLAYER_BUFFERING =
EVENT_DANIULIVE_PLAYER_SDK | 0x82;
static const EVENT_DANIULIVE_ERC_PLAYER_STOP_BUFFERING =
EVENT_DANIULIVE_PLAYER_SDK | 0x83;
static const EVENT_DANIULIVE_ERC_PLAYER_DOWNLOAD_SPEED =
EVENT_DANIULIVE_PLAYER_SDK | 0x91;
}
typedef SmartEventCallback = void Function(int, String, String, String);
class SmartPlayerController {
MethodChannel _channel;
EventChannel _eventChannel;
SmartEventCallback _eventCallback;
void init(int id) {
_channel = MethodChannel('smartplayer_plugin_$id');
_eventChannel = EventChannel('smartplayer_event_$id');
_eventChannel.receiveBroadcastStream().listen(_onEvent, onError: _onError);
}
void setEventCallback(SmartEventCallback callback) {
_eventCallback = callback;
}
void _onEvent(Object event) {
if (event != null) {
Map valueMap = json.decode(event);
String param = valueMap['param'];
onSmartEvent(param);
}
}
void _onError(Object error) {
// print('error:'+ error);
}
Future<dynamic> _smartPlayerCall(String funcName) async {
var ret = await _channel.invokeMethod(funcName);
return ret;
}
Future<dynamic> _smartPlayerCallInt(String funcName, int param) async {
var ret = await _channel.invokeMethod(funcName, {
'intParam': param,
});
return ret;
}
Future<dynamic> _smartPlayerCallIntInt(
String funcName, int param1, int param2) async {
var ret = await _channel.invokeMethod(funcName, {
'intParam': param1,
'intParam2': param2,
});
return ret;
}
Future<dynamic> _smartPlayerCallString(String funcName, String param) async {
var ret = await _channel.invokeMethod(funcName, {
'strParam': param,
});
return ret;
}
/// 设置解码方式 false 软解码 true 硬解码 默认为false
/// </summary>
/// <param name="isHwDecoder"></param>
Future<dynamic> setVideoDecoderMode(int isHwDecoder) async {
return _smartPlayerCallInt('setVideoDecoderMode', isHwDecoder);
}
/// <summary>
/// 设置音频输出模式: if 0: 自动选择; if with 1: audiotrack模式, 此接口仅限于Android平台使用
/// </summary>
/// <param name="use_audiotrack"></param>
Future<dynamic> setAudioOutputType(int useAudiotrack) async {
return _smartPlayerCallInt('setAudioOutputType', useAudiotrack);
}
/// <summary>
/// 设置播放端缓存大小, 默认200毫秒
/// </summary>
/// <param name="buffer"></param>
Future<dynamic> setBuffer(int buffer) async {
return _smartPlayerCallInt('setBuffer', buffer);
}
/// <summary>
/// 接口可实时调用：设置是否实时静音，1：静音; 0: 取消静音
/// </summary>
/// <param name="is_mute"></param>
Future<dynamic> setMute(int isMute) async {
return _smartPlayerCallInt('setMute', isMute);
}
/// <summary>
/// 设置RTSP TCP模式, 1: TCP; 0: UDP
/// </summary>
/// <param name="is_using_tcp"></param>
Future<dynamic> setRTSPTcpMode(int isUsingTcp) async {
return _smartPlayerCallInt('setRTSPTcpMode', isUsingTcp);
}
/// <summary>
/// 设置RTSP超时时间, timeout单位为秒，必须大于0
/// </summary>
/// <param name="timeout"></param>
Future<dynamic> setRTSPTimeout(int timeout) async {
return _smartPlayerCallInt('setRTSPTimeout', timeout);
}
/// <summary>
/// 设置RTSP TCP/UDP自动切换
/// 对于RTSP来说，有些可能支持rtp over udp方式，有些可能支持使用rtp over tcp方式.
/// 为了方便使用，有些场景下可以开启自动尝试切换开关, 打开后如果udp无法播放，sdk会自动尝试tcp, 如果tcp方式播放不了,sdk会自动尝试udp.
/// </summary>
/// <param name="is_auto_switch_tcp_udp"></param>
Future<dynamic> setRTSPAutoSwitchTcpUdp(int is_auto_switch_tcp_udp) async {
return _smartPlayerCallInt('setRTSPAutoSwitchTcpUdp', is_auto_switch_tcp_udp);
}
/// <summary>
/// 设置快速启动该模式，
/// </summary>
/// <param name="is_fast_startup"></param>
Future<dynamic> setFastStartup(int isFastStartup) async {
return _smartPlayerCallInt('setFastStartup', isFastStartup);
}
/// <summary>
/// 设置超低延迟模式 false不开启 true开启 默认false
/// </summary>
/// <param name="mode"></param>
Future<dynamic> setPlayerLowLatencyMode(int mode) async {
return _smartPlayerCallInt('setPlayerLowLatencyMode', mode);
}
/// <summary>
/// 设置视频垂直反转
/// </summary>
/// <param name="is_flip"></param>
Future<dynamic> setFlipVertical(int is_flip) async {
return _smartPlayerCallInt('setFlipVertical', is_flip);
}
/// <summary>
/// 设置视频水平反转
/// </summary>
/// <param name="is_flip"></param>
Future<dynamic> setFlipHorizontal(int is_flip) async {
return _smartPlayerCallInt('setFlipHorizontal', is_flip);
}
/// <summary>
/// 设置顺时针旋转, 注意除了0度之外， 其他角度都会额外消耗性能
/// degress： 当前支持 0度，90度, 180度, 270度 旋转
/// </summary>
/// <param name="degress"></param>
Future<dynamic> setRotation(int degress) async {
return _smartPlayerCallInt('setRotation', degress);
}
/// <summary>
/// 设置是否回调下载速度
/// is_report: if 1: 上报下载速度, 0: 不上报.
/// report_interval: 上报间隔，以秒为单位，>0.
/// </summary>
/// <param name="is_report"></param>
/// <param name="report_interval"></param>
Future<dynamic> setReportDownloadSpeed(
int isReport, int reportInterval) async {
return _smartPlayerCallIntInt(
'setReportDownloadSpeed', isReport, reportInterval);
}
/// <summary>
/// Set playback orientation(设置播放方向)，此接口仅适用于Android平台
/// </summary>
/// <param name="surOrg"></param>
/// surOrg: current orientation, PORTRAIT 1, LANDSCAPE with 2
Future<dynamic> setOrientation(int surOrg) async {
return _smartPlayerCallInt('setOrientation', surOrg);
}
/// <summary>
/// 设置是否需要在播放或录像过程中快照
/// </summary>
/// <param name="is_save_image"></param>
Future<dynamic> setSaveImageFlag(int isSaveImage) async {
return _smartPlayerCallInt('setSaveImageFlag', isSaveImage);
}
/// <summary>
/// 播放或录像过程中快照
/// </summary>
/// <param name="imageName"></param>
Future<dynamic> saveCurImage(String imageName) async {
return _smartPlayerCallString('saveCurImage', imageName);
}
/// <summary>
/// 播放或录像过程中，快速切换url
/// </summary>
/// <param name="uri"></param>
Future<dynamic> switchPlaybackUrl(String uri) async {
return _smartPlayerCallString('switchPlaybackUrl', uri);
}
/// <summary>
/// 创建录像存储路径
/// </summary>
/// <param name="path"></param>
Future<dynamic> createFileDirectory(String path) async {
return _smartPlayerCallString('createFileDirectory', path);
}
/// <summary>
/// 设置录像存储路径
/// </summary>
/// <param name="path"></param>
Future<dynamic> setRecorderDirectory(String path) async {
return _smartPlayerCallString('setRecorderDirectory', path);
}
/// <summary>
/// 设置单个录像文件大小
/// </summary>
/// <param name="size"></param>
Future<dynamic> setRecorderFileMaxSize(int size) async {
return _smartPlayerCallInt('setRecorderFileMaxSize', size);
}
/// <summary>
/// 设置录像时音频转AAC编码的开关
/// aac比较通用，sdk增加其他音频编码(比如speex, pcmu, pcma等)转aac的功能.
/// </summary>
/// <param name="is_transcode"></param>
/// is_transcode: 设置为1的话，如果音频编码不是aac，则转成aac，如果是aac，则不做转换. 设置为0的话，则不做任何转换. 默认是0.
Future<dynamic> setRecorderAudioTranscodeAAC(int is_transcode) async {
return _smartPlayerCallInt('setRecorderAudioTranscodeAAC', is_transcode);
}
/// <summary>
/// 设置播放路径
/// </summary>
Future<dynamic> setUrl(String url) async {
return _smartPlayerCallString('setUrl', url);
}
/// <summary>
/// 开始播放
/// </summary>
Future<dynamic> startPlay() async {
return _smartPlayerCall('startPlay');
}
/// <summary>
/// 停止播放
/// </summary>
Future<dynamic> stopPlay() async {
return _smartPlayerCall('stopPlay');
}
/// <summary>
/// 开始录像
/// </summary>
Future<dynamic> startRecorder() async {
return _smartPlayerCall('startRecorder');
}
/// <summary>
/// 停止录像
/// </summary>
Future<dynamic> stopRecorder() async {
return _smartPlayerCall('stopRecorder');
}
/// <summary>
/// 关闭播放
/// </summary>
Future<dynamic> dispose() async {
return await _channel.invokeMethod('dispose');
}
void onSmartEvent(String param) {
if (!param.contains(",")) {
print("[onNTSmartEvent] android传递参数错误");
return;
}
List<String> strs = param.split(',');
String code = strs[1];
String param1 = strs[2];
String param2 = strs[3];
String param3 = strs[4];
String param4 = strs[5];
int evCode = int.parse(code);
var p1, p2, p3;
switch (evCode) {
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_STARTED:
print("开始。。");
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_CONNECTING:
print("连接中。。");
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_CONNECTION_FAILED:
print("连接失败。。");
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_CONNECTED:
print("连接成功。。");
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_DISCONNECTED:
print("连接断开。。");
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_STOP:
print("停止播放。。");
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_RESOLUTION_INFO:
print("分辨率信息: width: " + param1 + ", height: " + param2);
p1 = param1;
p2 = param2;
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_NO_MEDIADATA_RECEIVED:
print("收不到媒体数据，可能是url错误。。");
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_SWITCH_URL:
print("切换播放URL。。");
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_CAPTURE_IMAGE:
print("快照: " + param1 + " 路径：" + param3);
if (int.parse(param1) == 0) {
print("截取快照成功。.");
} else {
print("截取快照失败。.");
}
p1 = param1;
p2 = param3;
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_RECORDER_START_NEW_FILE:
print("[record]开始一个新的录像文件 : " + param3);
p3 = param3;
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_ONE_RECORDER_FILE_FINISHED:
print("[record]已生成一个录像文件 : " + param3);
p3 = param3;
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_START_BUFFERING:
print("Start_Buffering");
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_BUFFERING:
print("Buffering: " + param1 + "%");
p1 = param1;
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_STOP_BUFFERING:
print("Stop_Buffering");
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_DOWNLOAD_SPEED:
print("download_speed:" + (double.parse(param1) * 8 / 1000).toStringAsFixed(0) + "kbps" + ", " + (double.parse(param1) / 1024).toStringAsFixed(0) + "KB/s");
p1 = param1;
break;
}
if (_eventCallback != null) {
_eventCallback(evCode, p1, p2, p3);
}
}
}
//
// main.dart
// main
//
// GitHub: https://github.com/daniulive/SmarterStreaming
// website: https://www.daniulive.com
//
// Created by daniulive on 2019/02/25.
// Copyright © 2014~2019 daniulive. All rights reserved.
//
import 'dart:io';
import 'package:flutter/services.dart';
import 'package:flutter/material.dart';
import 'package:flutter/cupertino.dart';
import 'package:flutter/foundation.dart';
import 'package:smartplayer_native_view/smartplayer.dart';
import 'package:smartplayer_native_view/smartplayer_plugin.dart';
void main() {
///
/// 强制竖屏
///
SystemChrome.setPreferredOrientations(
[DeviceOrientation.portraitUp, DeviceOrientation.portraitDown]);
runApp(new MyApp());
}
class MyApp extends StatefulWidget {
@override
_MyAppState createState() => new _MyAppState();
}
class _MyAppState extends State<MyApp> {
SmartPlayerController player;
double aspectRatio = 4.0 / 3.0;
//输入需要播放的RTMP/RTSP url
TextEditingController playback_url_controller_ = TextEditingController();
//Event事件回调显示
TextEditingController event_controller_ = TextEditingController();
bool is_playing_ = false;
bool is_mute_ = false;
var rotate_degrees_ = 0;
Widget smartPlayerView() {
return SmartPlayerWidget(
onSmartPlayerCreated: onSmartPlayerCreated,
);
}
@override
void initState() {
print("initState called..");
super.initState();
}
@override
void didChangeDependencies() {
print('didChangeDependencies called..');
super.didChangeDependencies();
}
@override
void deactivate() {
print('deactivate called..');
super.deactivate();
}
@override
void dispose() {
print("dispose called..");
player.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) {
return MaterialApp(
home: Scaffold(
appBar: AppBar(
title: const Text('Flutter SmartPlayer Demo'),
),
body: new SingleChildScrollView(
child: new Column(
children: <Widget>[
new Container(
color: Colors.black,
child: AspectRatio(
child: smartPlayerView(),
aspectRatio: aspectRatio,
),
),
new TextField(
controller: playback_url_controller_,
keyboardType: TextInputType.text,
decoration: InputDecoration(
contentPadding: EdgeInsets.all(10.0),
icon: Icon(Icons.link),
labelText: '请输入RTSP/RTMP url',
),
autofocus: false,
),
new Row(
children: [
new RaisedButton(
onPressed: this.onSmartPlayerStartPlay,
child: new Text("开始播放")),
new Container(width: 20),
new RaisedButton(
onPressed: this.onSmartPlayerStopPlay,
child: new Text("停止播放")),
new Container(width: 20),
new RaisedButton(
onPressed: this.onSmartPlayerMute,
child: new Text("实时静音")),
],
),
new Row(
children: [
new RaisedButton(
onPressed: this.onSmartPlayerSwitchUrl,
child: new Text("实时切换URL")),
new Container(width: 20),
new RaisedButton(
onPressed: this.onSmartPlayerSetRotation,
child: new Text("实时旋转View")),
],
),
new TextField(
controller: event_controller_,
keyboardType: TextInputType.text,
decoration: InputDecoration(
contentPadding: EdgeInsets.all(10.0),
icon: Icon(Icons.event_note),
labelText: 'Event状态回调',
),
autofocus: false,
),
],
),
)),
);
}
void _eventCallback(int code, String param1, String param2, String param3) {
String event_str;
switch (code) {
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_STARTED:
event_str = "开始..";
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_CONNECTING:
event_str = "连接中..";
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_CONNECTION_FAILED:
event_str = "连接失败..";
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_CONNECTED:
event_str = "连接成功..";
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_DISCONNECTED:
event_str = "连接断开..";
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_STOP:
event_str = "停止播放..";
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_RESOLUTION_INFO:
event_str = "分辨率信息: width: " + param1 + ", height: " + param2;
setState(() {
aspectRatio = double.parse(param1) / double.parse(param2);
print('change aspectRatio:$aspectRatio');
});
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_NO_MEDIADATA_RECEIVED:
event_str = "收不到媒体数据，可能是url错误..";
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_SWITCH_URL:
event_str = "切换播放URL..";
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_CAPTURE_IMAGE:
event_str = "快照: " + param1 + " 路径: " + param3;
if (int.parse(param1) == 0) {
print("截取快照成功。.");
} else {
print("截取快照失败。.");
}
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_RECORDER_START_NEW_FILE:
event_str = "[record] new file: " + param3;
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_ONE_RECORDER_FILE_FINISHED:
event_str = "[record] record finished: " + param3;
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_START_BUFFERING:
//event_str = "Start Buffering";
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_BUFFERING:
event_str = "Buffering: " + param1 + "%";
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_STOP_BUFFERING:
//event_str = "Stop Buffering";
break;
case EVENTID.EVENT_DANIULIVE_ERC_PLAYER_DOWNLOAD_SPEED:
event_str = "download_speed:" +
(double.parse(param1) * 8 / 1000).toStringAsFixed(0) +
"kbps" +
", " +
(double.parse(param1) / 1024).toStringAsFixed(0) +
"KB/s";
break;
}
event_controller_.text = event_str;
}
void onSmartPlayerCreated(SmartPlayerController controller) async {
player = controller;
player.setEventCallback(_eventCallback);
var ret = -1;
//设置video decoder模式
var is_video_hw_decoder = 0;
if (defaultTargetPlatform == TargetPlatform.android)
{
ret = await player.setVideoDecoderMode(is_video_hw_decoder);
}
else if(defaultTargetPlatform == TargetPlatform.iOS)
{
is_video_hw_decoder = 1;
ret = await player.setVideoDecoderMode(is_video_hw_decoder);
}
//设置缓冲时间
var play_buffer = 100;
ret = await player.setBuffer(play_buffer);
//设置快速启动
var is_fast_startup = 1;
ret = await player.setFastStartup(is_fast_startup);
//是否开启低延迟模式
var is_low_latency_mode = 0;
ret = await player.setPlayerLowLatencyMode(is_low_latency_mode);
//set report download speed(默认5秒一次回调 用户可自行调整report间隔)
ret = await player.setReportDownloadSpeed(1, 2);
//设置RTSP超时时间
var rtsp_timeout = 10;
ret = await player.setRTSPTimeout(rtsp_timeout);
var is_auto_switch_tcp_udp = 1;
ret = await player.setRTSPAutoSwitchTcpUdp(is_auto_switch_tcp_udp);
// 设置RTSP TCP模式
//ret = await player.setRTSPTcpMode(1);
//第一次启动 为方便测试 设置个初始url
playback_url_controller_.text = "rtmp://live.hkstv.hk.lxdns.com/live/hks2";
}
Future<void> onSmartPlayerStartPlay() async {
var ret = -1;
if (playback_url_controller_.text.length < 8) {
playback_url_controller_.text =
"rtmp://live.hkstv.hk.lxdns.com/live/hks1"; //给个初始url
}
//实时静音设置
ret = await player.setMute(is_mute_ ? 1 : 0);
if (!is_playing_) {
ret = await player.setUrl(playback_url_controller_.text);
ret = await player.startPlay();
if (ret == 0) {
is_playing_ = true;
}
}
}
Future<void> onSmartPlayerStopPlay() async {
if (is_playing_) {
await player.stopPlay();
playback_url_controller_.clear();
is_playing_ = false;
is_mute_ = false;
}
}
Future<void> onSmartPlayerMute() async {
if (is_playing_) {
is_mute_ = !is_mute_;
await player.setMute(is_mute_ ? 1 : 0);
}
}
Future<void> onSmartPlayerSwitchUrl() async {
if (is_playing_) {
if (playback_url_controller_.text.length < 8) {
playback_url_controller_.text =
"rtmp://live.hkstv.hk.lxdns.com/live/hks1";
}
await player.switchPlaybackUrl(playback_url_controller_.text);
}
}
Future<void> onSmartPlayerSetRotation() async {
if (is_playing_) {
rotate_degrees_ += 90;
rotate_degrees_ = rotate_degrees_ % 360;
if (0 == rotate_degrees_) {
print("旋转90度");
} else if (90 == rotate_degrees_) {
print("旋转180度");
} else if (180 == rotate_degrees_) {
print("旋转270度");
} else if (270 == rotate_degrees_) {
print("不旋转");
}
await player.setRotation(rotate_degrees_);
}
}
}
经测试，Flutter环境下，RTMP和RTSP播放，拥有Native SDK一样优异的播放体验。
相关资料：Github: https://github.com/daniulive/SmarterStreaming
QQ群：
一直以来，好多开发者苦于如何实现RTMP导播数据源实时切换，以下是大牛直播SDK导播切换说明，支持只切换数据源模式，或音视频混音合成输出模式：
数据源：
1. rtmp/rtsp音视频流；
2. 本地屏幕/摄像头/音频数据；
3.本地flv文件。
输出：
1. 多路流合成一路流后，推送到RTMP服务器；
2. 多路合成后的流，支持本地录像、快照。
无视频合成/音频混音模式：
1. 打开SmartStreamRelayDemo.exe，输入一路RTMP或RTSP流，在拉流地址输入需要转推的RTMP的url，如“rtmp://player.daniulive.com:1935/hls/stream666”，先点击“拉流”，再点击“推流”按钮，如需本地预览，可以点击“预览”按钮。
打开SmartPlayer.exe，输入刚刚设置的RTMP url：rtmp://player.daniulive.com:1935/hls/stream666，点击“播放”即可。
如下图所示：
2. 切换一路RTMP数据源，输入新的RTMP地址，点击“切换拉流地址”即可：
3. 切换一路RTSP数据源，输入新的RTSP地址，点击“切换拉流地址”即可：
视频合成/音频混音模式：
1. 合流界面：
2. 播放输出界面：
细心的你会发现，三路流分辨率和协议封装不同，不过依然可自动切换，从而实现播放端观众无感知的导播体验。
1. 以SDK形式输出，企业或开发者可根据需求完成多样化的产品需求；
2. 行业内接口更灵活，资源占用更低；
3. 超低延迟输出，效率更高；
4. 支持合流后的图像预览；
5. 支持合流后的音频混音；
6. 支持导播过程中，随时切断某一路音视频或音频；
7. 岂止是合流，还可以实时录像、快照等，接口更丰富。