Wie spielt ein VR-Headset 8K-RTSP mit geringer Latenz ab?|RTMP-Streaming

Wie spielt das VR-Headset 8K RTSP|RTMP-Streams mit geringer Latenz ab?

2024-07-12

technischer Hintergrund

Als wir RTSP- und RTMP-Player für die Unity-Plattform entwickelten, stellten einige Unternehmen solche technischen Anforderungen und hofften, 8K-RTSP|RTMP-Panorama-Livestreams und 8K-Daten auf dem Headset abspielen zu können, was neue Ideen für das Headset und den Player vorsah Um die Anforderungen zu erfüllen, werden wir unter verschiedenen Aspekten besprechen, wie VR-Head-Mount-Geräte 8K-RTSP|RTMP-Streaming-Daten wiedergeben:

1. Spielerunterstützung

Kompatibilität : Erstens muss der RTSP|RTMP-Player Videostreaming mit 8K-Auflösung unterstützen. Das bedeutet, dass der Player in der Lage sein muss, 8K-Videos zu dekodieren und auf einem Anzeigegerät abzuspielen, das die 8K-Auflösung unterstützt. Selbstverständlich unterstützen wir dies bereits.
Dekodierungsfähigkeit : Der Player muss über leistungsstarke Dekodierungsfunktionen verfügen, um die große Datenmenge im 8K-Videostream verarbeiten zu können. Dies erfordert in der Regel, dass der Player effiziente Dekodierungsalgorithmen verwendet und die Hardwarebeschleunigungsfunktionen (z. B. GPU-Beschleunigung) vollständig nutzt, was erfordert, dass das Headset 8K-Harddekodierung unterstützt.

2. Netzwerkanforderungen

Bandbreite : 8K-Videostreaming erfordert eine extrem hohe Netzwerkbandbreite, um die Echtzeitübertragung zu unterstützen. Stellen Sie sicher, dass die Netzwerkbandbreite groß genug ist, um Probleme wie Verzögerungen, Verzögerungen oder Pufferung während der Wiedergabe zu vermeiden. Wenn es sich um eine Intranet-Umgebung handelt, müssen Sie sich grundsätzlich keine Sorgen über Bandbreitenprobleme machen.
Stabilität : Auch die Stabilität der Netzwerkverbindung ist sehr wichtig. Eine instabile Netzwerkverbindung kann dazu führen, dass das Video-Streaming unterbrochen wird oder die Qualität abnimmt.

3. Hardwareanforderungen

Prozessor und SpeicherHinweis: VR-Headsets spielen 8K-Videostreams ab, was sehr hohe Anforderungen an die Leistung von VR-Headsets stellt. Beispielsweise ist quest3 eine gute Wahl.

4. Wiedergabeschritte

Wählen Sie RTSP-Player: Unser Ansatz besteht darin, den nativen RTSP|RTMP-Player von Daniu Live SDK im Hard-Dekodierungsmodus zu verwenden, um die dekodierten YUV- oder RGB-Daten auf Unity zurückzurufen. Es ist zu beachten, dass aufgrund des 8K-RTSP|RTMP-Streams die Datenmenge Bei sehr großen, insbesondere dekodierten Daten ist es erforderlich, die Kopien so gering wie möglich zu halten, sofern die Bedingungen dies zulassen.

Technische Umsetzung

In diesem Artikel wird das Unity3D RTSP|RTMP-Wiedergabemodul des Daniu Live SDK für die Android-Plattform als Beispiel verwendet:

Jetzt Spielen:


/*
 * 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;  
}

Die entsprechende OpenPlayer()-Implementierung lautet wie folgt:


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");
}

Spieler schließen:


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;
}

Aktualisierungsdaten aktualisieren:


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;
}

Zusammenfassen

Wenn ein VR-Headset 8K-RTSP- oder RTSP-Streams abspielen muss, stellt es sehr hohe Hardware- und Netzwerkanforderungen, sodass es in praktischen Anwendungen auf einige Herausforderungen stoßen kann. Durch tatsächliche Tests kann das quest3-Headset in Kombination mit unserem RTSP|RTMP-Player eine Verzögerung der 8K-Videodatenwiedergabe in Unity erreichen, um Anwendungsszenarien mit sehr hohen Echtzeitanforderungen wie der Balance-Steuerung zu erfüllen bei mir individuell.

Technologieaustausch