www.pudn.com > vls-0.5.6.rar > streamer.sgml

The Streamer, part of that we called the "consumer thread", takes the
data from the SyncFifo, makes some timing synchro and sends it to the
output.

Refer to  to see the position of
TsStreamer between other parts of vls.



The TsStreamer is declared and implemented in server/tsstreamer.* . The
main purpose of TsStreamer is to deal with timing management, especially
with Program Clock References.




 Program Clock Reference are 33 bits time values, which are in the
adaptation_field of a TS packet header (see 13818-1 specifications).
There are not in each TS packet, the specs say that there should be at
least one PCR every 0.1 second.

The PCR located at a given byte i is the time at which the byte i has to
be processed (sent in the case of a streamer). Obviously, there can not
be a PCR for each byte of a TS stream, so we make a linear calculation
between two PCRs to send the data regularly along the time. So, the
bitrate between two PCR shall be constant.





   
    
  
 
    
  
 
    PCR graph
  




That is why PCR are the core of streaming : they say
when datas have to be sent over the network. In the case of file stored
on and hard disk, this System Layer (TS in our case) provide timing
information. 

That is why, for the moment, it is not possible to stream any file
format. For example, in the case of mpeg4, most files does not contain
streaming time stamps since they don't have a system layer. It would be
possible to re-generate them knowing the frame-rate, and going deeper in
the stream layer to get each frame, remixing the data and sending the at
the right date.





 
First of all, the streamer can (or not) take into account PCRs. This is
specified when instanciating a new TsStreaming : the constructor has a
field bool m_bUsePcr :



  C_TsStreamer(handle hLog, C_Broadcast* pBroadcast,
               C_NetList* pTsProvider, C_SyncFifo* pBuffer,
               C_EventHandler* pEventHandler,
               bool m_bOwnProvider, bool m_bUsePcr);



In the case of a stored stream (file or Dvd), the use of PCR is
essential since we do not have any other timing info. That's why, in
modules/localinput/localinput.cpp, C_TsStreamer is
instantiated with :



C_TsStreamer* pStreamer = new C_TsStreamer(m_hLog, pBroadcast,
                                             pTsProvider, pBuffer,
                                             m_pEventHandler, true, true);



Don't forget that the localinput input deals with Dvd and files, and -
like other input modules - spawns all the streaming chain.



In the case of satellite or live-video encoding, the data comes
at the correct rate (since it is live and supposed to be well
broadcasted...). So the TsStreamer doesn't need to handle the PCRs,
it just transmits the packets as they come. That's why the value
m_bUsePcr is set to false.





We said before that between two PCRs, a streamer should
make a linear interpolation. However, as the streamer does
not contain any buffer, it is not possible to know what the next PCR
will be, so it is impossible to calculate the interpolated date at which
a byte has to be sent.




  
   
   
    
    
  

    Extrapolation
  




Instead, vls uses extrapolation : when the PCR(j) is received, the slope
and offset are updated to correspond to the segment [i,j]. This is done
in modules/server/tsstreamer.cpp :



inline void C_TsStreamer::AdjustClock(C_TsPacket* pPacket)
{
(...)
  m_dSlope = ((double)iPCRTime - m_iLastTime) / (s64)m_uiByteRead;
(...)
  m_iLastTime = iPCRTime;
(...)



Then, when holding the data D, the streamer computes the
linear extrapolation of the sending date Streaming(Data)
using the previous values m_dSlope and
m_iLastTime of segment [i,j] :



inline void C_TsStreamer::WaitSendDate()
{
  s64 iSendDate = m_iLastTime + m_iDeltaClock + (s64)m_dSlope*m_uiByteRead;
  (...)
}



Of course, this method is not exactly accurate, since just before k,
extrapolated_date(k) and PCR(k) do not match : there is a tiny jitter.
However, extrapolation avoids an extra buffer, and the jitter may be
negligible in regards to the amount of data transmited.



At last, one must be aware that PCR are expressed in a 27 MHz clock,
so when mixing PCR and system clock (in seconds or milliseconds),
conversions have to be done.






The main job is made in void C_TsStreamer::DoWork().

First, a packet is taken from the SyncFifo :


C_TsPacket* pPacket = m_pBuffer->Pop();





  
   
  
  

  

    TsStreamer
  




After all the timing calculations described before, each TS packet is sent to the output :

Output->Send(pPacket, (...) );