/// <summary>
   /// RTP(RFC3550)協(xié)議數(shù)據(jù)包
   /// </summary>
   /// <remarks>
   /// The RTP header has the following format:
   ///  0                   1                   2                   3
   ///  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
   /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   /// |V=2|P|X| CC    |M| PT          | sequence number               |
   /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   /// | timestamp                                                     |
   /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   /// | synchronization source (SSRC) identifier                      |
   /// +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
   /// | contributing source (CSRC) identifiers                        |
   /// | ....                                                          |
   /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   /// </remarks>
   public class RtpPacket
   {
     /// <summary>
     /// version (V): 2 bits
     /// RTP版本標識，當前規(guī)范定義值為2.
     /// This field identifies the version of RTP. The version defined by this specification is two (2).
     /// (The value 1 is used by the first draft version of RTP and the value 0 is used by the protocol
     /// initially implemented in the \vat" audio tool.)
     /// </summary>
     public int Version { get { return 2; } }

     /// <summary>
     /// padding (P)：1 bit
     /// 如果設(shè)定padding，在報文的末端就會包含一個或者多個padding 字節(jié)，這不屬于payload。
     /// 最后一個字節(jié)的padding 有一個計數(shù)器，標識需要忽略多少個padding 字節(jié)(包括自己)。
     /// 一些加密算法可能需要固定塊長度的padding，或者是為了在更低層數(shù)據(jù)單元中攜帶一些RTP 報文。
     /// If the padding bit is set, the packet contains one or more additional padding octets at the
     /// end which are not part of the payload. The last octet of the padding contains a count of
     /// how many padding octets should be ignored, including itself. Padding may be needed by
     /// some encryption algorithms with fixed block sizes or for carrying several RTP packets in a
     /// lower-layer protocol data unit.
     /// </summary>
     public int Padding { get { return 0; } }

     /// <summary>
     /// extension (X)：1 bit
     /// 如果設(shè)定了extension 位，定長頭字段后面會有一個頭擴展。
     /// If the extension bit is set, the fixed header must be followed by exactly one header extensio.
     /// </summary>
     public int Extension { get { return 0; } }

     /// <summary>
     /// CSRC count (CC)：4 bits
     /// CSRC count 標識了定長頭字段中包含的CSRC identifier 的數(shù)量。
     /// The CSRC count contains the number of CSRC identifiers that follow the fixed header.
     /// </summary>
     public int CC { get { return 0; } }

     /// <summary>
     /// marker (M)：1 bit
     /// marker 是由一個profile 定義的。用來允許標識在像報文流中界定幀界等的事件。
     /// 一個profile 可能定義了附加的標識位或者通過修改payload type 域中的位數(shù)量來指定沒有標識位.
     /// The interpretation of the marker is defined by a profile. It is intended to allow significant
     /// events such as frame boundaries to be marked in the packet stream. A profile may define
     /// additional marker bits or specify that there is no marker bit by changing the number of bits
     /// in the payload type field.
     /// </summary>
     public int Marker { get { return 0; } }

     /// <summary>
     /// payload type (PT)：7 bits
     /// 這個字段定一個RTPpayload 的格式和在應(yīng)用中定義解釋。
     /// profile 可能指定一個從payload type 碼字到payload format 的默認靜態(tài)映射。
     /// 也可以通過non-RTP 方法來定義附加的payload type 碼字(見第3 章)。
     /// 在 RFC 3551[1]中定義了一系列的默認音視頻映射。
     /// 一個RTP 源有可能在會話中改變payload type，但是這個域在復(fù)用獨立的媒體時是不同的。(見5.2 節(jié))。
     /// 接收者必須忽略它不識別的payload type。
     /// This field identifies the format of the RTP payload and determines its interpretation by the
     /// application. A profile may specify a default static mapping of payload type codes to payload
     /// formats. Additional payload type codes may be defined dynamically through non-RTP means
     /// (see Section 3). A set of default mappings for audio and video is specified in the companion
     /// RFC 3551 [1]. An RTP source may change the payload type during a session, but this field
     /// should not be used for multiplexing separate media streams (see Section 5.2).
     /// A receiver must ignore packets with payload types that it does not understand.
     /// </summary>
     public RtpPayloadType PayloadType { get; private set; }

     /// <summary>
     /// sequence number：16 bits
     /// 每發(fā)送一個RTP 數(shù)據(jù)報文序列號值加一，接收者也可用來檢測丟失的包或者重建報文序列。
     /// 初始的值是隨機的，這樣就使得known-plaintext 攻擊更加困難， 即使源并沒有加密(見9。1)，
     /// 因為要通過的translator 會做這些事情。關(guān)于選擇隨機數(shù)方面的技術(shù)見[17]。
     /// The sequence number increments by one for each RTP data packet sent, and may be used
     /// by the receiver to detect packet loss and to restore packet sequence. The initial value of the
     /// sequence number should be random (unpredictable) to make known-plaintext attacks on
     /// encryption more dificult, even if the source itself does not encrypt according to the method
     /// in Section 9.1, because the packets may flow through a translator that does. Techniques for
     /// choosing unpredictable numbers are discussed in [17].
     /// </summary>
     public int SequenceNumber { get; private set; }

     /// <summary>
     /// timestamp：32 bits
     /// timestamp 反映的是RTP 數(shù)據(jù)報文中的第一個字段的采樣時刻的時間瞬時值。
     /// 采樣時間值必須是從恒定的和線性的時間中得到以便于同步和jitter 計算(見第6.4.1 節(jié))。
     /// 必須保證同步和測量保溫jitter 到來所需要的時間精度(一幀一個tick 一般情況下是不夠的)。
     /// 時鐘頻率是與payload 所攜帶的數(shù)據(jù)格式有關(guān)的，在profile 中靜態(tài)的定義或是在定義格式的payload format 中，
     /// 或通過non-RTP 方法所定義的payload format 中動態(tài)的定義。如果RTP 報文周期的生成，就采用虛擬的(nominal)
     /// 采樣時鐘而不是從系統(tǒng)時鐘讀數(shù)。例如，在固定比特率的音頻中，timestamp 時鐘會在每個采樣周期時加一。
     /// 如果音頻應(yīng)用中從輸入設(shè)備中讀入160 個采樣周期的塊，the timestamp 就會每一塊增加160，
     /// 而不管塊是否傳輸了或是丟棄了。
     /// 對于序列號來說，timestamp 初始值是隨機的。只要它們是同時(邏輯上)同時生成的，
     /// 這些連續(xù)的的 RTP 報文就會有相同的timestamp，
     /// 例如，同屬一個視頻幀。正像在MPEG 中內(nèi)插視頻幀一樣，
     /// 連續(xù)的但不是按順序發(fā)送的RTP 報文可能含有相同的timestamp。
     /// The timestamp reflects the sampling instant of the first octet in the RTP data packet. The
     /// sampling instant must be derived from a clock that increments monotonically and linearly
     /// in time to allow synchronization and jitter calculations (see Section 6.4.1). The resolution
     /// of the clock must be suficient for the desired synchronization accuracy and for measuring
     /// packet arrival jitter (one tick per video frame is typically not suficient). The clock frequency
     /// is dependent on the format of data carried as payload and is specified statically in the profile
     /// or payload format specification that defines the format, or may be specified dynamically for
     /// payload formats defined through non-RTP means. If RTP packets are generated periodically,
     /// the nominal sampling instant as determined from the sampling clock is to be used, not a
     /// reading of the system clock. As an example, for fixed-rate audio the timestamp clock would
     /// likely increment by one for each sampling period. If an audio application reads blocks covering
     /// 160 sampling periods from the input device, the timestamp would be increased by 160 for
     /// each such block, regardless of whether the block is transmitted in a packet or dropped as silent.
     /// </summary>
     public long Timestamp { get; private set; }

     /// <summary>
     /// SSRC：32 bits
     /// SSRC 域識別同步源。為了防止在一個會話中有相同的同步源有相同的SSRC identifier，
     /// 這個identifier 必須隨機選取。
     /// 生成隨機 identifier 的算法見目錄A.6 。雖然選擇相同的identifier 概率很小，
     /// 但是所有的RTP implementation 必須檢測和解決沖突。
     /// 第8 章描述了沖突的概率和解決機制和RTP 級的檢測機制，根據(jù)唯一的 SSRCidentifier 前向循環(huán)。
     /// 如果有源改變了它的源傳輸?shù)刂罚?BR>     /// 就必須為它選擇一個新的SSRCidentifier 來避免被識別為循環(huán)過的源(見第8.2 節(jié))。
     /// The SSRC field identifies the synchronization source. This identifier should be chosen
     /// randomly, with the intent that no two synchronization sources within the same RTP session
     /// will have the same SSRC identifier. An example algorithm for generating a random identifier
     /// is presented in Appendix A.6. Although the probability of multiple sources choosing the same
     /// identifier is low, all RTP implementations must be prepared to detect and resolve collisions.
     /// Section 8 describes the probability of collision along with a mechanism for resolving collisions
     /// and detecting RTP-level forwarding loops based on the uniqueness of the SSRC identifier. If
     /// a source changes its source transport address, it must also choose a new SSRC identifier to
     /// avoid being interpreted as a looped source (see Section 8.2).
     /// </summary>
     public int SSRC { get { return 0; } }

     /// <summary>
     /// 每一個RTP包中都有前12個字節(jié)定長的頭字段
     /// The first twelve octets are present in every RTP packet
     /// </summary>
     public const int HeaderSize = 12;
     /// <summary>
     /// RTP消息頭
     /// </summary>
     private byte[] _header;
     /// <summary>
     /// RTP消息頭
     /// </summary>
     public byte[] Header { get { return _header; } }

     /// <summary>
     /// RTP有效載荷長度
     /// </summary>
     private int _payloadSize;
     /// <summary>
     /// RTP有效載荷長度
     /// </summary>
     public int PayloadSize { get { return _payloadSize; } }

     /// <summary>
     /// RTP有效載荷
     /// </summary>
     private byte[] _payload;
     /// <summary>
     /// RTP有效載荷
     /// </summary>
     public byte[] Payload { get { return _payload; } }

     /// <summary>
     /// RTP消息總長度，包括Header和Payload
     /// </summary>
     public int Length { get { return HeaderSize + PayloadSize; } }

     /// <summary>
     /// RTP(RFC3550)協(xié)議數(shù)據(jù)包
     /// </summary>
     /// <param name="playloadType">數(shù)據(jù)報文有效載荷類型</param>
     /// <param name="sequenceNumber">數(shù)據(jù)報文序列號值</param>
     /// <param name="timestamp">數(shù)據(jù)報文采樣時刻</param>
     /// <param name="data">數(shù)據(jù)</param>
     /// <param name="dataSize">數(shù)據(jù)長度</param>
     public RtpPacket(
       RtpPayloadType playloadType,
       int sequenceNumber,
       long timestamp,
       byte[] data,
       int dataSize)
     {
       // fill changing header fields
       SequenceNumber = sequenceNumber;
       Timestamp = timestamp;
       PayloadType = playloadType;

       // build the header bistream
       _header = new byte[HeaderSize];

       // fill the header array of byte with RTP header fields
       _header[0] = (byte)((Version << 6) | (Padding << 5) | (Extension << 4) | CC);
       _header[1] = (byte)((Marker << 7) | (int)PayloadType);
       _header[2] = (byte)(SequenceNumber >> 8);
       _header[3] = (byte)(SequenceNumber);
       for (int i = 0; i < 4; i++)
       {
         _header[7 - i] = (byte)(Timestamp >> (8 * i));
       }
       for (int i = 0; i < 4; i++)
       {
         _header[11 - i] = (byte)(SSRC >> (8 * i));
       }

       // fill the payload bitstream
       _payload = new byte[dataSize];
       _payloadSize = dataSize;

       // fill payload array of byte from data (given in parameter of the constructor)
       Array.Copy(data, 0, _payload, 0, dataSize);
     }

     /// <summary>
     /// RTP(RFC3550)協(xié)議數(shù)據(jù)包
     /// </summary>
     /// <param name="playloadType">數(shù)據(jù)報文有效載荷類型</param>
     /// <param name="sequenceNumber">數(shù)據(jù)報文序列號值</param>
     /// <param name="timestamp">數(shù)據(jù)報文采樣時刻</param>
     /// <param name="frame">圖片</param>
     public RtpPacket(
       RtpPayloadType playloadType,
       int sequenceNumber,
       long timestamp,
       Image frame)
     {
       // fill changing header fields
       SequenceNumber = sequenceNumber;
       Timestamp = timestamp;
       PayloadType = playloadType;

       // build the header bistream
       _header = new byte[HeaderSize];

       // fill the header array of byte with RTP header fields
       _header[0] = (byte)((Version << 6) | (Padding << 5) | (Extension << 4) | CC);
       _header[1] = (byte)((Marker << 7) | (int)PayloadType);
       _header[2] = (byte)(SequenceNumber >> 8);
       _header[3] = (byte)(SequenceNumber);
       for (int i = 0; i < 4; i++)
       {
         _header[7 - i] = (byte)(Timestamp >> (8 * i));
       }
       for (int i = 0; i < 4; i++)
       {
         _header[11 - i] = (byte)(SSRC >> (8 * i));
       }

       // fill the payload bitstream
       using (MemoryStream ms = new MemoryStream())
       {
         frame.Save(ms, ImageFormat.Jpeg);
         _payload = ms.ToArray();
         _payloadSize = _payload.Length;
       }
     }

     /// <summary>
     /// RTP(RFC3550)協(xié)議數(shù)據(jù)包
     /// </summary>
     /// <param name="packet">數(shù)據(jù)包</param>
     /// <param name="packetSize">數(shù)據(jù)包長度</param>
     public RtpPacket(byte[] packet, int packetSize)
     {
       //check if total packet size is lower than the header size
       if (packetSize >= HeaderSize)
       {
         //get the header bitsream
         _header = new byte[HeaderSize];
         for (int i = 0; i < HeaderSize; i++)
         {
           _header[i] = packet[i];
         }

         //get the payload bitstream
         _payloadSize = packetSize - HeaderSize;
         _payload = new byte[_payloadSize];
         for (int i = HeaderSize; i < packetSize; i++)
         {
           _payload[i - HeaderSize] = packet[i];
         }

         //interpret the changing fields of the header
         PayloadType = (RtpPayloadType)(_header[1] & 127);
         SequenceNumber = UnsignedInt(_header[3]) + 256 * UnsignedInt(_header[2]);
         Timestamp = UnsignedInt(_header[7])
           + 256 * UnsignedInt(_header[6])
           + 65536 * UnsignedInt(_header[5])
           + 16777216 * UnsignedInt(_header[4]);
       }
     }

     /// <summary>
     /// 將消息轉(zhuǎn)換成byte數(shù)組
     /// </summary>
     /// <returns>消息byte數(shù)組</returns>
     public byte[] ToArray()
     {
       byte[] packet = new byte[Length];

       Array.Copy(_header, 0, packet, 0, HeaderSize);
       Array.Copy(_payload, 0, packet, HeaderSize, PayloadSize);

       return packet;
     }

     /// <summary>
     /// 將消息體轉(zhuǎn)換成圖片
     /// </summary>
     /// <returns>圖片</returns>
     public Bitmap ToBitmap()
     {
       return new Bitmap(new MemoryStream(_payload));
     }

     /// <summary>
     /// 將消息體轉(zhuǎn)換成圖片
     /// </summary>
     /// <returns>圖片</returns>
     public Image ToImage()
     {
       return Image.FromStream(new MemoryStream(_payload));
     }

     /// <summary>
     /// 將圖片轉(zhuǎn)換成消息
     /// </summary>
     /// <param name="playloadType">數(shù)據(jù)報文有效載荷類型</param>
     /// <param name="sequenceNumber">數(shù)據(jù)報文序列號值</param>
     /// <param name="timestamp">數(shù)據(jù)報文采樣時刻</param>
     /// <param name="frame">圖片幀</param>
     /// <returns>
     /// RTP消息
     /// </returns>
     public static RtpPacket FromImage(
       RtpPayloadType playloadType,
       int sequenceNumber,
       long timestamp,
       Image frame)
     {
       return new RtpPacket(playloadType, sequenceNumber, timestamp, frame);
     }

     /// <summary>
     /// return the unsigned value of 8-bit integer nb
     /// </summary>
     /// <param name="nb"></param>
     /// <returns></returns>
     private static int UnsignedInt(int nb)
     {
       if (nb >= 0)
         return (nb);
       else
         return (256 + nb);
     }
   }