Compartir tecnología

¿Cómo reproducen los auriculares VR transmisiones 8K RTSP|RTMP con baja latencia?

2024-07-12

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

experiencia técnica

Cuando estábamos fabricando reproductores RTSP y RTMP para la plataforma Unity, algunas empresas presentaron tales requisitos técnicos, con la esperanza de reproducir transmisiones en vivo panorámicas 8K RTSP|RTMP y datos 8K en los auriculares, lo que propuso nuevas ideas para los auriculares y el reproductor. los requisitos, analizaremos cómo los dispositivos VR montados en la cabeza reproducen datos de transmisión 8K RTSP|RTMP desde varios aspectos:

1. Soporte al jugador

  1. compatibilidad : En primer lugar, el reproductor RTSP|RTMP debe admitir la transmisión de vídeo con resolución de 8K. Esto significa que el reproductor debe poder decodificar videos de 8K y reproducirlos en un dispositivo de visualización que admita una resolución de 8K. No hace falta decir que ya lo admitimos.
  2. capacidad de decodificación : El reproductor debe tener potentes capacidades de decodificación para manejar la gran cantidad de datos en la transmisión de video de 8K. Esto generalmente requiere que el reproductor utilice algoritmos de decodificación eficientes y haga un uso completo de las funciones de aceleración de hardware (como la aceleración de GPU), lo que requiere que los auriculares admitan la decodificación física de 8K.

2. Requisitos de red

  1. banda ancha : La transmisión de vídeo de 8K requiere un ancho de banda de red extremadamente alto para admitir la transmisión en tiempo real. Asegúrese de que el ancho de banda de la red sea lo suficientemente grande para evitar problemas como retrasos, demoras o almacenamiento en búfer durante la reproducción. Si se trata de un entorno de intranet, básicamente no se preocupe por los problemas de ancho de banda.
  2. estabilidad : La estabilidad de la conexión de red también es muy importante. Una conexión de red inestable puede provocar que la transmisión de vídeo se interrumpa o se degrade su calidad.

3. Requisitos de hardware

  1. Procesador y memoria: Los cascos de realidad virtual reproducen transmisiones de video de 8K, lo que impone requisitos muy altos en el rendimiento de los cascos de realidad virtual. Por ejemplo, quest3 es una buena opción.

4. Pasos de reproducción

  1. Seleccionar reproductor RTSP: Nuestro enfoque es utilizar el reproductor RTSP|RTMP nativo de Daniu Live SDK en modo de decodificación dura para devolver los datos YUV o RGB decodificados a la unidad. Cabe señalar que debido a la transmisión 8K RTSP|RTMP, la cantidad de datos. Datos muy grandes, especialmente datos decodificados, es necesario reducir las copias lo menos posible si las condiciones lo permiten.

Realización técnica

Este artículo toma como ejemplo el módulo de reproducción Unity3D RTSP|RTMP de la plataforma Android de Daniu Live SDK:

Empieza a jugar:

  1. /*
  2.  * SmartPlayerAndroidMono.cs
  3.  * Author: daniusdk.com
  4.  * QQ：89030985
  5.  */
  6. public void Play()
  7. {
  8. 	if (is_running)
  9. 	{
  10. 		Debug.Log("已经在播放。。");   
  11. 		return;
  12. 	}
  13.  
  14. 	//获取输入框的url
  15. 	string url = input_url_.text.Trim();
  16.  
  17. 	if (!url.StartsWith("rtmp://") && !url.StartsWith("rtsp://"))
  18. 	{
  19. 		videoUrl = "rtsp://admin:[email protected]:554/h264/ch1/main/av_stream";
  20. 	}
  21. 	else
  22. 	{
  23. 		videoUrl = url;
  24. 	}
  25.  
  26. 	OpenPlayer();
  27.  
  28. 	if ( player_handle_ == 0 )
  29. 		return;
  30.  
  31. 	NT_U3D_Set_Game_Object(player_handle_, game_object_);
  32.  
  33. 	/* ++ 播放前参数配置可加在此处 ++ */
  34. 	int is_using_tcp = 0;        //TCP/UDP模式设置
  35. 	NT_U3D_SetRTSPTcpMode(player_handle_, is_using_tcp);
  36.  
  37. 	int is_report = 0;
  38. 	int report_interval = 1;
  39. 	NT_U3D_SetReportDownloadSpeed(player_handle_, is_report, report_interval);  //下载速度回调
  40.  
  41. 	NT_U3D_SetBuffer(player_handle_, play_buffer_time_);                        //设置buffer time
  42.  
  43. 	NT_U3D_SetPlayerLowLatencyMode(player_handle_, is_low_latency_ ? 1 : 0);    //设置是否启用低延迟模式
  44.  
  45. 	NT_U3D_SetMute(player_handle_, is_mute_ ? 1 : 0);                           //是否启动播放的时候静音
  46.  
  47. 	NT_U3D_SetAudioVolume(player_handle_, cur_audio_volume_);                   //设置播放音量
  48.  
  49. 	NT_U3D_SetVideoDecoderMode(player_handle_, is_hw_decode_ ? 1 : 0);          //设置H.264软硬解模式
  50.  
  51. 	NT_U3D_SetVideoHevcDecoderMode(player_handle_, is_hw_decode_ ? 1 : 0);          //设置H.265软硬解模式
  52.  
  53. 	int is_output = 1;
  54. 	int disable_use_image_planes = 0;
  55. 	bool is_supports_texture_format = SystemInfo.SupportsTextureFormat(TextureFormat.RG16);
  56. 	Debug.Log("is_supports_texture_format: " + is_supports_texture_format);
  57. 	int is_supported_multiple_format = is_supports_texture_format? 1:0;
  58. 	int max_images = 3;
  59. 	int buffer_pool_max_size = 0;
  60. 	NT_U3D_SetImageReaderOutput(player_handle_, is_output, disable_use_image_planes, is_supported_multiple_format, max_images, buffer_pool_max_size);  //硬解码image reader
  61.  
  62. 	int is_fast_startup = 1;
  63. 	NT_U3D_SetFastStartup(player_handle_, is_fast_startup);                     //设置快速启动模式
  64.  
  65. 	int rtsp_timeout = 10;
  66. 	NT_U3D_SetRTSPTimeout(player_handle_, rtsp_timeout);                        //设置RTSP超时时间
  67.  
  68. 	int is_auto_switch_tcp_udp = 1;
  69. 	NT_U3D_SetRTSPAutoSwitchTcpUdp(player_handle_, is_auto_switch_tcp_udp);    //设置TCP/UDP模式自动切换
  70.  
  71. 	int is_audiotrack = 1;
  72. 	NT_U3D_SetAudioOutputType(player_handle_, is_audiotrack);                   //设置音频输出模式: if 0: 自动选择; if with 1: audiotrack模式
  73.  
  74. 	NT_U3D_SetUrl(player_handle_, videoUrl);
  75. 	/* -- 播放前参数配置可加在此处 -- */
  76.  
  77. 	int flag = NT_U3D_StartPlay(player_handle_);
  78.  
  79. 	if (flag  == DANIULIVE_RETURN_OK)
  80. 	{
  81. 		is_need_get_frame_ = true;
  82. 		Debug.Log("播放成功");
  83. 	}
  84. 	else
  85. 	{
  86. 		is_need_get_frame_ = false;
  87. 		Debug.LogError("播放失败");
  88. 	}
  89.  
  90. 	is_running = true;  
  91. }

La implementación correspondiente de OpenPlayer() es la siguiente:

  1. private void OpenPlayer()
  2. {
  3. 	if ( java_obj_cur_activity_ == null )
  4. 	{
  5. 		Debug.LogError("getApplicationContext is null");
  6. 		return;
  7. 	}
  8.  
  9. 	player_handle_ = NT_U3D_Open();
  10.  
  11. 	if (player_handle_ != 0)
  12. 		Debug.Log("open success");
  13. 	else
  14. 		Debug.LogError("open fail");
  15. }

Cerrar jugador:

  1. private void ClosePlayer()
  2. {
  3. 	is_need_get_frame_ = false;
  4. 	is_need_init_texture_ = false;
  5.  
  6. 	int flag = NT_U3D_StopPlay(player_handle_);
  7. 	if (flag == DANIULIVE_RETURN_OK)
  8. 	{
  9. 		Debug.Log("停止成功");
  10. 	}
  11. 	else
  12. 	{
  13. 		Debug.LogError("停止失败");
  14. 	}
  15.  
  16. 	flag = NT_U3D_Close(player_handle_);
  17. 	if (flag == DANIULIVE_RETURN_OK)
  18. 	{
  19. 		Debug.Log("关闭成功");
  20. 	}
  21. 	else
  22. 	{
  23. 		Debug.LogError("关闭失败");
  24. 	}
  25.  
  26. 	player_handle_ = 0;
  27.  
  28. 	NT_U3D_UnInit();
  29.  
  30. 	is_running = false;
  31. 	video_format_ = VideoFrame.FORMAT_UNKNOWN;
  32. 	video_width_ = 0;
  33. 	video_height_ = 0;
  34. }

Actualizar datos de actualización:

  1. private void Update()
  2. {
  3. 	if (!is_need_get_frame_)
  4. 		return;
  5.  
  6. 	if (player_handle_ == 0)
  7. 		return;
  8.  
  9. 	AndroidJavaObject u3d_video_frame_obj = NT_U3D_GetVideoFrame(player_handle_);
  10.  
  11. 	if (u3d_video_frame_obj == null)
  12. 	{
  13. 		return;
  14. 	}
  15.  
  16. 	VideoFrame converted_video_frame = ConvertToVideoFrame(u3d_video_frame_obj);
  17.  
  18. 	if (converted_video_frame == null)
  19. 	{
  20. 		u3d_video_frame_obj.Call("release");
  21.  
  22. 	   u3d_video_frame_obj = null;
  23. 	   return;
  24. 	}
  25.  
  26. 	if (!is_need_init_texture_)
  27. 	{
  28. 		if (converted_video_frame.format_ != video_format_)
  29. 		{
  30. 			is_need_init_texture_ = true;
  31.  
  32. 		}
  33. 		else if (converted_video_frame.width_ != video_width_
  34. 			|| converted_video_frame.height_ != video_height_
  35. 			|| converted_video_frame.stride0_ != y_row_bytes_
  36. 			|| converted_video_frame.stride1_ != u_row_bytes_
  37. 			|| converted_video_frame.stride2_ != v_row_bytes_)
  38. 		{
  39. 			is_need_init_texture_ = true;
  40. 		}
  41. 	}
  42.  
  43. 	if (is_need_init_texture_)
  44. 	{
  45. 		if (InitYUVTexture(converted_video_frame))
  46. 		{
  47. 			is_need_init_texture_ = false;
  48. 		}
  49. 	}
  50.  
  51. 	UpdateYUVTexture(converted_video_frame);
  52.  
  53. 	converted_video_frame.java_frame_obj_ = null;
  54. 	converted_video_frame = null;
  55. 	u3d_video_frame_obj.Call("release");
  56. 	u3d_video_frame_obj = null;
  57. }

Resumir

Si un visor de realidad virtual necesita reproducir transmisiones RTSP o RTSP de 8K, tiene requisitos muy altos de hardware y red, por lo que puede encontrar algunos desafíos en las aplicaciones prácticas. A través de pruebas reales, los auriculares quest3, combinados con nuestro reproductor RTSP|RTMP, pueden lograr un retraso de milisegundos en la reproducción de datos de video de 8K en Unity para cumplir con escenarios de uso con requisitos de tiempo real muy altos, como el control de equilibrio. Los desarrolladores interesados ​​pueden discutir esto. conmigo individualmente.

Perfil personal

Se ha dedicado a la investigación de tecnología durante más de 30 años y domina varios lenguajes como java, linux, javascript, php, css, etc. Ha realizado muchas contribuciones en el campo del código abierto. Estación de documentación para desarrolladores para compartir algunos problemas en el desarrollo de tecnología para referencia futura.

Mi información de contacto

Correo