In che modo un visore VR riproduce 8K RTSP con bassa latenza|RTMP streaming

In che modo le cuffie VR riproducono lo streaming 8K RTSP|RTMP con bassa latenza?

2024-07-12

background tecnico

Quando stavamo realizzando lettori RTSP e RTMP per la piattaforma Unity, alcune aziende hanno avanzato tali requisiti tecnici, sperando di riprodurre streaming live panoramici RTSP|RTMP 8K e dati 8K sulle cuffie, cosa che ha proposto nuove idee per le cuffie e il lettore requisiti, discuteremo di come i dispositivi VR montati sulla testa riproducono dati in streaming 8K RTSP | RTMP da diversi aspetti:

1. Supporto al giocatore

Compatibilità : Innanzitutto, il lettore RTSP|RTMP deve supportare lo streaming video con risoluzione 8K. Ciò significa che il lettore deve essere in grado di decodificare video 8K e riprodurli su un dispositivo di visualizzazione che supporti la risoluzione 8K. Inutile dire che lo supportiamo già.
capacità di decodifica : il lettore deve disporre di potenti capacità di decodifica per gestire la grande quantità di dati nel flusso video 8K. Ciò di solito richiede che il lettore utilizzi algoritmi di decodifica efficienti e sfrutti appieno le funzioni di accelerazione hardware (come l'accelerazione GPU), che richiede che le cuffie supportino la decodifica hard 8K.

2. Requisiti di rete

larghezza di banda : lo streaming video 8K richiede una larghezza di banda di rete estremamente elevata per supportare la trasmissione in tempo reale. Assicurati che la larghezza di banda della rete sia sufficientemente grande da evitare problemi come rallentamenti, ritardi o buffering durante la riproduzione. Se si tratta di un ambiente intranet, in pratica non preoccuparti dei problemi di larghezza di banda.
stabilità : Anche la stabilità della connessione di rete è molto importante. Una connessione di rete instabile può causare l'interruzione dello streaming video o un peggioramento della qualità.

3. Requisiti hardware

Processore e memoria: I visori VR riproducono flussi video 8K, che impongono requisiti molto elevati alle prestazioni dei visori VR. Ad esempio, quest3 è una buona scelta.

4. Passaggi di riproduzione

Seleziona il lettore RTSP: Il nostro approccio consiste nell'utilizzare il lettore RTSP|RTMP nativo di Daniu Live SDK in modalità di decodifica rigida per richiamare i dati YUV o RGB decodificati all'unità. Va notato che a causa del flusso RTSP|RTMP 8K, la quantità di dati Dati molto grandi, soprattutto decodificati, è necessario ridurre le copie il meno possibile se le condizioni lo consentono.

Realizzazione tecnica

Questo articolo prende come esempio il modulo di riproduzione Unity3D RTSP|RTMP della piattaforma Android di Daniu Live SDK:

Inizia a giocare:


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

La corrispondente implementazione di OpenPlayer() è la seguente:


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

Giocatore vicino:


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

Aggiorna i dati di aggiornamento:


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

Riassumere

Se un visore VR deve riprodurre flussi 8K RTSP o RTSP, ha requisiti hardware e di rete molto elevati, quindi potrebbe incontrare alcune sfide nelle applicazioni pratiche. Attraverso test effettivi, le cuffie quest3, combinate con il nostro lettore RTSP|RTMP, possono raggiungere un ritardo di livello di millisecondo nella riproduzione di dati video 8K in Unity per soddisfare scenari di utilizzo con requisiti in tempo reale molto elevati come il controllo del bilanciamento. Gli sviluppatori interessati possono discuterne con me individualmente.

Condivisione della tecnologia