Design essentials of cross-platform screen/camera RTMP stream push module

There are often companies or developers who have such doubts, obviously see online demo, one RTMP push, five or six interfaces are done, why do you make it so complicated?

Take Daniu live SDK (Github) Windows RTMP push stream as an example, our interface to more than 100, below we pull, why a RTMP push, how so difficult?

RTMP push SDK features:

Self-developed framework, easy to expand, adaptive algorithm to lower latency, higher transmission efficiency of acquisition code;
All functions are provided in the form of SDK interface. All states have event callback, which perfectly supports automatic reconnection when the network is disconnected.
Modular SDK, which can be combined with DANniu Live Player SDK to realize streaming media data forwarding, built-in lightweight RTSP service, mimai, one-to-one interaction and other scenes;
Windows push SDK is provided in hierarchical mode, and developers can combine data sources (such as multiple cameras/screens/watermarks) by themselves.
Supports external YUV/RGB/h. 264 / AAC/SPEEX/PCMA/PCMU data access;
All parameters can be set separately through the SDK interface, or through the default parameters, fool setting;
Push, video, built-in lightweight RTSP service module completely separated, can be used alone or combined;
It’s hard to find an SDK that even comes close.

On a graph:

Features:

[Video collection and processing] The Windows platform provides the Windows video collection and processing function.
[Audio collection and processing] The Windows platform provides the Windows Audio collection and processing function.
[Local preview]Windows supports real-time preview of camera, screen, and composite data. Android and iOS support local front and rear camera preview.
[Camera inversion/rotation]Windows platform supports camera horizontal reversal, vertical reversal, 0°/90°/180°/270° rotation;
[Camera capture] In addition to the conventional YUV format, Windows platform also supports MJPEG format camera capture;
[Microphone/speaker acquisition]Windows platform audio input side supports microphone, speaker, or microphone and speaker mix input;
[RTMP push stream] Ultra-low latency RTMP protocol live push stream SDK (Windows/Android/iOS support RTMP extension H.265 push);
Windows/Android platforms support H.264/H.265 encoding (Hard coding Android H.265), iOS platforms support H.264 encoding;
Windows/Android/iOS platforms support AAC encoding, Windows/Android platforms support Speex encoding;
[Audio encoding]Windows/Android platform support Speex push, Speex coding quality Settings;
[Volume adjustment] On Windows and Android platforms, the acquisition terminal supports real-time volume adjustment (in the Mixing mode of Windows platform, the volume of microphone and speaker can be controlled separately).
[H.264 hardcoding]Windows/Android/iOS platforms support H.264 hardcoding for specific models;
[H.265 hardcoding]Android/iOS platforms support H.265 hardcoding for specific models;
[Hardcoding adaptive]Android/iOS platform supports hardcoding adaptive. If it detects that hard coding is not supported, the system automatically switches to soft coding (for iOS, if H.265 hard coding is not supported, the system switches to H.264 hard coding first; if h. 264 soft coding is not supported, the system tries to h. 264 soft coding again).
[Hard and soft coding parameter configuration] Support GOP interval, frame rate and bit-rate Settings;
[Soft coding parameter Configuration] Supports soft coding profile, soft coding speed and variable bit rate Settings.
[Multi-instance push] Supports multi-instance push (for example, push screen/camera and external data simultaneously);
[RTMP extension H.265]Windows/Android/iOS push SDK supports THE RTMP extension H.265 push, Windows for camera acquisition soft coding, using variable bit rate H.265, bandwidth saving, the effect is close to the traditional H.265 encoding camera, H.265 hard coding is supported on Android and iOS platforms.
[Horizontal and vertical pushing] Supported on Android/iOS platforms, horizontal and vertical pushing is supported.
[Multi-resolution support] Supports multiple camera or screen resolution Settings;
[Windows Screen Push]Windows platform supports screen clipping, window collection, screen/camera data synthesis and other modes of push;
[Screen push on mobile terminal]Android platform supports background Service push screen (5.0+ version);
IOS platform support background push screen (based on ReplayKit, requires iOS 10.0+ version);
[Event callback] Supports real-time callback of various states;
Windows platform supports text watermarking, PNG watermarking, real-time occlusion, Android platform supports text watermarking, PNG watermarking;
[RTMP push mode] supports RTMP push live | record mode setting (server support required);
[Mirroring]Android and iOS platforms support the real-time mirroring function of the front camera.
[Real-time switching between front and rear cameras]Android and iOS platforms support switching between front and rear cameras during collection.
[Complex network processing] Automatic adaptation of various network environments such as disconnection and reconnection;
[Dynamic bit rate] Supports automatic adjustment of stream bit rate according to network conditions.
[Real-time mute] Supports real-time mute/unmute during push.
[Real-time snapshot] Supports real-time snapshot in the process of pushing flow.
[Pure audio push stream] support only to collect audio stream and push stream function;
[Pure video Streaming] Supports pure video streaming in special scenarios;
[Noise reduction]Windows/Android platform supports noise reduction, automatic gain and VAD detection caused by ambient sound and mobile phone interference.
Echo cancellation Android platform supports real-time transmission of remote PCM data, convenient echo cancellation processing;
[Video data interconnection before external coding] YUV data interconnection;
[Audio data docking before external coding] support PCM docking;
[Video data docking after external encoding] Supports external H.264 data docking;
External AAC/PCMA/PCMU/SPEEX data connection;
[Hibernation setting of push side]Windows platform supports hibernation interface (CPU will be lowered properly after hibernation mode is set).
[Encoded data output] The Android platform supports the output of encoded H264/AAC data to the upper layer for easy interconnection with third-party platforms (such as GB28181).
[Extended Video function] Perfectly supports the combination of video SDK, video related functions, see “Windows/Android/iOS video “;
[Clipping mode]Android/iOS platforms support camera clipping mode setting with specific resolution;
[Server compatibility] Supports self-built servers (such as Nginx and SRS) or CDN.

Supported platform architecture

Support platform	Support structure
The Windows platform	x86 debug/release, x64 debug/release
The Android platform	armeabi-v7a, arm64-v8a, x86, x86_64
The iOS platform	armv7, arm64, i386, x86_64

Windows Video collection and processing

Video Source support

Windows screen capture, screen cropping, specific window capture, camera capture, extended external H.264 data docking;
Camera and screen composite
[Real-time switching between camera and screen] In the process of push, the camera and screen can switch with each other and display the camera or screen in a single screen.
[Camera overlay to screen] Supports camera overlay to the specified position on the screen according to the set coordinates, and supports real-time closing of the overlay layer;
[Screen overlay to camera] Support the screen to overlay to the specified position of the camera according to the set coordinates, and support real-time closing of the overlay layer;

Watermark and opacity occlusion

[Real-time watermark] supportDynamic watermarkSettings, perfect supportText watermarking, real-time time watermarking and picture watermarking;
[Transparency] You can set transparency handling (set masking);

Windows audio collection processing related

Support for audio sources

Support Windows acquisition microphone, speaker and external AAC, Speex WB, PCMA, PCMU data interface input;

Audio synthesis

[Audio] Support speaker and microphone audio mixing output (select “acquisition speaker” and “acquisition microphone” at the same time);

Audio processing

Support audio “endpoint detection (VAD)”, adaptive code stream, audio code stream more saving;
Echo cancellation support;
Support noise suppression function;
Automatic gain control is supported.

Windows/Android/iOS video SDK related

[Pull stream] support to pull RTSP streaming video;
[Pull stream] support to pull RTMP stream video;
[Streaming end video] Support push end synchronous video;
[Logical separation] Danniu Live video SDK is different from ordinary video interface, more intelligent, and push, play, forward, built-in lightweight RTSP service SDK functions are completely separated, support video at any time;
[URL Switching] During recording, you can switch between different urls. If two urls are configured in the same way, you can record the same MP4 file. If they are inconsistent, they can be automatically split to the next file.
[Parameter Settings] You can set the size and path of a single video file, and support audio, video, and audio recording modes.
[Audio transcoding] Support audio (PCMU/PCMA,Speex, etc.) to AAC before recording;
[265 support] Support RTSP/RTMP H.265 recording to MP4 files;
Windows/Android push SDK support H265 video;
[Event callback] From the beginning of recording to the end of recording, there will be event callback, network congestion, audio and video synchronization are very friendly processing.

After reading this, you can think again, a commercial RTMP push stream, really several interfaces can handle?

Attached with a Windows push SDK oral file:

#ifndef NT_SMART_PUBLISHER_SDK_H_
#define NT_SMART_PUBLISHER_SDK_H_

// The following ifdef block is the standard way of creating macros which make exporting 
// from a DLL simpler. All files within this DLL are compiled with the SMARTPUBLISHERSDK_EXPORTS
// symbol defined on the command line. This symbol should not be defined on any project
// that uses this DLL. This way any other project whose source files include this file see 
// SMARTPUBLISHERSDK_API functions as being imported from a DLL, whereas this DLL sees symbols
// defined with this macro as being exported.
#ifdef SMARTPUBLISHERSDK_EXPORTS
#define SMARTPUBLISHERSDK_API __declspec(dllexport)
#else
#define SMARTPUBLISHERSDK_API __declspec(dllimport)
#endif

#include "nt_type_define.h"

#include "nt_smart_publisher_define.h"


#ifdef __cplusplus
extern "C"{
#endif

	/* Image processing provides a separate structure to reduce storage space and facilitate copying */
	typedef struct _NT_SmartPublisherImageSDKAPI
	{
		/* Allocate the Image, and the SDK will initialize the structure internally, or return NULL */ on failure
		NT_PB_Image* (NT_API *AllocateImage)(NT_VOID);

		/* Free Image, be sure to call this interface to free memory, if you free in your own module, Windows will have problems, return NT_ERC_OK */ on success
		NT_UINT32(NT_API *FreeImage)(NT_PB_Image** ppImage);

		/* Clone an Image, return NULL */ on failure
		NT_PB_Image* (NT_API* CloneImage)(const NT_PB_Image* src);

		/* NT_ERC_OK */ is returned on success
		NT_UINT32(NT_API* CopyImage)(NT_PB_Image* dst, const NT_PB_Image* src);

		/* Set data to a face of the image. If the face already has data, it will be freed. Setting this behavior depends on NT_PB_Image::format_ returning NT_ERC_OK */
		NT_UINT32(NT_API* SetImagePlane)(NT_PB_Image* image, NT_INT32 plane,
			NT_INT32 planeStride, const NT_UINT8* planeData, NT_INT32 planeDataSize);

		File_name_utf8: must be UTF8 encoding success returns NT_ERC_OK */
		NT_UINT32(NT_API* LoadImage)
			(
			NT_PCSTR file_name_utf8,
			NT_PB_Image** ppImage
			);

	} NT_SmartPublisherImageSDKAPI;

	/* Draw the relevant interface, draw may provide more interfaces */
	typedef struct _NT_SmartPublisherDrawImageSDKAPI
	{
		/* Returns NT_ERC_OK */ on success
		NT_UINT32(NT_API *Draw)(NT_HDC hdc, NT_INT32 xDst, NT_INT32 yDst,
			NT_INT32 dstWidth, NT_INT32 dstHeight,
			NT_INT32 xSrc, NT_INT32 ySrc,
			NT_INT32 srcWidth, NT_INT32 srcHeight,
			const NT_PB_Image* image);

	} NT_SmartPublisherDrawImageSDKAPI;


	typedef struct _NT_SmartPublisherSDKAPI
	{
		/* NT_ERC_OK */ * NT_ERC_OK */
		NT_UINT32(NT_API *Init)(NT_UINT32 flag, NT_PVOID pReserve);

		/* This is the last interface called successfully returns NT_ERC_OK */
		NT_UINT32(NT_API *UnInit)();

		/* video_option please refer to NT_PB_E_VIDEO_OPTION, auido_option please refer to NT_PB_E_AUDIO_OPTION flag NT_ERC_OK */ is returned after the Handle is successfully obtained
		NT_UINT32(NT_API *Open)(NT_PHANDLE pHandle, NT_UINT32 video_option, NT_UINT32 auido_option, NT_UINT32 flag, NT_PVOID pReserve);

		/* Handle fails after calling this interface and returns NT_ERC_OK */ on success
		NT_UINT32(NT_API *Close)(NT_HANDLE handle);


		/* Set the event callback. If you want to listen for events, it is recommended to call this interface */ after the successful call to Open
		NT_UINT32(NT_API *SetEventCallBack)(NT_HANDLE handle,
			NT_PVOID call_back_data, NT_PB_SDKEventCallBack call_back);


		/* Parameter Settings */
		/* Set screen clipping left: x position top: y position width: a multiple of 16 Height: a multiple of 16 */
		NT_UINT32(NT_API *SetScreenClip)(NT_HANDLE handle, NT_UINT32 left, NT_UINT32 top, NT_UINT32 width, NT_UINT32 height);


		/* Move the clipping area of the screen. This interface can only be pushed or called in video. Left: x position in the upper left corner of the screen
		NT_UINT32(NT_API *MoveScreenClipRegion)(NT_HANDLE handle, NT_UINT32 left, NT_UINT32 top);


		Is_enable: 1 means to enable DXGI collection, 0 means not to enable, other values directly return error success return NT_ERC_OK */
		NT_UINT32(NT_API *EnableDXGIScreenCapturer)(NT_HANDLE handle, NT_INT32 is_enable);


		/* * Disable Aero when capturing the screen, this only affects Windows 7, Windows 8 and above, Microsoft has abandoned Aero Glass effect *is_disable: 1: stop, if set to 1, in Win7 system start screen capture may be black screen flashing, 0: do not stop * SDK internal default value is 1 * success return NT_ERC_OK */
		NT_UINT32(NT_API *DisableAeroScreenCapturer)(NT_HANDLE handle, NT_INT32 is_disable);


		/* If the WS_EX_LAYERED window needs to be collected in GDI mode, set it to 1 is_enable: 1 indicates that WS_EX_LAYERED window is collected, and 0 indicates that WS_EX_LAYERED window is not collected. The default value is 0 and no collection is performed. Note that in the WS_EX_LAYERED property window, the mouse will flash successfully and return to NT_ERC_OK */
		NT_UINT32(NT_API *EnableScreenCaptureLayeredWindow)(NT_HANDLE handle, NT_INT32 is_enable);


		/* This interface determines whether the top-level window can be captured. If it cannot be captured, NT_ERC_FAILED is returned
		NT_UINT32(NT_API *CheckCapturerWindow)(NT_HWND hwnd);

		/* Sets the handle to the window to capture */
		NT_UINT32(NT_API *SetCaptureWindow)(NT_HANDLE handle, NT_HWND hwnd);


		/* Set the frame rate */
		NT_UINT32(NT_API *SetFrameRate)(NT_HANDLE handle, NT_UINT32 frame_rate);

		/*+++ Camera related interfaces +++*/
		
		PNumer: The number of devices is successfully returned. NT_ERC_OK */
		NT_UINT32(NT_API* GetVideoCaptureDeviceNumber)(NT_INT32* pNumer);

		Device_index: device index device_name_utf8: Device name. If NULL is passed, device_name_length must be greater than or equal to 256, and device_name_length encoded in UTF8 is returned: Device name buffer size, if device_name_UTF8 is NULL, pass in 0, otherwise must be greater than or equal to 256 device_UNIque_ID_UTF8: Unique device ID. If NULL is passed, ID is not returned. If NULL is not passed, device_UNIque_ID_length must be greater than or equal to 1024, and device_UNIque_ID_length encoded in UTF8 is returned: Device unique ID Buffer agent. If device_unique_id_utf8NULL is used, 0 is passed. Otherwise, NT_ERC_OK */ must be greater than or equal to 1024
		NT_UINT32(NT_API* GetVideoCaptureDeviceInfo)(
			NT_INT32	device_index,
			NT_PSTR		device_name_utf8,
			NT_UINT32	device_name_length,
			NT_PSTR		device_unique_id_utf8,
			NT_UINT32	device_unique_id_length
			);

		Device_unique_id_utf8: unique device ID Capability_number: number of returned device capabilities NT_ERC_OK */ is returned successfully
		NT_UINT32(NT_API* GetVideoCaptureDeviceCapabilityNumber)(
			NT_PCSTR device_unique_id_utf8,
			NT_INT32* capability_number
			);

		Device_unique_id_utf8: unique device ID, device_Capability_index: device capability index Capability NT_ERC_OK */ is returned successfully
		NT_UINT32(NT_API* GetVideoCaptureDeviceCapability)(
			NT_PCSTR device_unique_id_utf8,
			NT_INT32 device_capability_index,
			NT_PB_VideoCaptureCapability* capability);


		/* * When multiple instances push multiple channels, for a camera, all instances can only share the camera, so only one instance can change the camera resolution, the other instances use the scaled image. When using multiple instances, calling this interface disables the resolution setting capability of the instance. Only one instance can change resolution, if not set, the behavior is undefined. This interface must be called device_unique_ID_UTf8: Device unique ID before SetLayersConfig, AddLayerConfig returns NT_ERC_OK */
		NT_UINT32(NT_API* DisableVideoCaptureResolutionSetting)(
			NT_HANDLE handle,
			NT_PCSTR device_unique_id_utf8
			);


		/* Start camera preview device_UNIque_ID_UTf8: unique device ID HWND: Drawn window handle successfully returns NT_ERC_OK */
		NT_UINT32(NT_API* StartVideoCaptureDevicePreview)(
			NT_PCSTR device_unique_id_utf8,
			NT_HWND hwnd
			);

		Is_flip: 1: indicates inversion, 0: indicates no inversion */
		NT_UINT32(NT_API *FlipVerticalCameraPreview)(NT_HWND hwnd, NT_INT32 is_flip);


		Is_flip: 1: indicates inversion, 0: indicates no inversion */
		NT_UINT32(NT_API *FlipHorizontalCameraPreview)(NT_HWND hwnd, NT_INT32 is_flip);


		/* * Rotate the camera preview image clockwise. If this parameter is set to 0, 90, 180, or 270 degrees, this parameter is invalid. Note that playing at any Angle except 0 degrees consumes more CPU */
		NT_UINT32(NT_API *RotateCameraPreview)(NT_HWND hwnd, NT_INT32 degress);


		/* Tells the SDK preview window size change HWND: the window handle drawn successfully returns NT_ERC_OK */
		NT_UINT32(NT_API* VideoCaptureDevicePreviewWindowSizeChanged)
			(
			NT_HWND hwnd
			);

		/* Stop camera preview HWND: the window handle drawn successfully returns NT_ERC_OK */
		NT_UINT32(NT_API* StopVideoCaptureDevicePreview)(
			NT_HWND hwnd
			);


		/ * * * * * * * * * * * * * * * * * * * * * * * * * * * /
		/ * * * * * to get camera RBG32 image interface + + / / * * * * * * * * * * * * * * * * * * * * * * * * * * * /
		/* Call process: 1. StartGetVideoCaptureDeviceImage access to handle, cut the handle to save 2. GetVideoCaptureDeviceImage image 3. StopGetVideoCaptureDeviceImage stop, The handle will then be invalid */

		/ * call this interface precondition: you must call the Init interface, otherwise it will collapse or failure pVideoCaptrueImageHandle: a pointer to the handle to return, please do not handle and other mixed device_unique_id_utf8: The device unique ID successfully returns NT_ERC_OK and the VideoCaptrueImageHandle */
		
		NT_UINT32(NT_API* StartGetVideoCaptureDeviceImage)
			(
			NT_PHANDLE pVideoCaptrueImageHandle,
			NT_PCSTR   device_unique_id_utf8
			);


		Is_flip: 1: indicates inversion, 0: indicates no inversion */
		NT_UINT32(NT_API *FlipVerticalVideoCaptureDeviceImage)(NT_HANDLE videoCaptrueImageHandle, NT_INT32 is_flip);


		Is_flip: 1: indicates inversion, 0: indicates no inversion */
		NT_UINT32(NT_API *FlipHorizontalVideoCaptureDeviceImage)(NT_HANDLE videoCaptrueImageHandle, NT_INT32 is_flip);


		/* * Rotate the device image clockwise. If this parameter is set to 0 °, 90 °, 180 °, or 270 °, the device will consume more CPU */
		NT_UINT32(NT_API *RotateVideoCaptureDeviceImage)(NT_HANDLE videoCaptrueImageHandle, NT_INT32 degress);

		/ * call this interface can get camera image videoCaptrueImageHandle: handle, obtained by StartGetVideoCaptureDeviceImage isDiscardImage: 1: indicates that the image saved in SDK will be deleted after the image is retrieved. 0: indicates that the image saved in SDK will not be deleted after the image is retrieved. Then the next time when this interface is invoked, if the camera does not generate a new image, the last returned image ppImage will be returned: Return value: NT_ERC_OK: indicates that an image has been obtained, and *ppImage must have a value. NT_ERC_PB_NO_IMAGE: indicates that there is no image in the SDK and it needs to wait for the camera to generate an image. Other values: It may be other errors, such as parameter error etc. Note: 1. The width and height of the image returned by this interface may vary, meaning that each call may return a different width and height. The image is taken from top to bottom */

		NT_UINT32(NT_API* GetVideoCaptureDeviceImage)
			(
			NT_HANDLE     videoCaptrueImageHandle,
			NT_INT32      isDiscardImage,
			NT_PB_Image** ppImage
			);


		/* Return NT_ERC_OK on success of stopping camera image retrieval note: */ must be called before UnInit
		NT_UINT32(NT_API* StopGetVideoCaptureDeviceImage)
			(
			NT_HANDLE  videoCaptrueImageHandle
			);


		/ * * * * * * * * * * * * * * * * * * * * * * * * * * * /
		/ * * * * * to get camera RBA32 image interface -- / / * * * * * * * * * * * * * * * * * * * * * * * * * * * /

		/* Set camera information */
		NT_UINT32(NT_API *SetVideoCaptureDeviceBaseParameter)(NT_HANDLE handle, NT_PCSTR device_unique_id_utf8, NT_UINT32 width, NT_UINT32 height);

		Is_flip: 1: indicates inversion, 0: indicates no inversion */
		NT_UINT32(NT_API *FlipVerticalCamera)(NT_HANDLE handle, NT_INT32 is_flip);

		Is_flip: 1: indicates inversion, 0: indicates no inversion */
		NT_UINT32(NT_API *FlipHorizontalCamera)(NT_HANDLE handle, NT_INT32 is_flip);

		/* * Rotate the camera image clockwise. If this parameter is set to 0, 90, 180, or 270 degrees, this parameter is invalid
		NT_UINT32(NT_API *RotateCamera)(NT_HANDLE handle, NT_INT32 degress);


		/*-- Camera related interface --*/


		/*+++ + Video compositing related Settings +++*/
		

		/* Set the video composator layer, pass an array, fill each layer correctly reserve: this parameter is reserved, currently pass 0 confs: layer configuration array count: array size flag: currently pass 0 pReserve: Reserved for future success returns NT_ERC_OK */
		NT_UINT32(NT_API *SetLayersConfig)(NT_HANDLE handle, NT_INT32 reserve, 
			const NT_PB_LayerBaseConfig** confs, NT_INT32 count,
			NT_UINT32 flag, NT_PVOID pReserve);


		SetLayersConfig Reserve: SetLayersConfig Reserve: SetLayersConfig Reserve: SetLayersConfig Reserve: SetLayersConfig Reserve: SetLayersConfig Reserve: SetLayersConfig Reserve Reserved for future success returns NT_ERC_OK */
		NT_UINT32 (NT_API *ClearLayersConfig)(NT_HANDLE handle, NT_INT32 reserve,
			NT_UINT32 flag, NT_PVOID pReserve);


		SetLayersConfig reserve: SetLayersConfig reserve: this parameter is reserved. Conf: layer_type: Layer type Flag: 0 pReserve: NT_ERC_OK */
		NT_UINT32 (NT_API *AddLayerConfig)(NT_HANDLE handle, NT_INT32 reserve,
			NT_PVOID conf, NT_INT32 layer_type,
			NT_UINT32 flag, NT_PVOID pReserve);

		Is_enable: 1 indicates that it is enabled, 0 indicates that it is disabled, and the other values directly return an error on success. NT_ERC_OK */
		NT_UINT32(NT_API *EnableLayer)(NT_HANDLE handle, NT_INT32 reserve,
			NT_INT32 index, NT_INT32 is_enable);

		/* Update the layer configuration. Note that not all fields of the layer can be updated, only some fields can be updated, and some layers do not have fields that can be updated, the SDK only selects the fields that can be updated, and the fields that cannot be updated will be ignored. Pass 0 to pReserve: Return NT_ERC_OK */
		NT_UINT32(NT_API * UpdateLayerConfig)(NT_HANDLE handle, NT_INT32 reserve,
			const NT_PB_LayerBaseConfig* conf, NT_UINT32 flag, NT_PVOID pReserve);


		/* this interface is for C#, C++ please use the above UpdateLayerConfig interface to update the layer configuration. Note that not all fields of the layer can be updated, only some fields can be updated, and some layers do not have fields to update. Fields that cannot be updated will be ignored. Reserve: Reserved fields, and pass 0 conf: Configuration flag: 0 pReserve fields, and pass 0. NT_ERC_OK */ is returned successfully
		NT_UINT32(NT_API * UpdateLayerConfigV2)(NT_HANDLE handle, NT_INT32 reserve,
			NT_PVOID conf, NT_INT32 layer_type, NT_UINT32 flag, NT_PVOID pReserve);

		NT_ERC_OK */
		NT_UINT32(NT_API *UpdateLayerRegion)(NT_HANDLE handle, NT_INT32 reserve,
			NT_INT32 index, const NT_PB_RectRegion* region);

		/* Index: 0 index: 0 Image: 0 flag: 0 pReserve: NT_ERC_OK */ is returned if 0 is passed
		NT_UINT32(NT_API * PostLayerImage)(NT_HANDLE handle, NT_INT32 reserve,
			NT_INT32 index, const NT_PB_Image* image, NT_UINT32 flag, NT_PVOID pReserve);

		/*-- video compositing related Settings --*/

		
		/*+++ Video capture related interfaces +++*/

		/* File_name_UTf8: file name, utf8 encoding call_back_data: user-defined data call_back: NT_ERC_OK is a callback function used to notify the user that a screenshot has been taken or failed. Due to the time-consuming process of generating PNG files, which usually takes hundreds of milliseconds, the SDK limits the number of screenshot requests to prevent CPU overshooting. When the number exceeds a certain threshold, calling this interface will return NT_ERC_PB_TOO_MANY_CAPTURE_IMAGE_REQUESTS. In this case, delay for a while and try again after the SDK has processed some requests. */
		NT_UINT32(NT_API* CaptureImage)(NT_HANDLE handle, NT_PCSTR file_name_utf8,
			NT_PVOID call_back_data, NT_PB_SDKCaptureImageCallBack call_back);


		/*-- Video capture related interface --*/



		/*+++ + video encoding related interface +++*/


		NT_ERC_OK */
		NT_UINT32(NT_API *GetHWVideoEncoderInfoCount)(NT_INT32* count);

		/ * video hard-coded information infos: please call GetHWVideoEncoderInfoCount, and then assign the array info_array_size: distribution of the array size out_count: The actual number returned successfully returns NT_ERC_OK */
		NT_UINT32(NT_API *GetHWVideoEncoderInfos)(NT_PB_HWVideoEncoderInfo* infos, NT_INT32 info_array_size, NT_INT32* out_count);


		Encoder_id encoder_id encoder_id encoder_id encoder_id encoder_id encoder_id encoder_id encoder_id For hard coding, 128 is NVIDIA Video Encoder (NVENC), and an error is returned when other values are specified. Param1: For soft coding, set to 0. If it is hard coded and NVENC, this parameter is used to set the GPU index. If it is set to -1, the SDK automatically selects gpu. codec_id: To set the h264 or H265 encoding, see NT_MEDIA_CODEC_ID for H264 and NT_MEDIA_CODEC_ID_H264 for H265. The default encoding is H264. Note: Soft coding does not support H265. Hard coding depends on the actual hardware situation. If this interface is called, do not call the SetVideoEncoderType interface again and return NT_ERC_OK */ successfully
		NT_UINT32(NT_API *SetVideoEncoder)(NT_HANDLE handle, NT_INT32 type, NT_INT32 encoder_id, NT_UINT32 codec_id, NT_INT32 param1);

		/* This interface is deprecate, please use the SetVideoEncoder interface to set the encoding type, currently supports H264 and H265 (note :h265 is only supported by the 64-bit SDK library, setting will fail on the 32-bit library) encoder_type: 1 is H264, 2 is H265. The default value is H264. NT_ERC_OK */ is returned on success
		NT_UINT32(NT_API *SetVideoEncoderType)(NT_HANDLE handle, NT_INT32 encoder_type);

		/* Note that bitrate is controlled in two ways, Either SetVideoQuality(or SetVideoQuality v2) + SetVideoMaxBitRate or SetVideoMaxBitRate + SetVideoBitRate */

		/* Set the video quality, range [0-20], default is 10, the smaller the quality is better, but the larger the bit rate is recommended to use SetVideoQualityV2(note: see v2 specific parameters and range) */
		NT_UINT32(NT_API *SetVideoQuality)(NT_HANDLE handle, NT_INT32 quality);


		/* Set the video quality, the range is [1-50], the smaller the value, the better the video quality, but the higher the bit rate. For H264, the default is 23. For H265, the default is 28 */
		NT_UINT32(NT_API *SetVideoQualityV2)(NT_HANDLE handle, NT_INT32 quality);


		/* Sets the maximum video bitrate in KBPS */
		NT_UINT32(NT_API *SetVideoMaxBitRate)(NT_HANDLE handle, NT_INT32 kbit_rate);

		/* Set the video bit rate in KBPS, default is 0, do not use average bit rate */
		NT_UINT32(NT_API *SetVideoBitRate)(NT_HANDLE handle, NT_INT32 kbit_rate);


		/* * In some special scenarios, the video resolution will change. If a fixed bit rate is set, the video resolution will become blurred when it becomes larger, and the bit rate will be wasted when it becomes smaller. For example, if the resolution is set to 640*360 and 640*480, the bitrate of 640*360 will be used when the resolution is less than or equal to 640*360. * When the resolution is greater than 640*360 and less than or equal to 640*480, If the resolution is greater than 640*480 then use 640*480 resolution * To set more accurate, it is recommended to divide several groups, make the interval smaller * */ call this interface set one group each time, set multiple groups call * */
		NT_UINT32(NT_API* AddVideoEncoderBitrateGroupItem)(NT_HANDLE handle, const NT_PB_VideoEncoderBitrateGroupItem* item);

		
		/* Clear the video bitrate group */
		NT_UINT32(NT_API* ClearVideoEncoderBitrateGroup)(NT_HANDLE handle);


		/* Set the interval between keyframes. For example, 1 indicates that all keyframes are keyframes, 10 indicates one keyframe in every 10 frames, and 25 indicates one keyframe in every 25 frames */
		NT_UINT32(NT_API *SetVideoKeyFrameInterval)(NT_HANDLE handle, NT_INT32 interval);


		Profile: 1: H264 baseline(default value). 2: H264 main. 3. H264 high NT_ERC_OK */ is returned successfully
		NT_UINT32(NT_API *SetVideoEncoderProfile)(NT_HANDLE handle, NT_INT32 profile);

		/* Set the video encoding speed speed: the range is 1 to 6, the smaller the value, the faster the speed, the worse the quality */
		NT_UINT32(NT_API *SetVideoEncoderSpeed)(NT_HANDLE handle, NT_INT32 speed);

		Is_compare_image: 1: compares, 0: does not compare, other invalid values max_frame_interval: */
		NT_UINT32(NT_API *SetVideoCompareSameImage)(NT_HANDLE handle, NT_INT32 is_compare_image,
			NT_UINT32 max_frame_interval);

		SetVideoCompareSameImage SetVideoCompareSameImage SetVideoCompareSameImage SetVideoCompareSameImage For example, after image comparison is enabled, the SDK finds that the images are the same for 20 consecutive seconds, but the player needs to receive the key frame to decode and play, so a limit is required
		NT_UINT32(NT_API *SetVideoMaxKeyFrameInterval)(NT_HANDLE handle, NT_INT32 interval);

		/*-- video encoding related interface --*/


		/*+++ + audio related interface +++*/

		/* Get the number of system audio input devices */
		NT_UINT32(NT_API* GetAuidoInputDeviceNumber)(NT_INT32* pNumer);

		Device_name_buff: Device_name_buff_size: device_name_buff_size: Device_name_buff_size: Device_name_buff_size: device_name_buff_size: device_name_buff_size The recommended buffer size is 512 */
		NT_UINT32(NT_API* GetAuidoInputDeviceName)(NT_UINT32 device_id, NT_PSTR device_name_buff, NT_UINT32 device_name_buff_size);

		/* * Set push audio encoding type *type: 1: use AAC encoding, 2: use speex encoding, other values return error * success returns NT_ERC_OK */
		NT_UINT32(NT_API* SetPublisherAudioCodecType)(NT_HANDLE handle, NT_INT32 type);


		/* * Set push Speex encoding quality *quality: range is 0-10, default is 8: about 28kbps, the higher the value, the better the quality, the higher the bit rate */ success returns NT_ERC_OK */
		NT_UINT32(NT_API* SetPublisherSpeexEncoderQuality)(NT_HANDLE handle, NT_INT32 quality);


		Is_mute: 0 indicates unmute, 1 indicates mute */
		NT_UINT32(NT_API* SetMute)(NT_HANDLE handle, NT_INT32 is_mute);

		/* Set the audio input device ID. Device_id: device ID, usually starting from 0 */
		NT_UINT32(NT_API* SetAuidoInputDeviceId)(NT_HANDLE handle, NT_UINT32 device_id);

		Out_flag: 1 indicates that the speaker can be captured, 0 indicates that the speaker cannot be captured. */
		NT_UINT32(NT_API* IsCanCaptureSpeaker)(NT_INT32* out_flag);

		/* * Set whether to compensate mute frames when collecting the speaker. This is only valid in auIDO_option. NT_PB_E_AUDIO_OPTION_CAPTURE_SPEAKER 1 indicates compensation, 0 indicates compensation, otherwise invalid * returns NT_ERC_OK */ on success
		NT_UINT32(NT_API* SetCaptureSpeakerCompensateMute)(NT_HANDLE handle, NT_INT32 is_compensation);

		/* * Set echo cancellation *isCancel: 1: echo cancellation, 0: no echo cancellation *delay: Echo delay, in milliseconds, 100ms is currently recommended, or 100ms will be used if set to 0 * note that this only works for microphone capture, speaker capture is invalid * NT_ERC_OK */ is returned on success
		NT_UINT32(NT_API* SetEchoCancellation)(NT_HANDLE handle, NT_INT32 isCancel, NT_INT32 delay);
		
		/* * Set audio noise suppression *isNS: 1 means noise suppression, 0 means no suppression * Note that this is usually used on the acquisition microphone, the acquisition system must not play the sound is not * success return NT_ERC_OK */
		NT_UINT32(NT_API* SetNoiseSuppression)(NT_HANDLE handle, NT_INT32 isNS);

		IsAGC: 1 indicates gain control, 0 indicates no control
		NT_UINT32(NT_API* SetAGC)(NT_HANDLE handle, NT_INT32 isAGC);


		IsVAD: 1: isVAD: 0: isVAD: 1: isVAD: 0: isVAD: 0: isVAD: 1: isVAD: 0: isVAD
		NT_UINT32(NT_API* SetVAD)(NT_HANDLE handle, NT_INT32 isVAD);


		/* * Set the input volume, this interface is not recommended to call, some special cases may be used, generally not recommended to magnify the volume *index: usually 0 and 1, if there is no mixing, only 0, 0,1 set the volume respectively *volume: Volume, default is 1.0, range is [0.0, 5.0], set to 0 mute, 1 volume unchanged * returns NT_ERC_OK */ on success
		NT_UINT32(NT_API* SetInputAudioVolume)(NT_HANDLE handle, NT_INT32 index, float volume);


		/*-- Audio related interface --*/



		/*+++ Push related interface +++*/

		/* Set the URL to be pushed to multiple RTMP servers at the same time, up to three servers can be pushed to set multiple urls, please call multiple success return NT_ERC_OK */
		NT_UINT32(NT_API *SetURL)(NT_HANDLE handle, NT_PCSTR url, NT_PVOID pReserve);


		Is_encrypt_video: /* Set the RTMP push encryption option url: To allow multiple servers to be pushed, you can configure different encryption options based on the push URL. 1: indicates that the video is encrypted, 0: indicates that the video is not encrypted, by default. Other values return error IS_encrypt_audio: 1: indicates that the audio is encrypted, 0: indicates that the audio is not encrypted, by default. Other values return error with success
		NT_UINT32(NT_API *SetRtmpEncryptionOption)(NT_HANDLE handle, NT_PCSTR url, NT_INT32 is_encrypt_video, NT_INT32 is_encrypt_audio);


		/* Encryption_algorithm: SetURL encryption_algorithm: SetURL encryption_algorithm: SetURL encryption_algorithm: Encryption algorithm. Currently, AES and NATIONAL standard SM4.1 are supported. The default value is SM4
		NT_UINT32(NT_API *SetRtmpEncryptionAlgorithm)(NT_HANDLE handle, NT_PCSTR url, NT_INT32 encryption_algorithm);


		/* Set the RTMP push encryption key URL: Considering that the push may be sent to multiple servers, you can configure different encryption options according to the push URL. Ensure that the URL and SetURL are consistent. If the encryption algorithm is AES, key_size must be 16, 24, 32. If the encryption algorithm is SM4, key_size must be 16, other values return an error. Return NT_ERC_OK */ on success
		NT_UINT32(NT_API *SetRtmpEncryptionKey)(NT_HANDLE handle, NT_PCSTR url, const NT_BYTE* key, NT_UINT32 key_size);


		/* Set RTMP push encryption IV(initialization vector), this interface is not called, the default IV URL will be used: The current value must be 16, other values return error success returns NT_ERC_OK */
		NT_UINT32(NT_API *SetRtmpEncryptionIV)(NT_HANDLE handle, NT_PCSTR url, const NT_BYTE* iv, NT_UINT32 iv_size);


		/* * Set the video packet timestamp callback url: push URL min_call_interval: minimum callback interval (milliseconds), if 0, Callbackdata: user-defined data during callback call_back: callback function pointer */
		NT_UINT32(NT_API *SetVideoPacketTimestampCallBack)(NT_HANDLE handle,
			NT_PCSTR url, NT_UINT32 min_call_interval,
			NT_PVOID call_back_data, NT_PB_SDKVideoPacketTimestampCallBack call_back);


		Call_back_data: user - defined data call_back */
		NT_UINT32(NT_API *SetPublisherStatusCallBack)(NT_HANDLE handle,
			NT_PVOID call_back_data, NT_PB_SDKPublisherStatusCallBack call_back);

		/* Start push */
		NT_UINT32(NT_API *StartPublisher)(NT_HANDLE handle, NT_PVOID pReserve);

		/* Stop push */
		NT_UINT32(NT_API *StopPublisher)(NT_HANDLE handle);

		/*-- push related interface --*/


		/*+++ publish RTSP stream-related interfaces +++*/


		/* * Set RTSP stream name * stream_name: stream name, cannot be an empty string, must be English * Such as RTSP url is: RTSP: / / 192.168.0.111 / test, the test is set down stream_name * successfully returns NT_ERC_OK * /
		NT_UINT32(NT_API *SetRtspStreamName)(NT_HANDLE handle, NT_PCSTR stream_name);

		/* * Set the RTSP server for the RTSP stream to be published. A stream can be published to multiple RTSP servers. Push instance handle * RTSP_server_HANDLE: RTSP server handle * reserve: reserve parameter, pass 0 */
		NT_UINT32(NT_API *AddRtspStreamServer)(NT_HANDLE handle, NT_HANDLE rtsp_server_handle, NT_INT32 reserve);

		
		/* * Clear the set RTSP server */
		NT_UINT32(NT_API *ClearRtspStreamServer)(NT_HANDLE handle);


		/* Start RTSP stream reserve: reserve parameter, pass 0 */
		NT_UINT32(NT_API *StartRtspStream)(NT_HANDLE handle, NT_INT32 reserve);

		
		/* Stop the RTSP stream */
		NT_UINT32(NT_API *StopRtspStream)(NT_HANDLE handle);


		/*-- publish the RTSP stream-related interface --*/



		/*+++ Push RTSP related interfaces +++*/

		Transport_protocol: 1: indicates that UDP RTP packets are transmitted. 2 indicates that TCP transmits RTP packets. The default is 1 for UDP transmission. The SDK reported an error when uploading other values. Return NT_ERC_OK */ on success
		NT_UINT32(NT_API *SetPushRtspTransportProtocol)(NT_HANDLE handle, NT_INT32 transport_protocol);

		/* Set RTSP URL successfully returns NT_ERC_OK */
		NT_UINT32(NT_API *SetPushRtspURL)(NT_HANDLE handle, NT_PCSTR url);


		/* Start push RTSP stream reserve: reserve parameter, pass 0 */
		NT_UINT32(NT_API *StartPushRtsp)(NT_HANDLE handle, NT_INT32 reserve);

		
		/* Stop pushing RTSP stream */
		NT_UINT32(NT_API *StopPushRtsp)(NT_HANDLE handle);


		/*-- push RTSP related interface --*/
		

		/*+++ + Video related interface +++*/

		/* Set the local video directory, the directory must be English, otherwise it will fail */
		NT_UINT32(NT_API *SetRecorderDirectory)(NT_HANDLE handle, NT_PCSTR dir, NT_PVOID pReserve);

		/* Sets the maximum size of a single video file. When this value is exceeded, it will be cut into a second file size: the unit is KB(1024 bytes). The current range is [5MB-1GB]
		NT_UINT32(NT_API *SetRecorderFileMaxSize)(NT_HANDLE handle, NT_UINT32 size);

		/* Set the video file name generation rule */
		NT_UINT32(NT_API *SetRecorderFileNameRuler)(NT_HANDLE handle, NT_PB_RecorderFileNameRuler* ruler);

		/* Start recording */
		NT_UINT32(NT_API *StartRecorder)(NT_HANDLE handle, NT_PVOID pReserve);

		/* Pause recording is_pause: 1: pause recording, 0: resume recording, any other values will fail. NT_ERC_OK: NT_ERC_PB_NEED_RETRY. Please try */ at an interval
		NT_UINT32(NT_API *PauseRecorder)(NT_HANDLE hanlde, NT_INT32 is_pause);

		/* Stop recording */
		NT_UINT32(NT_API *StopRecorder)(NT_HANDLE handle);

		/*-- video related interface --*/


		/*+++ preview related interfaces +++*/

		/* Set the preview image callback image_format: see NT_PB_E_IMAGE_FORMAT, only NT_PB_E_IMAGE_FORMAT_RGB32, NT_PB_E_IMAGE_FORMAT_I420 */
		NT_UINT32(NT_API *SetVideoPreviewImageCallBack)(NT_HANDLE handle,
			NT_INT32 image_format,
			NT_PVOID call_back_data, NT_PB_SDKVideoPreviewImageCallBack call_back);

		/* Start preview reserve1: Reserve parameter 0 pReserve2: Reserve parameter NULL */
		NT_UINT32(NT_API *StartPreview)(NT_HANDLE handle, NT_UINT32 reserve1, NT_PVOID pReserve2);

		/* Stop preview */
		NT_UINT32(NT_API *StopPreview)(NT_HANDLE handle);


		/*-- previews related interfaces --*/

		/* * Deliver encoded video data to SDK * codec_id: please refer to NT_MEDIA_CODEC_ID, note that do not pass auido codec ID, otherwise the result is not defined * data: encoded data * size: Encoding data size * is_key_frame: 1: indicates a key frame, 0: indicates not * timestamp: timestamp * NT_ERC_OK */ is returned successfully
		NT_UINT32(NT_API *PostVideoEncodedData)(NT_HANDLE handle, NT_UINT32 codec_id, 
			const NT_BYTE* data, NT_UINT32 size,
			NT_INT32 is_key_frame, NT_UINT64 timestamp);


		/* * * Drop encoded video data to SDK V2 * codec_id: please refer to NT_MEDIA_CODEC_ID, note that do not pass auido codec id, otherwise the result is not defined * data: encoded data * size: Encoding data size * IS_KEY_frame: 1: indicates a key frame, 0: indicates not * TIMESTAMP: decoded timestamp * Presentation_timestamp: Note: Make sure presentation_TIMESTAMP >= TIMESTAMP, otherwise the result is undefined * NT_ERC_OK */ is returned successfully
		NT_UINT32(NT_API *PostVideoEncodedDataV2)(NT_HANDLE handle, NT_UINT32 codec_id,
			const NT_BYTE* data, NT_UINT32 size,
			NT_INT32 is_key_frame, NT_UINT64 timestamp, NT_UINT64 presentation_timestamp);


		* * * Drop encoded audio data to SDK *codec_id: see NT_MEDIA_CODEC_ID, note that do not pass video codec ID, otherwise the result is not defined * data: encoded data * size: * is_key_frame: 1: a key frame, 0: a non-key frame * timestamp: timestamp * parameter_info: NULL * parameter_info_size: parameter_INFO length * NT_ERC_OK */ is returned on success
		NT_UINT32(NT_API *PostAudioEncodedData)(NT_HANDLE handle, NT_UINT32 codec_id,
			const NT_BYTE* data, NT_UINT32 size,
			NT_INT32 is_key_frame, NT_UINT64 timestamp,
			const NT_BYTE*  parameter_info,
			NT_UINT32 parameter_info_size);


		/* * * Send PCM audio data to SDK every 10ms * * DATA: PCM data, note that each sample must be 16 bits, other formats are not supported, note that dual channel data is interleaved * size: PCM data size * timestamp: timestamp in milliseconds, must be increasing * sample_rate: sampling rate * Channels: Per_channel_sample_number: this is passed in sampleRate/100, which is the number of samples in 10 milliseconds for a single channel */
		NT_UINT32(NT_API *PostAudioPCMData)(NT_HANDLE handle,
			const NT_BYTE* data, NT_UINT32 size, NT_UINT64 timestamp,
			NT_INT32 sample_rate, NT_INT32 channels, NT_INT32 per_channel_sample_number);


		/* * * This interface is only used when auIDO_option is NT_PB_E_AUDIO_OPTION_MIC_EXTERNAL_PCM_MIXER, * * Data: PCM data, note that each sample must be 16 bits, other formats are not supported, note that dual channel data is interleave * size: PCM data size * timestamp: timestamp in milliseconds, must be increasing * sample_rate: sampling rate * Channels: Per_channel_sample_number: this is passed in sampleRate/100, which is the number of samples in 10 milliseconds for a single channel */
		NT_UINT32(NT_API *PostAudioExternalPCMMixerData)(NT_HANDLE handle,
			const NT_BYTE* data, NT_UINT32 size, NT_UINT64 timestamp,
			NT_INT32 sample_rate, NT_INT32 channels, NT_INT32 per_channel_sample_number);



		/*++++ send user - defined data related interface ++++*/
		/* * 1. Currently, the SEI mechanism is used to send user-definable data to the player * 2. This mechanism may lose data, so there is no guarantee that the receiver will receive * 3. Advantages: Can keep in sync with the video, although it may be lost, but the general needs are met * 4. There are currently two sending methods: the first sends binary data, and the second sends utF8 string */

		/* * Set the size of the send queue, the default size is 3 to ensure real time, you must set a number greater than 0 * If the data exceeds the queue size, queue header data will be discarded * this interface should be called before StartPublisher */
		NT_UINT32(NT_API *SetPostUserDataQueueMaxSize)(NT_HANDLE handle, NT_INT32 max_size, NT_INT32 reserve);


		PostUserXXX * */ PostUserXXX * */; PostUserXXX * */; PostUserXXX * */
		NT_UINT32(NT_API *ClearPostUserDataQueue)(NT_HANDLE handle);

		/* * Send binary data * data: binary data * size: data size * Note: 1. Currently, the data size is limited to 256 bytes, too large may affect video transmission. If you have special requirements, please contact us to increase the limit * 2. If the accumulated data exceeds the set queue size, the previous queue header data is discarded * 3. You must call StartPublisher again before sending the data */
		NT_UINT32(NT_API *PostUserData)(NT_HANDLE handle, const NT_BYTE* data, NT_UINT32 size, NT_INT32 reserve);

		/* * Send utf8 string * UTf8_str: utf8 string * The length of the string cannot exceed 256, too large may affect the video transmission, if you have special requirements, need to increase the limit, please contact us * 2. If the accumulated data exceeds the set queue size, the previous queue header data is discarded * 3. You must call StartPublisher again before sending the data */
		NT_UINT32(NT_API *PostUserUTF8StringData)(NT_HANDLE handle, NT_PCSTR utf8_str, NT_INT32 reserve);


		/*---- send user - defined data related interface ----*/


		/* Set the hibernation mode. Mode: 1 indicates hibernation, 0 indicates no hibernation. Reserve: This parameter is reserved
		NT_UINT32(NT_API *SetSleepMode)(NT_HANDLE hanlde, NT_INT32 mode, NT_INT32 reserve);


		/* Universal interface, set parameters, most problems, these interfaces can solve */
		NT_UINT32(NT_API *SetParam)(NT_HANDLE handle, NT_UINT32 id, NT_PVOID pData);

		/* Universal interface, get parameters, most problems, these interfaces can solve */
		NT_UINT32(NT_API *GetParam)(NT_HANDLE handle, NT_UINT32 id, NT_PVOID pData);

		/*+++ screen picker +++*/
		/* This interface returns a different handle than the one used in the Open interface

		/* mode: see NT_PB_E_SCREEN_REGION_CHOOSE_MODE mode_data: Mode == NT_PB_E_SCREEN_REGION_CHOOSE_MODE_CHOOSE, mode_data is NULL. Mode == NT_PB_E_SCREEN_REGION_CHOOSE_MODE_MOVE, Mode_data is NT_PB_RectRegion* callback: This must be present and must be handled otherwise the resource leaks callback_data: Callback data flag (0); pReserve (NULL); open a screen picker toolHandle and return NT_ERC_OK */
		NT_UINT32(NT_API *OpenScreenRegionChooseTool)(NT_PHANDLE pToolHandle,
			NT_UINT32 mode, 
			NT_PVOID  mode_data,
			NT_PB_SDKScreenRegionChooseCallBack callback,
			NT_PVOID callback_data,
			NT_UINT32 flag, NT_PVOID pReserve);

		/* The toolHandle fails after calling this interface and returns NT_ERC_OK */ on success
		NT_UINT32(NT_API *CloseScreenRegionChooseTool)(NT_HANDLE toolHandle);

		/*-- screen picker --*/



		/*+++ RTSP Server operation interface +++*/


		/* * Create an RTSP server * pRtspServerHandle: RTSP Server handle * reserve: Reserve parameter pass 0 * return NT_ERC_OK */ on success
		NT_UINT32(NT_API *OpenRtspServer)(NT_PHANDLE pRtspServerHandle, NT_INT32 reserve);

		* rtSP_server_handle: RTSP server handle * port: The port number can be set to 554 or between 1024 and 65535. Other values return failure * Success NT_ERC_OK */
		NT_UINT32(NT_API *SetRtspServerPort)(NT_HANDLE rtsp_server_handle, NT_INT32 port);

		* rtSP_server_handle: RTSP server handle * user_name: RTSP server handle User name, English * password: password, English * NT_ERC_OK */ is returned on success
		NT_UINT32(NT_API *SetRtspServerUserNamePassword)(NT_HANDLE rtsp_server_handle, NT_PCSTR user_name, NT_PCSTR password);


		Rtsp_server_handle: rtsp_server_handle: rtsp_server_handle: rtsp_server_handle: rtsp_server_handle: RTSP server handle * IS_multicast: whether to multicast, 1 is multicast, 0 is unicast, other values interface return error, default unicast * return NT_ERC_OK */ on success
		NT_UINT32(NT_API *SetRtspServerMulticast)(NT_HANDLE rtsp_server_handle, NT_INT32 is_multicast);


		/* * Set RTSP server multicast multicast address * rtSP_server_handle: RTSP server handle * multicast_address: Multicast address * If the address is not a multicast address, an error is returned. Multicast address range: [224.0.0.0, 224.0.0.255] are reserved multicast addresses and cannot be set. The value range is 224.0.1.0, 239.255.255.255. The SSM address range is 232.0.0.0, 232.255.255.255. NT_ERC_OK */ is returned successfully
		NT_UINT32(NT_API *SetRtspServerMulticastAddress)(NT_HANDLE rtsp_server_handle, NT_PCSTR multicast_address);


		* rtSP_server_handle: RTSP server handle * session_numbers: rtSP_handle: RTSP server handle * session_numbers: Number of sessions * Returns NT_ERC_OK */ on success
		NT_UINT32(NT_API *GetRtspServerClientSessionNumbers)(NT_HANDLE rtsp_server_handle, NT_INT32* session_numbers);


		/* * Start RTSP server * RtSP_server_HANDLE: RTSP server handle * reserve: Reserve parameter pass 0 * Successful return NT_ERC_OK */
		NT_UINT32(NT_API *StartRtspServer)(NT_HANDLE rtsp_server_handle, NT_INT32 reserve);

		/* * Stop RTSP server * RtSP_server_HANDLE: RTSP server handle * NT_ERC_OK */ is successfully returned
		NT_UINT32(NT_API *StopRtspServer)(NT_HANDLE rtsp_server_handle);

		/* * Close RTSP server * rtsp_server_handle fails after calling this interface, * returns NT_ERC_OK */ on success
		NT_UINT32 (NT_API *CloseRtspServer)(NT_HANDLE rtsp_server_handle);


		/*-- RTSP server operation interface --*/




		/*+++ + NT_PB_Image +++*/
		NT_SmartPublisherImageSDKAPI ImageAPI_;
		/*-- NT_PB_Image operation function --*/


		/*+++ + Draw operation +++*/
		NT_SmartPublisherDrawImageSDKAPI drawImageAPI_;
		/*-- draw operation --*/

	} NT_SmartPublisherSDKAPI;


	NT_UINT32 NT_API NT_GetSmartPublisherSDKAPI(NT_SmartPublisherSDKAPI* pAPI);


	NT_PVOID: NULL is passed successfully. NT_ERC_OK */ is returned
	NT_UINT32 NT_API NT_PB_SetSDKClientKey(NT_PCSTR cid, NT_PCSTR key, NT_INT32 reserve1, NT_PVOID reserve2);


#ifdef __cplusplus
}
#endif

#endif
Copy the code

Design essentials of cross-platform screen/camera RTMP stream push module

RTMP push SDK features:

On a graph:

Features:

Supported platform architecture

Windows Video collection and processing

Windows audio collection processing related

Windows/Android/iOS video SDK related

Attached with a Windows push SDK oral file:

Related Posts

The Android platform uses Camera2 (5.0+) instead of the outdated Camera

Use Qt Creator as Linux IDE to compile Redis source code and debug breakpoints

HarmonyOS Learn the Road – Intent