Technology Sharing

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

technical background

When we were developing the RTSP and RTMP players for the Unity platform, a company proposed a technical requirement to play panoramic 8K RTSP|RTMP live streams on head-mounted displays. 8K data puts forward new requirements for head-mounted displays and players. We will explore how VR head-mounted display devices can play 8K RTSP|RTMP stream data from several aspects:

1. Player support

1. compatibility: First of all, the RTSP|RTMP player needs to support 8K resolution video streaming. This means that the player must be able to decode 8K video and play it on a display device that supports 8K resolution. Needless to say, we already support this.
2. Decoding capability: The player needs to have powerful decoding capabilities to process the large amount of data in the 8K video stream. This usually requires the player to use efficient decoding algorithms and make full use of hardware acceleration functions (such as GPU acceleration), which requires the headset to support 8K hard decoding.

2. Network requirements

1. bandwidth: 8K video streaming requires extremely high network bandwidth to support real-time transmission. Make sure the network bandwidth is large enough to avoid problems such as freezing, delay or buffering during playback. If it is in an intranet environment, basically do not worry about bandwidth issues.
2. stability: The stability of the network connection is also very important. An unstable network connection may cause video streaming interruptions or quality degradation.

3. Hardware Requirements

1. Processor and Memory: VR headsets playing 8K video streams place very high demands on the performance of VR headsets. For example, Quest3 is a good choice.

4. Playback steps

1. Select RTSP player: What we do is use the native RTSP|RTMP player of the Danniu Live SDK, in hard decoding mode, and call back the decoded YUV or RGB data to Unity. It should be noted that due to the 8K RTSP|RTMP stream, the amount of data is very large, especially the decoded data. If conditions permit, it is necessary to reduce the copying as much as possible.

Technical realization

This article takes the Android platform Unity3D RTSP|RTMP playback module of Danniu Live SDK as an example:

Start playing:

/*
 * SmartPlayerAndroidMono.cs
 * Author: daniusdk.com
 * QQ：89030985
 */
public void Play()
{
	if (is_running)
	{
		Debug.Log("已经在播放。。");   
		return;
	}
 
	//获取输入框的url
	string url = input_url_.text.Trim();
 
	if (!url.StartsWith("rtmp://") && !url.StartsWith("rtsp://"))
	{
		videoUrl = "rtsp://admin:[email protected]:554/h264/ch1/main/av_stream";
	}
	else
	{
		videoUrl = url;
	}
 
	OpenPlayer();
 
	if ( player_handle_ == 0 )
		return;
 
	NT_U3D_Set_Game_Object(player_handle_, game_object_);
 
	/* ++ 播放前参数配置可加在此处 ++ */
	int is_using_tcp = 0;        //TCP/UDP模式设置
	NT_U3D_SetRTSPTcpMode(player_handle_, is_using_tcp);
 
	int is_report = 0;
	int report_interval = 1;
	NT_U3D_SetReportDownloadSpeed(player_handle_, is_report, report_interval);  //下载速度回调
 
	NT_U3D_SetBuffer(player_handle_, play_buffer_time_);                        //设置buffer time
 
	NT_U3D_SetPlayerLowLatencyMode(player_handle_, is_low_latency_ ? 1 : 0);    //设置是否启用低延迟模式
 
	NT_U3D_SetMute(player_handle_, is_mute_ ? 1 : 0);                           //是否启动播放的时候静音
 
	NT_U3D_SetAudioVolume(player_handle_, cur_audio_volume_);                   //设置播放音量
 
	NT_U3D_SetVideoDecoderMode(player_handle_, is_hw_decode_ ? 1 : 0);          //设置H.264软硬解模式
 
	NT_U3D_SetVideoHevcDecoderMode(player_handle_, is_hw_decode_ ? 1 : 0);          //设置H.265软硬解模式
 
	int is_output = 1;
	int disable_use_image_planes = 0;
	bool is_supports_texture_format = SystemInfo.SupportsTextureFormat(TextureFormat.RG16);
	Debug.Log("is_supports_texture_format: " + is_supports_texture_format);
	int is_supported_multiple_format = is_supports_texture_format? 1:0;
	int max_images = 3;
	int buffer_pool_max_size = 0;
	NT_U3D_SetImageReaderOutput(player_handle_, is_output, disable_use_image_planes, is_supported_multiple_format, max_images, buffer_pool_max_size);  //硬解码image reader
 
	int is_fast_startup = 1;
	NT_U3D_SetFastStartup(player_handle_, is_fast_startup);                     //设置快速启动模式
 
	int rtsp_timeout = 10;
	NT_U3D_SetRTSPTimeout(player_handle_, rtsp_timeout);                        //设置RTSP超时时间
 
	int is_auto_switch_tcp_udp = 1;
	NT_U3D_SetRTSPAutoSwitchTcpUdp(player_handle_, is_auto_switch_tcp_udp);    //设置TCP/UDP模式自动切换
 
	int is_audiotrack = 1;
	NT_U3D_SetAudioOutputType(player_handle_, is_audiotrack);                   //设置音频输出模式: if 0: 自动选择; if with 1: audiotrack模式
 
	NT_U3D_SetUrl(player_handle_, videoUrl);
	/* -- 播放前参数配置可加在此处 -- */
 
	int flag = NT_U3D_StartPlay(player_handle_);
 
	if (flag  == DANIULIVE_RETURN_OK)
	{
		is_need_get_frame_ = true;
		Debug.Log("播放成功");
	}
	else
	{
		is_need_get_frame_ = false;
		Debug.LogError("播放失败");
	}
 
	is_running = true;  
}

The corresponding OpenPlayer() implementation is as follows:

private void OpenPlayer()
{
	if ( java_obj_cur_activity_ == null )
	{
		Debug.LogError("getApplicationContext is null");
		return;
	}
 
	player_handle_ = NT_U3D_Open();
 
	if (player_handle_ != 0)
		Debug.Log("open success");
	else
		Debug.LogError("open fail");
}

Close the Player:

private void ClosePlayer()
{
	is_need_get_frame_ = false;
	is_need_init_texture_ = false;
 
	int flag = NT_U3D_StopPlay(player_handle_);
	if (flag == DANIULIVE_RETURN_OK)
	{
		Debug.Log("停止成功");
	}
	else
	{
		Debug.LogError("停止失败");
	}
 
	flag = NT_U3D_Close(player_handle_);
	if (flag == DANIULIVE_RETURN_OK)
	{
		Debug.Log("关闭成功");
	}
	else
	{
		Debug.LogError("关闭失败");
	}
 
	player_handle_ = 0;
 
	NT_U3D_UnInit();
 
	is_running = false;
	video_format_ = VideoFrame.FORMAT_UNKNOWN;
	video_width_ = 0;
	video_height_ = 0;
}

Update refresh data:

private void Update()
{
	if (!is_need_get_frame_)
		return;
 
	if (player_handle_ == 0)
		return;
 
	AndroidJavaObject u3d_video_frame_obj = NT_U3D_GetVideoFrame(player_handle_);
 
	if (u3d_video_frame_obj == null)
	{
		return;
	}
 
	VideoFrame converted_video_frame = ConvertToVideoFrame(u3d_video_frame_obj);
 
	if (converted_video_frame == null)
	{
		u3d_video_frame_obj.Call("release");
 
	   u3d_video_frame_obj = null;
	   return;
	}
 
	if (!is_need_init_texture_)
	{
		if (converted_video_frame.format_ != video_format_)
		{
			is_need_init_texture_ = true;
 
		}
		else if (converted_video_frame.width_ != video_width_
			|| converted_video_frame.height_ != video_height_
			|| converted_video_frame.stride0_ != y_row_bytes_
			|| converted_video_frame.stride1_ != u_row_bytes_
			|| converted_video_frame.stride2_ != v_row_bytes_)
		{
			is_need_init_texture_ = true;
		}
	}
 
	if (is_need_init_texture_)
	{
		if (InitYUVTexture(converted_video_frame))
		{
			is_need_init_texture_ = false;
		}
	}
 
	UpdateYUVTexture(converted_video_frame);
 
	converted_video_frame.java_frame_obj_ = null;
	converted_video_frame = null;
	u3d_video_frame_obj.Call("release");
	u3d_video_frame_obj = null;
}

Summarize

If VR headsets need to play 8K RTSP or RTSP streams, the hardware and network requirements are very high, so there may be some challenges in actual applications. Through actual tests, on the Quest3 headset, with our RTSP|RTMP player, under Unity, 8K video data playback with millisecond delay can be achieved to meet the use scenarios with very high real-time requirements such as balance control. Interested developers can discuss with me separately.