Comment un casque VR lit-il le RTSP 8K avec une faible latence

Comment le casque VR lit-il le flux RTSP|RTMP 8K avec une faible latence ?

2024-07-12

formation technique

Lorsque nous créions des lecteurs RTSP et RTMP pour la plate-forme Unity, certaines entreprises ont mis en avant de telles exigences techniques, dans l'espoir de lire des flux en direct panoramiques 8K RTSP|RTMP et des données 8K sur le casque, ce qui a proposé de nouvelles idées pour le casque et le lecteur. En fonction des exigences, nous discuterons de la manière dont les visiocasques VR lisent les données de streaming RTSP|RTMP 8K sous plusieurs aspects :

1. Assistance aux joueurs

compatibilité : Premièrement, le lecteur RTSP|RTMP doit prendre en charge le streaming vidéo en résolution 8K. Cela signifie que le lecteur doit être capable de décoder la vidéo 8K et de la lire sur un périphérique d'affichage prenant en charge la résolution 8K. Inutile de dire que nous le prenons déjà en charge.
capacité de décodage : Le lecteur doit disposer de puissantes capacités de décodage pour gérer la grande quantité de données contenues dans le flux vidéo 8K. Cela nécessite généralement que le joueur utilise des algorithmes de décodage efficaces et utilise pleinement les fonctions d'accélération matérielle (telles que l'accélération GPU), ce qui nécessite que le casque prenne en charge le décodage dur 8K.

2. Exigences du réseau

bande passante : Le streaming vidéo 8K nécessite une bande passante réseau extrêmement élevée pour prendre en charge la transmission en temps réel. Assurez-vous que la bande passante du réseau est suffisamment grande pour éviter des problèmes tels que le retard, le retard ou la mise en mémoire tampon pendant la lecture. S'il s'agit d'un environnement intranet, ne vous inquiétez pas des problèmes de bande passante.
la stabilité : La stabilité de la connexion réseau est également très importante. Une connexion réseau instable peut entraîner une interruption du streaming vidéo ou une dégradation de la qualité.

3. Exigences matérielles

Processeur et mémoire: Les casques VR diffusent des flux vidéo 8K, ce qui impose des exigences très élevées en matière de performances des casques VR. Par exemple, quest3 est un bon choix.

4. Étapes de lecture

Sélectionnez le lecteur RTSP: Notre approche consiste à utiliser le lecteur RTSP|RTMP natif du Daniu Live SDK en mode de décodage dur pour rappeler les données YUV ou RGB décodées à l'unité. Il est à noter qu'en raison du flux RTSP|RTMP 8K, la quantité de données. Les données très volumineuses, notamment décodées, doivent être réduites le moins possible si les conditions le permettent.

Réalisation technique

Cet article prend comme exemple le module de lecture RTSP|RTMP de la plateforme Android Unity3D du SDK Daniu Live :

Commencer à jouer:


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

L'implémentation OpenPlayer() correspondante est la suivante :


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

Fermer le joueur :


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

Mettre à jour les données d'actualisation :


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

Résumer

Si un casque VR doit lire des flux RTSP ou RTSP 8K, il a des exigences très élevées en matière de matériel et de réseau, il peut donc rencontrer certains défis dans les applications pratiques. Grâce à des tests réels, le casque quest3, combiné à notre lecteur RTSP|RTMP, peut atteindre un retard de la milliseconde dans la lecture des données vidéo 8K dans Unity pour répondre à des scénarios d'utilisation avec des exigences en temps réel très élevées, telles que le contrôle de la balance. Les développeurs intéressés peuvent en discuter. avec moi individuellement.

Partage de technologie