Transmitting RTP Media Streams

最新推荐文章于 2021-05-20 17:17:40 发布
最新推荐文章于 2021-05-20 17:17:40 发布
阅读量1.2k 收藏
点赞数
文章标签： session null output manager vector audio
 
传输ＲＴＰ媒体流
 
要传输一个ＲＴＰ媒体流，你使用一个Processor生成一个ＲＴＰ解码数据源，然后要末创建一个SessionManager，要末创建一个DataSink来控制传输。
 
输入到Processor不仅能保存，也能实况转播拍摄到的数据。要保存数据，你使用一个MediaLocator在你要创建Processor时确定文件。要得到拍摄到的数据，用一个拍摄数据源作为输入传入Processor，就像在Capturing Media Data中描述的一样。
 
有两种方式可以传输ＲＴＰ流：
 
l 使用一个具有ＲＴＰ session参数的MediaLocator，通过调用Manager.createDataSink创建一个ＲＴＰ　DataSink。
l 使用一个session管理器创建发送流发送内容并控制传输。
 
如果你使用一个MediaLocator创建一个ＲＴＰ DataSink，你可以只传输数据源中的第一个流。如果你想传输session中的多个ＲＴＰ流，或者需要监听session统计表，你需要直接使用SessionManager。
 
不管你选择怎样去传输ＲＴＰ流，你都需要：
 
１．用一个DataSource创建一个Processor去播放你想传输的数据。
２．配置Processor输出ＲＴＰ编码数据。
３．把Processor作为一个DataSource从中得到输出数据。
 
配置Processor
 
要配置Processor产生ＲＴＰ编码数据，你为每个轨迹设置RTP-specific格式，然后指定你要想要的输出内容描述符。
 
通过得到每个轨迹的TrackControl来设置轨迹格式，然后调用setFormat指定一个RTP-specific格式。通过设定格式的编码字符串到一个RTP-specific字符串，比如”AudioFormat.GSM_RTP”,　 选定一个RTP-specific格式。这个Processor试图去加载一个支持这种格式的插件。如果没有安装合适的插件，有可能不支持特殊的ＲＴＰ格式并抛出一个UnSupportFormatException异常。
 
用setOutputContentDescriptor设置输出格式。如果需要专门的多路技术，输出内容描述符能被设置为”ContentDescriptor.RAW”。音频和视频流不应该被交叉存取。如果Processor的轨迹不同于媒体类型，每个媒体流都在一个单独的ＲＴＰ session中被传输。
 
重新得到Processor 输出
 
一旦设置了一个Processor轨迹的格式并且实现了Processor，Processor的输出数据源能够被重新得到。通过调用getDataSource重新得到Processor的输出作为一个DataSource。这个返回的DataSource不仅是一个PushBufferDataSource，也是一个PullBufferDataSource，这取决于数据源。
 
输出DataSource使用createSendStream方法被连接到SessionManager。这个session 管理器必须在你创建发送流之前被初始化。
 
如果DataSource包含多个SourceStreams，每个SourceStream都被作为一个单独的ＲＴＰ流被发送出去，不管是在同一个session还是在一个不同的session中。如果DataSource不仅包含音频流，也包含视频流，那么必须为音频和视频创建单独的ＲＴＰ sessions。你也可以复制DataSource，然后在同一个session或不同的session中，发送复制的输出作为不同的ＲＴＰ流。
 
控制包的延迟
 
包的延迟，也是被熟知的包化的时间间隔，是定期的播放网络中传输的每个ＲＴＰ包。包化的时间间隔定义了最小的点对点的延迟;比较大的包在最上面引入少量报头而不是长时间的延迟并丢失重要信息。为非交互的应用程序比如演讲，或用一些宽带约束的链接，一个更高级的包化的延迟可能是合适的。
 
一个接收包应该接收包，播放音频数据的范围在０到２００毫秒。（因为帧的音频编码，一个接收端通过帧的持续时间收集，应该用２００毫秒来接收包。）这个约束允许接收端的合理的缓冲大小。每个包化的多媒体数字信号编解码器都有适合于它自己编码的一个默认的包时间间隔。
 
如果这个多媒体数字信号编解码器允许修改这个时间间隔，它有一个相应的PacketSizeControl。通过使用setPacketSize方法，包的时间间隔能够被改变或设置。
 
在多个ＲＴＰ包中，为视频流要传输一个单独的视频帧。通过最大化网络的传输单元，每个包的大小都是有限的。这个参数也可以使用包的codec的PacketSizeControl的setPacketSize来设定。
 
用一个数据池来传输ＲＴＰ数据
 
传输一个ＲＴＰ数据最简单的途径是使用Manager.createDataSink方法创建一个ＲＴＰ DataSink。你从Processor中传入输出DataSource和一个MediaLocator，这个MediaLocator描述了ＲＴＰ　session要流化的DataSource。（这个MediaLocator提供了ＲＴＰ　session的地址和端口）。
 
要控制传输，你在DataSink上调用start和stop方法。只有DataSource 中的第一个流被传输。
 
在Example 10-1中，拍摄了实况转播的视频而后使用一个DataSink来传输。
 
 
Example 10-1: Transmitting RTP Data using a DataSink (1 of 2)
         // 首先找到摄像驱动，它将在8bit 8Khz拍摄线性的音频数据
       
          AudioFormat format= new AudioFormat(AudioFormat.LINEAR,
                                              8000,
                                              8,
                                              1);
 
          Vector devices= CaptureDeviceManager.getDeviceList( format);
 
          CaptureDeviceInfo di= null;
 
          if (devices.size() > 0) {
               di = (CaptureDeviceInfo) devices.elementAt( 0);
          }
          else {
              // exit if we could not find the relevant capturedevice.
              System.exit(-1);
          }
        
          // Create a processor for this capturedevice & exit if we
          // cannot create it
          try {
              Processor p = Manager.createProcessor(di.getLocator());
          } catch (IOException e) {
              System.exit(-1);
          } catch (NoProcessorException e) {
              System.exit(-1);
          }
 
         // configure the processor 
         processor.configure();
        
         // block until it has been configured
        
         processor.setContentDescriptor(
             new ContentDescriptor( ContentDescriptor.RAW));
         
         TrackControl track[] = processor.getTrackControls();
        
         boolean encodingOk = false;
        
         // Go through the tracks and try to program one of them to
         // output gsm data.
        
          for (int i = 0; i < track.length; i++) {
              if (!encodingOk && track[i] instanceof FormatControl) { 
                  if (((FormatControl)track[i]).
                      setFormat( new AudioFormat(AudioFormat.GSM_RTP,
                                                 8000,
                                                 8,
                                                 1)) == null) {
 
                     track[i].setEnabled(false);
                  }
                  else {
                      encodingOk = true;
                  }
              } else {
                  // we could not set this track to gsm, so disable it
                  track[i].setEnabled(false);
              }
          }
         
          // At this point, we have determined where we can send out
          // gsm data or not.
          // realize the processor
          if (encodingOk) {
              processor.realize();
              // block until realized.
              // get the output datasource of the processor and exit
              // if we fail
              DataSource ds = null;
             
              try {
                  ds = processor.getDataOutput();
              } catch (NotRealizedError e) {
                  System.exit(-1);
              }
 
              // hand this datasource to manager for creating an RTP
              // datasink our RTP datasimnk will multicast the audio
              try {
                  String url= "rtp://224.144.251.104:49150/audio/1";
 
                  MediaLocator m = new MediaLocator(url);
 
                  DataSink d = Manager.createDataSink(ds, m);
 
                  d.open();
                  d.start();
              } catch (Exception e) {
                  System.exit(-1);
              }    
          }   
 
用Session Manager 来传输ＲＴＰ数据
 
１．创建一个JMF Processor，然后设置每个轨迹的格式到ＲＴＰ指定的格式。
２．从Processor中重新得到输出DataSource。
３．在一个先前创建和初始化的SessionManager上调用createSendStream，传进DataSource和一个流的索引。这个session管理器为指定的SourceStream创建一个SendStream。
４．通过调用SessionManager startSession启动session管理器。
５．通过SendStream方法控制传输。一个SendStreamListener能够被注册为监听SendStream上的事件。
 
创建一个发送流
 
在session管理器传输数据以前，它需要知道从哪里得到要传输的数据。当你构造一个新的SendStream时，从它将得到数据的DataSource来支持SessionManager。因为一个DataSource能包含多个流，你也需要指定这个session中要发送流的索引。通过传递不同的DataSource到createSendStream或通过指定不同的流的索此，你可以创建多个发送流。
 
Session管理器查询SourceStream的格式来确定这个格式中是否有一个已注册的有效载荷。如果数据的格式不是一个RTP格式，或者一个有效载荷类型不能为RTP格式定位，带有适当消息的UnSupportedFormatException将被抛出。使用SessionManager addFormat方法，动态的有效载荷可以被关联到一个RTP格式。
 
使用克隆的数据源
 
很多RTP用法的说明都包括在多个RTP session上发送一个流，或把一个流编码进多个格式然后在多个RTP session上发送他们。当一个已编码进一个单独格式中的流在多个RTP上被发送，从被拍摄的数据中，你需要从Processor中克隆DataSource的输出。通过创建一个克隆的DataSource经由Manager，然后在克隆的DataSource上调用getClone可以做到这一切。一个新的Processor能够通过每个克隆的DataSource创建，它的编码轨道是要求的格式，并且在一个RTP session上发送流。
 
使用合并的数据源
 
如果你想混合多个相同类型的媒体流（比如音频）到一个单独的源的输出流，你必须使用一个RTP混合器。如果这个流是开始从多个DataSource中被混合的，你开始从单独的DataSources创建一个MergingDataSource，然后把它放入SessionManager中创建流。
 
控制一个发送流
 
你使用RTPStream start和stop方法来控制一个SendStream。启动一个SendStream开始数据在网络中的传输，并且停止一个SendStream指示要中止数据的传输。要开始一个RTP传输，每个SendStream都需要被启动。
 
启动或停止一个发送流，在它的DataSource上会触发相应的事件。然而，当SendStream被停止时，如果这个DataSource被独立的启动，通过session管理器，数据将会被删除(PushBufferDataSource)或不pulled（PullBufferDataSource）。在这段时间，没有数据会在网络上被传输。
 
在一个单独的Session 中发送出捕获到的音频
 
例10－2捕获到了一个mono音频数据并在一个RTP session发送出去。
 
Example 10-2: Sending captured audio out on a single session (1 of 3)
          // First, we'll need a DataSource that captures live audio:
        
          AudioFormat format = new AudioFormat(AudioFormat.ULAW,
                                               8000,
                                               8,
                                               1);
   
          Vector devices= CaptureDeviceManager.getDeviceList( format);
 
          CaptureDeviceInfo di= null;
          if (devices.size() > 0) {
               di = (CaptureDeviceInfo) devices.elementAt( 0);
          }
          else {
              // exit if we could not find the relevant capture device.
              System.exit(-1);
          }
          // Create a processor for this capture device & exit if we
          // cannot create it
          try {
              Processor p = Manager.createProcessor(di.getLocator());
          } catch (IOException e) {
              System.exit(-1);
          } catch (NoProcessorException e) {
              System.exit(-1);
          }
 
          // at this point, we have succesfully created the processor.
          // Realize it and block until it is configured.
        
          processor.configure();
        
          // block until it has been configured
        
          processor.setContentDescriptor(
              new ContentDescriptor( ContentDescriptor.RAW));
        
          TrackControl track[] = processor.getTrackControls();
        
         boolean encodingOk = false;
        
          // Go through the tracks and try to program one of them to
          // output ULAW_RTP data.
          for (int i = 0; i < track.length; i++) {
              if (!encodingOk && track[i] instanceof FormatControl) {
 
                  if (((FormatControl)track[i]).
                      setFormat( new AudioFormat(AudioFormat.ULAW_RTP,
                                                 8000,
                                                 8,
                                                 1)) == null) {
 
                      track[i].setEnabled(false);
                  }
                  else {
                      encodingOk = true;
                  }
              }
              else { 
                  // we could not set this track to gsm, so disable it
                  track[i].setEnabled(false);
              }
          }
          // Realize it and block until it is realized.
          processor.realize();   
        
          // block until realized.
          // get the output datasource of the processor and exit
          // if we fail
        
          DataSource ds = null;
        
          try {
              ds = processor.getDataOutput();
          } catch (NotRealizedError e){
              System.exit(-1);
          }
         
          // Create a SessionManager and hand over the 
          // datasource for SendStream creation.
        
          SessionManager rtpsm = new com.sun.media.rtp.RTPSessionMgr();
         
          // The session manager then needs to be initialized and started:
          // rtpsm.initSession(...);
          // rtpsm.startSession(...);
 
          try {
              rtpsm.createSendStream(ds, 0);
          } catch (IOException e)      {
              e.printStackTrace();
          } catch( UnsupportedFormatException e) {
              e.printStackTrace();
          }
 
 
例10－3和例10－4都编码了捕获的音频并且在多个RTP sessions中发送了出去。在例10－3中，数据被编码为gsm ;在例10－4中，数据被编码为一些不同的格式。
 
Example 10-3: Sending RTP data out in multiple sessions (1 of 4)
          // First find a capture device that will capture linear audio
          // data at 8bit 8Khz
        
          AudioFormat format= new AudioFormat(AudioFormat.LINEAR,
                                              8000,
                                              8,
                                              1);
          Vector devices= CaptureDeviceManager.getDeviceList( format);
 
          CaptureDeviceInfo di= null;
 
          if (devices.size() > 0) {
               di = (CaptureDeviceInfo) devices.elementAt( 0);
          }
          else {
              // exit if we could not find the relevant capturedevice.
              System.exit(-1);
          }
         
          // Now create a processor for this capturedevice & exit if we
          // cannot create it
          try {
              Processor p = Manager.createProcessor(di.getLocator());
          } catch (IOException e) {
              System.exit(-1);
          } catch (NoProcessorException e) {
              System.exit(-1);
          }
        
          // configure the processor
          processor.configure();
        
          // block until it has been configured
        
          processor.setContentDescriptor(
              new ContentDescriptor( ContentDescriptor.RAW));
        
          TrackControl track[] = processor.getTrackControls();
        
          boolean encodingOk = false;
        
          // Go through the tracks and try to program one of them to
          // output gsm data.
        
          for (int i = 0; i < track.length; i++) {
              if (!encodingOk && track[i] instanceof FormatControl) {
 
                  if (((FormatControl)track[i]).
                      setFormat( new AudioFormat(AudioFormat.GSM_RTP,
                                                 8000,
                                                 8,
                                                 1)) == null) {
 
                      track[i].setEnabled(false);
                  }
                  else {
                      encodingOk = true;
                  }
              } 
              else {
                  // we could not set this track to gsm, so disable it
                  track[i].setEnabled(false);
              }
          }
        
          // At this point, we have determined where we can send out
          // gsm data or not.
          // realize the processor
        
          if (encodingOk) {
              processor.realize();
        
              // block until realized.
        
              // get the output datasource of the processor and exit
              // if we fail
        
              DataSource origDataSource = null;
        
              try {
                  origDataSource = processor.getDataOutput();
              } catch (NotRealizedError e) {
                  System.exit(-1);
              }
        
              // We want to send the stream of this datasource over two
              // RTP sessions.
        
              // So we need to clone the output datasource of the 
              // processor and hand the clone over to the second
              // SessionManager
        
              DataSource cloneableDataSource = null;
              DataSource clonedDataSource = null;
        
              cloneableDataSource
                = Manager.createCloneableDataSource(origDataSource);
 
              clonedDataSource
                = ((SourceCloneable)cloneableDataSource).createClone();
        
              // Now create the first SessionManager and hand over the
              // first datasource for SendStream creation.
        
              SessionManager rtpsm1
                = new com.sun.media.rtp.RTPSessionMgr(); 
 
              // The session manager then needs to be
              // initialized and started:
              // rtpsm1.initSession(...);
              // rtpsm1.startSession(...);
              try {
                  rtpsm1.createSendStream(cloneableDataSource, // Datasource 1
                                      0);     
                                                  
              } catch (IOException e) {
                  e.printStackTrace();
             } catch( UnsupportedFormatException e) {
                  e.printStackTrace();
              }
 
              try {
                  cloneableDataSource.connect();
                  cloneableDataSource.start();
              } catch (IOException e) {
                  e.printStackTrace();
              }
        
              // create the second RTPSessionMgr and hand over the
              // cloned datasource
              if (clonedDataSource != null) {
                  SessionManager rtpsm2
                    = new com.sun.media.rtp.RTPSessionMgr();
 
                  // rtpsm2.initSession(...);
                  // rtpsm2.startSession(...);
 
                  try {
                      rtpsm2.createSendStream(clonedDataSource,0);
                  } catch (IOException e) {
                      e.printStackTrace();
                  } catch( UnsupportedFormatException e) {
                      e.printStackTrace();
                  }
              }
          }
          else {
              // we failed to set the encoding to gsm. So deallocate
              // and close the processor before we leave.
        
              processor.deallocate();
              processor.close();
          }
 
例10－4编码捕获的音频为一些格式，然后在多个RTP sessions中将它发送出去。它假定在输入DataSource中有一个流。
 
输入DataSource被克隆并且另一个processor被从这个克隆中创建。两个 Processors中的轨迹都单独的设置gsm和dvi，并且输出DataSources被发送到两个不同的RTP session管理器。如果轨道的数量多于１，这个例子试图设置一个轨道的编码为gsm而另一个为dvi。同一个DataSource被交给两个单独的ＲＴＰsession管理器，第一个流的索引设为０而第二个索引设为１（为了不同种类的接收器）。
 
Example 10-4: Encoding and sending data in multiple formats (1 of 3)
          // Find a capture device that will capture linear 8bit 8Khz
          // audio
 
          AudioFormat format = new AudioFormat(AudioFormat.LINEAR,
                                               8000,
                                               8,
                                               1);
   
          Vector devices= CaptureDeviceManager.getDeviceList( format);
 
          CaptureDeviceInfo di= null;
 
          if (devices.size() > 0) {
               di = (CaptureDeviceInfo) devices.elementAt( 0);
          }
          else {
              // exit if we could not find the relevant capture device.
              System.exit(-1);
          }
   
          // Since we have located a capturedevice, create a data
          // source for it.
 
          DataSource origDataSource= null;
 
          try {
              origDataSource = Manager.createDataSource(di.getLocator());
          } catch (IOException e) {
              System.exit(-1);
          } catch (NoDataSourceException e) {
             System.exit(-1);
          }
          
          SourceStream streams[] = ((PushDataSource)origDataSource)
                                     .getStreams();
        
          DataSource cloneableDataSource = null;
          DataSource clonedDataSource = null;
 
          if (streams.length == 1) {
              cloneableDataSource
                = Manager.createCloneableDataSource(origDataSource);  
              clonedDataSource
                = ((SourceCloneable)cloneableDataSource).createClone();
          }
          else {
              // DataSource has more than 1 stream and we should try to
              // set the encodings of these streams to dvi and gsm
          }
        
          // at this point, we have a cloneable data source and its clone,
          // Create one processor from each of these datasources.
        
         Processor p1 = null;
 
          try {
              p1 = Manager.createProcessor(cloneableDataSource);
          } catch (IOException e) {
              System.exit(-1);
         } catch (NoProcessorException e) {
              System.exit(-1);
          }
        
          p1.configure();
        
          // block until configured.
 
          TrackControl track[] = p1.getTrackControls();
          boolean encodingOk = false;
        
          // Go through the tracks and try to program one of them
          // to output gsm data
          for (int i = 0; i < track.length; i++) {
              if (!encodingOk && track[i] instanceof FormatControl) {
                  if (((FormatControl)track[i]).
                      setFormat( new AudioFormat(AudioFormat.GSM_RTP,
                                                 8000,
                                                 8,
                                                 1)) == null) {
 
                      track[i].setEnabled(false);
                  }
                  else {
                      encodingOk = true;
                  }
              }
              else {
                  track[i].setEnabled(false);
              }
          }
          if (encodingOk) {
              processor.realize();
              // block until realized.
              // ...
              // get the output datasource of the processor
              DataSource ds = null;
 
              try {
                  ds = processor.getDataOutput();
              } catch (NotRealizedError e) {
                  System.exit(-1);
              }
            
              // Now create the first SessionManager and hand over the
              // first datasource for SendStream creation .
        
              SessionManager rtpsm1
                = new com.sun.media.rtp.RTPSessionMgr();
 
              // rtpsm1.initSession(...);
              // rtpsm1.startSession(...);
 
              try {
                  rtpsm1.createSendStream(ds, // first datasource
                                          0); // first sourcestream of
                                              // first datasource
              } catch (IOException e) {
                  e.printStackTrace();
              } catch( UnsupportedFormatException e) {
                  e.printStackTrace();
              }
          }
        
          // Now repeat the above with the cloned data source and
          // set the encoding to dvi. i.e create a processor with
          // inputdatasource clonedDataSource
          // and set encoding of one of its tracks to dvi.
          // create SessionManager giving it the output datasource of
          // this processor. 
 
用RTPSocket 传输ＲＴＰ流
 
你也可以使用RTPSocket来传输ＲＴＰ媒体流。要使用RTPSocket来传输，要用createDataSink通过传入一个MediaLocator来创建一个ＲＴＰ DataSink，这个MediaLocator用一种ＲＴＰ变量的新端口，”Ratibor”。管理器试图创建一个DataSink，从：
 
<protocol package-prefix>.media.datasink.rtpraw.Handler
 
这个管理器预备单独的正要在网络中传输的单独的包，然后发送他们到创建的RTPSocket，从：
<protocol package-prefix>.media.protocol.rtpraw.DataSource
 
这个在<protocol package-prefix>.media.protocol.rtpraw.DataSource上创建的RTPSocket是你自己实现的RTPSocket。ＪＭＦ　ＡＰＩ没有定义一个默认的RTPSocket的实现。RTPSocket的实现依赖于你正使用的底层传输协议。你的RTPSocket必须位于<protocol package-prefix>.media.protocol.rtpraw.DataSource。
 
你有责任在底层网络上传输ＲＴＰ包。
 
在以下的例子中，一个RTPSocket被用于传输捕获到的音频：
 
Example 10-5: Transmitting RTP data with RTPSocket (1 of 3)
          // Find a capture device that will capture linear audio
          // data at 8bit 8Khz
         
          AudioFormat format = new AudioFormat(AudioFormat.LINEAR,
                                               8000,
                                               8,
                                               1);
   
          Vector devices= CaptureDeviceManager.getDeviceList( format);
 
          CaptureDeviceInfo di= null;
          if (devices.size() > 0) {
               di = (CaptureDeviceInfo) devices.elementAt( 0);
          }
          else {
              // exit if we could not find the relevant capture device.
              System.exit(-1);
          }
 
          // Create a processor for this capturedevice & exit if we
          // cannot create it
         
          try {
              processor = Manager.createProcessor(di.getLocator());
          } catch (IOException e) {
              System.exit(-1);
          } catch (NoProcessorException e) {
              System.exit(-1);
          } 
          // configure the processor 
          processor.configure();
        
          // block until it has been configured
        
          processor.setContentDescriptor(
              new ContentDescriptor( ContentDescriptor.RAW));
        
          TrackControl track[] = processor.getTrackControls();
          boolean encodingOk = false;
        
          // Go through the tracks and try to program one of them to
          // output gsm data.
          for (int i = 0; i < track.length; i++) {
              if (!encodingOk && track[i] instanceof FormatControl) {
 
                  if (((FormatControl)track[i]).
                      setFormat( new AudioFormat(AudioFormat.GSM_RTP,
                                                 8000,
                                                 8,
                                                 1)) == null) {
 
                      track[i].setEnabled(false);
                  }
                  else {
                      encodingOk = true;
                  }
              }
              else {
                  // we could not set this track to gsm, so disable it
                  track[i].setEnabled(false);
              }
          }
         
          // At this point, we have determined where we can send out
          // gsm data or not.
          // realize the processor
          if (encodingOk) {
              processor.realize();
              // block until realized.
              // get the output datasource of the processor and exit
              // if we fail
              DataSource ds = null;
              try {
                  ds = processor.getDataOutput();
              } catch (NotRealizedError e) {
                  System.exit(-1);
              }
 
              // hand this datasource to manager for creating an RTP
              // datasink
              // our RTP datasimnk will multicast the audio
              try {
                  MediaLocator m = new MediaLocator("rtpraw://");
                  // here, manager will look for a datasink in
                  // <protocol.prefix>.media.protocol.rtpraw.DataSink
                  // the datasink will create an RTPSocket at
                  // <protocol.prefix>.media.protocol.rtpraw.DataSource
                  // and sink all RTP data to this socket.
                
                  DataSink d = Manager.createDataSink(ds, m);
        
                  d.open();
                  d.start();
              } catch (Exception e) {
                  System.exit(-1);
              }  
          }   
 
river98710
关注
rfc3550 RTP协议中文版本
04-18
6 3 7 传输一个 BYE 包（Transmitting a BYE Packet） 6 3 8 更新we_sent（Updating we_sent） 6 3 9 分配源描述带宽（Allocation of Source Description Bandwidth） 6 4 发送方和接收方报告（Sender and ...
RTP、RTSP和ES、PES、PS以及TS码流的区别
学无止尽，谨言慎行！
07-29 1万+
ES、PES、PS以及TS区别 基本概念 ES ES–Elementary Streams (原始流)是直接从编码器出来的数据流，可以是编码过的视频数据流(H.264,MJPEG等)，音频数据流（AAC），或其他编码数据流的统称。ES流经过PES打包器之后，被转换成PES包。 ES是只包含一种内容的数据流，如只含视频或只含音频等，打包之后的PES也是只含一种性质的ES,如只含视频ES的PES,...
使用wireshark解析RTP包中的音频流
halazi100
06-04 9890
使用wireshark解析RTP包中的音频流 当使用RTP协议传输音频，但是具体的载荷类型payload type是自定义的payload时可以使用以下方法进行解析； 使用wireshark对RTP报文进行解析 拿到抓包文件后使用wireshark打开 并使用合适的过滤条件进行过滤 然后选中其中一个数据包，右键选择[解码为…(Decode As…)] 选择RTP并点击OK 此时wireshark界面可以看到已经将对应的报文作为RTP协议解析； 然后选择【电话】-【RTP...
webrtc JetterBuffer 笔记-音视频同步RtpStreamsSynchronizer
weixin_39364897的博客
05-20 335
1.参考笔记 <<webrtc代码走读十六（Jitter延时的计算）>> <<webrtc QOS方法八（JitterBuffer）>> <<WebRTC视频JitterBuffer详解>> 代码版本M79 2.RtpStreamsSynchronizer
RTP的使用（发送端）
Mr_Pang的专栏
05-17 838
一.创建处理器 1.确认MediaPlayer对象是否为空 2.不为空的话则为定义的MediaPlayer定位并实例化一个适当的数据源  Maneger.createDataSource（medialocator） 3.使用数据源来构造Processor对象  Manager.createProcessor（DataSource） 4.为Processor对象添加监听器  Processo
为什么要使用RTP
weixin_33919941的博客
12-23 199
一提到流媒体传输、一谈到什么视频监控、视频会议、语音电话（VOIP），都离不开RTP协议的应用，但当大家都根据经验或者别人的应用而选择RTP协议的时候，你可曾想过，为什么我们要使用RTP来进行流媒体的传输呢？为什么我们一定要用RTP？难道TCP、UDP或者其他的网络协议不能达到我们的要求么？本文就是根据我在RTP协议的学习和应用过程中整理出来的思考，希望对大家有所启发，同时，也欢迎大家留言探讨，提...
rfc3550 rtp协议 中文版本
07-22
6 3 7 传输一个 BYE 包（Transmitting a BYE Packet） 6 3 8 更新we_sent（Updating we_sent） 6 3 9 分配源描述带宽（Allocation of Source Description Bandwidth） 6 4 发送方和接收方报告（Sender and ...
RFC3550_RTP：实时应用程序传输协议
11-04
6 3 7 传输一个 BYE 包（Transmitting a BYE Packet） 6 3 8 更新we_sent（Updating we_sent） 6 3 9 分配源描述带宽（Allocation of Source Description Bandwidth） 6 4 发送方和接收方报告（Sender and ...
The capacity of transmitting atomic qubit with light
02-21
The quantum information transfer between a single photon and a two-level atom is considered as a part of a quantum channel. The channel is a degradable channel even when there are decays of the atomic...
Transmitting Matter by Using Space-Varying Probability
02-20
文章标题《使用空间可变几率传输物质》及内容摘要提出了一种创新的传输物质的方法，即使用空间可变几率传输物质。该理念的提出基于宏观物质和微观物质性质的差异。文章作者黄永义来自西安交通大学光学信息科学与技术...
如何发送和接收RTP封包的H264，用FFmpeg解码
爱写代码的自由人
01-16 1万+
这篇文章给大家介绍怎么打包H264分片到RTP包，并且实现一个播放程序演示接收RTP包和用FFmpeg解码。为了让大家更了解H264打包成RTP的细节，有必要罗嗦一下向大家介绍一些相关的基础知识，下面分三节介绍，其中前面两节是基础知识，第三节重点讲解怎么实现RTP包的发送和接收，以及怎么用FFmpeg解码显示。 一、H264的组成结构 H264以NALU（NALunit）为单位来支持编码数据在...
RTP协议全解析（H264码流和PS流）
热门推荐
对牛乱弹琴
09-12 26万+
1RTP Header解析 2、RTP荷载H264码流 2.1、单个NAL单元包 2.2、分片单元（FU-A） 3、RTP荷载PS流 3.1、PS包头 3.2、系统标题 3.3、节目映射流 3.4、PES分组头部
RTP数据分析
blade2001的专栏
06-03 2966
How to decode and playback G729 audio streams: http://wiki.media5corp.com/wiki/index.php?title=Debug_%26_Troubleshooting_-_How_to_decode_and_playback_G729_audio_streams 使用wildpackets omnipee
WireShark 分析RTP丢包率
hebbely的博客
01-13 4万+
1、启动WireShark 打开WireShark，启动本地连接，在显示过滤框"Filter"输入“ip.addr eq 192.168.21.175”,然后单击“Apply”; 2、查找rtsp/1.0 Packet 1> Ctrl+f打开Find Packet对话框，选择“String” 单选框，在“Filter”右侧输入“rtsp/1
wireshark分析rtp
fishmai的专栏
12-15 7036
wireshark一些经典文档收录如下[@more@] 1 http://wiki.wireshark.org/RTP_statistics 用wireshark分析rtp流的统计信息 2 http://www.linuxjournal.com/article/9398 用wireshark分析voip rtp流，特别是关于统计丢包率，带宽，时延的方面很有价值 3 h
java版本的RtpStream
柳鲲鹏
04-29 1528
　　今天在家里的机器上，打开Eclipse，类删除也不编译出错，不知道哪里的问题。以后有机会，把这些代码编译后放出来。当初也是从网上搜索到了，略微整理而已。 package com.newayte.rtp.clinet; import android.os.HandlerThread; import android.os.Handler; import com.newayte.toolki...
基于Matlab面板版的卡尔曼小球运动跟踪[Matlab面板版].zip
最新发布
10-16
大模型实战教程
Day01(1).py
10-16
Day01(1).py
"RFC-5404: G.719 RTP Payload Format
Additionally, it outlines the requirements for synchronization, timestamping, and header compression to support the real-time nature of the audio streams. Furthermore, RFC-5404 addresses the ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值