网站建设方案基本流程,手机app开发工具中文版,二级网站都在一台服务器怎么做域名,防城港装修公司口碑排行闲暇时折腾IP网络视频监控系统#xff0c;需要支持视频帧数据包在网络内的传输。未采用H.264或MPEG4等编码压缩方式#xff0c;直接使用Bitmap图片。由于对帧的准确到达要求不好#xff0c;所以采用UDP传输。如果发生网络丢包现象则直接将帧丢弃。为了记录数据包的传输顺序和…闲暇时折腾IP网络视频监控系统需要支持视频帧数据包在网络内的传输。未采用H.264或MPEG4等编码压缩方式直接使用Bitmap图片。由于对帧的准确到达要求不好所以采用UDP传输。如果发生网络丢包现象则直接将帧丢弃。为了记录数据包的传输顺序和帧的时间戳所以研究了下RFC3550协议采用RTP包封装视频帧。并未全面深究所以未使用SSRC和CSRC因为不确切了解其用意。不过目前的实现情况已经足够了。 1 /// summary2 /// RTP(RFC3550)协议数据包3 /// /summary4 /// remarks5 /// The RTP header has the following format:6 /// 0 1 2 37 /// 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 18 /// --------------------------------9 /// |V2|P|X| CC |M| PT | sequence number |10 /// --------------------------------11 /// | timestamp |12 /// --------------------------------13 /// | synchronization source (SSRC) identifier |14 /// 15 /// | contributing source (CSRC) identifiers |16 /// | .... |17 /// --------------------------------18 /// /remarks19 public class RtpPacket20 {21 /// summary22 /// version (V): 2 bits23 /// RTP版本标识当前规范定义值为2.24 /// This field identifies the version of RTP. The version defined by this specification is two (2).25 /// (The value 1 is used by the first draft version of RTP and the value 0 is used by the protocol26 /// initially implemented in the \vat audio tool.)27 /// /summary28 public int Version { get { return 2; } }29 30 /// summary31 /// padding (P)1 bit32 /// 如果设定padding在报文的末端就会包含一个或者多个padding 字节这不属于payload。33 /// 最后一个字节的padding 有一个计数器标识需要忽略多少个padding 字节(包括自己)。34 /// 一些加密算法可能需要固定块长度的padding或者是为了在更低层数据单元中携带一些RTP 报文。35 /// If the padding bit is set, the packet contains one or more additional padding octets at the36 /// end which are not part of the payload. The last octet of the padding contains a count of37 /// how many padding octets should be ignored, including itself. Padding may be needed by38 /// some encryption algorithms with fixed block sizes or for carrying several RTP packets in a39 /// lower-layer protocol data unit.40 /// /summary41 public int Padding { get { return 0; } }42 43 /// summary44 /// extension (X)1 bit 45 /// 如果设定了extension 位定长头字段后面会有一个头扩展。46 /// If the extension bit is set, the fixed header must be followed by exactly one header extensio.47 /// /summary48 public int Extension { get { return 0; } }49 50 /// summary51 /// CSRC count (CC)4 bits 52 /// CSRC count 标识了定长头字段中包含的CSRC identifier 的数量。53 /// The CSRC count contains the number of CSRC identifiers that follow the fixed header.54 /// /summary55 public int CC { get { return 0; } }56 57 /// summary58 /// marker (M)1 bit 59 /// marker 是由一个profile 定义的。用来允许标识在像报文流中界定帧界等的事件。60 /// 一个profile 可能定义了附加的标识位或者通过修改payload type 域中的位数量来指定没有标识位.61 /// The interpretation of the marker is defined by a profile. It is intended to allow significant62 /// events such as frame boundaries to be marked in the packet stream. A profile may define63 /// additional marker bits or specify that there is no marker bit by changing the number of bits64 /// in the payload type field.65 /// /summary66 public int Marker { get { return 0; } }67 68 /// summary69 /// payload type (PT)7 bits70 /// 这个字段定一个RTPpayload 的格式和在应用中定义解释。71 /// profile 可能指定一个从payload type 码字到payload format 的默认静态映射。72 /// 也可以通过non-RTP 方法来定义附加的payload type 码字(见第3 章)。73 /// 在 RFC 3551[1]中定义了一系列的默认音视频映射。74 /// 一个RTP 源有可能在会话中改变payload type但是这个域在复用独立的媒体时是不同的。(见5.2 节)。75 /// 接收者必须忽略它不识别的payload type。76 /// This field identifies the format of the RTP payload and determines its interpretation by the77 /// application. A profile may specify a default static mapping of payload type codes to payload78 /// formats. Additional payload type codes may be defined dynamically through non-RTP means79 /// (see Section 3). A set of default mappings for audio and video is specified in the companion80 /// RFC 3551 [1]. An RTP source may change the payload type during a session, but this field81 /// should not be used for multiplexing separate media streams (see Section 5.2).82 /// A receiver must ignore packets with payload types that it does not understand.83 /// /summary84 public RtpPayloadType PayloadType { get; private set; }85 86 /// summary87 /// sequence number16 bits88 /// 每发送一个RTP 数据报文序列号值加一接收者也可用来检测丢失的包或者重建报文序列。89 /// 初始的值是随机的这样就使得known-plaintext 攻击更加困难 即使源并没有加密(见9。1)90 /// 因为要通过的translator 会做这些事情。关于选择随机数方面的技术见[17]。91 /// The sequence number increments by one for each RTP data packet sent, and may be used92 /// by the receiver to detect packet loss and to restore packet sequence. The initial value of the93 /// sequence number should be random (unpredictable) to make known-plaintext attacks on94 /// encryption more dificult, even if the source itself does not encrypt according to the method95 /// in Section 9.1, because the packets may flow through a translator that does. Techniques for96 /// choosing unpredictable numbers are discussed in [17].97 /// /summary98 public int SequenceNumber { get; private set; }99
100 /// summary
101 /// timestamp32 bits
102 /// timestamp 反映的是RTP 数据报文中的第一个字段的采样时刻的时间瞬时值。
103 /// 采样时间值必须是从恒定的和线性的时间中得到以便于同步和jitter 计算(见第6.4.1 节)。
104 /// 必须保证同步和测量保温jitter 到来所需要的时间精度(一帧一个tick 一般情况下是不够的)。
105 /// 时钟频率是与payload 所携带的数据格式有关的在profile 中静态的定义或是在定义格式的payload format 中
106 /// 或通过non-RTP 方法所定义的payload format 中动态的定义。如果RTP 报文周期的生成就采用虚拟的(nominal)
107 /// 采样时钟而不是从系统时钟读数。例如在固定比特率的音频中timestamp 时钟会在每个采样周期时加一。
108 /// 如果音频应用中从输入设备中读入160 个采样周期的块the timestamp 就会每一块增加160
109 /// 而不管块是否传输了或是丢弃了。
110 /// 对于序列号来说timestamp 初始值是随机的。只要它们是同时(逻辑上)同时生成的
111 /// 这些连续的的 RTP 报文就会有相同的timestamp
112 /// 例如同属一个视频帧。正像在MPEG 中内插视频帧一样
113 /// 连续的但不是按顺序发送的RTP 报文可能含有相同的timestamp。
114 /// The timestamp reflects the sampling instant of the first octet in the RTP data packet. The
115 /// sampling instant must be derived from a clock that increments monotonically and linearly
116 /// in time to allow synchronization and jitter calculations (see Section 6.4.1). The resolution
117 /// of the clock must be suficient for the desired synchronization accuracy and for measuring
118 /// packet arrival jitter (one tick per video frame is typically not suficient). The clock frequency
119 /// is dependent on the format of data carried as payload and is specified statically in the profile
120 /// or payload format specification that defines the format, or may be specified dynamically for
121 /// payload formats defined through non-RTP means. If RTP packets are generated periodically,
122 /// the nominal sampling instant as determined from the sampling clock is to be used, not a
123 /// reading of the system clock. As an example, for fixed-rate audio the timestamp clock would
124 /// likely increment by one for each sampling period. If an audio application reads blocks covering
125 /// 160 sampling periods from the input device, the timestamp would be increased by 160 for
126 /// each such block, regardless of whether the block is transmitted in a packet or dropped as silent.
127 /// /summary
128 public long Timestamp { get; private set; }
129
130 /// summary
131 /// SSRC32 bits
132 /// SSRC 域识别同步源。为了防止在一个会话中有相同的同步源有相同的SSRC identifier
133 /// 这个identifier 必须随机选取。
134 /// 生成随机 identifier 的算法见目录A.6 。虽然选择相同的identifier 概率很小
135 /// 但是所有的RTP implementation 必须检测和解决冲突。
136 /// 第8 章描述了冲突的概率和解决机制和RTP 级的检测机制根据唯一的 SSRCidentifier 前向循环。
137 /// 如果有源改变了它的源传输地址
138 /// 就必须为它选择一个新的SSRCidentifier 来避免被识别为循环过的源(见第8.2 节)。
139 /// The SSRC field identifies the synchronization source. This identifier should be chosen
140 /// randomly, with the intent that no two synchronization sources within the same RTP session
141 /// will have the same SSRC identifier. An example algorithm for generating a random identifier
142 /// is presented in Appendix A.6. Although the probability of multiple sources choosing the same
143 /// identifier is low, all RTP implementations must be prepared to detect and resolve collisions.
144 /// Section 8 describes the probability of collision along with a mechanism for resolving collisions
145 /// and detecting RTP-level forwarding loops based on the uniqueness of the SSRC identifier. If
146 /// a source changes its source transport address, it must also choose a new SSRC identifier to
147 /// avoid being interpreted as a looped source (see Section 8.2).
148 /// /summary
149 public int SSRC { get { return 0; } }
150
151 /// summary
152 /// 每一个RTP包中都有前12个字节定长的头字段
153 /// The first twelve octets are present in every RTP packet
154 /// /summary
155 public const int HeaderSize 12;
156 /// summary
157 /// RTP消息头
158 /// /summary
159 private byte[] _header;
160 /// summary
161 /// RTP消息头
162 /// /summary
163 public byte[] Header { get { return _header; } }
164
165 /// summary
166 /// RTP有效载荷长度
167 /// /summary
168 private int _payloadSize;
169 /// summary
170 /// RTP有效载荷长度
171 /// /summary
172 public int PayloadSize { get { return _payloadSize; } }
173
174 /// summary
175 /// RTP有效载荷
176 /// /summary
177 private byte[] _payload;
178 /// summary
179 /// RTP有效载荷
180 /// /summary
181 public byte[] Payload { get { return _payload; } }
182
183 /// summary
184 /// RTP消息总长度包括Header和Payload
185 /// /summary
186 public int Length { get { return HeaderSize PayloadSize; } }
187
188 /// summary
189 /// RTP(RFC3550)协议数据包
190 /// /summary
191 /// param nameplayloadType数据报文有效载荷类型/param
192 /// param namesequenceNumber数据报文序列号值/param
193 /// param nametimestamp数据报文采样时刻/param
194 /// param namedata数据/param
195 /// param namedataSize数据长度/param
196 public RtpPacket(
197 RtpPayloadType playloadType,
198 int sequenceNumber,
199 long timestamp,
200 byte[] data,
201 int dataSize)
202 {
203 // fill changing header fields
204 SequenceNumber sequenceNumber;
205 Timestamp timestamp;
206 PayloadType playloadType;
207
208 // build the header bistream
209 _header new byte[HeaderSize];
210
211 // fill the header array of byte with RTP header fields
212 _header[0] (byte)((Version 6) | (Padding 5) | (Extension 4) | CC);
213 _header[1] (byte)((Marker 7) | (int)PayloadType);
214 _header[2] (byte)(SequenceNumber 8);
215 _header[3] (byte)(SequenceNumber);
216 for (int i 0; i 4; i)
217 {
218 _header[7 - i] (byte)(Timestamp (8 * i));
219 }
220 for (int i 0; i 4; i)
221 {
222 _header[11 - i] (byte)(SSRC (8 * i));
223 }
224
225 // fill the payload bitstream
226 _payload new byte[dataSize];
227 _payloadSize dataSize;
228
229 // fill payload array of byte from data (given in parameter of the constructor)
230 Array.Copy(data, 0, _payload, 0, dataSize);
231 }
232
233 /// summary
234 /// RTP(RFC3550)协议数据包
235 /// /summary
236 /// param nameplayloadType数据报文有效载荷类型/param
237 /// param namesequenceNumber数据报文序列号值/param
238 /// param nametimestamp数据报文采样时刻/param
239 /// param nameframe图片/param
240 public RtpPacket(
241 RtpPayloadType playloadType,
242 int sequenceNumber,
243 long timestamp,
244 Image frame)
245 {
246 // fill changing header fields
247 SequenceNumber sequenceNumber;
248 Timestamp timestamp;
249 PayloadType playloadType;
250
251 // build the header bistream
252 _header new byte[HeaderSize];
253
254 // fill the header array of byte with RTP header fields
255 _header[0] (byte)((Version 6) | (Padding 5) | (Extension 4) | CC);
256 _header[1] (byte)((Marker 7) | (int)PayloadType);
257 _header[2] (byte)(SequenceNumber 8);
258 _header[3] (byte)(SequenceNumber);
259 for (int i 0; i 4; i)
260 {
261 _header[7 - i] (byte)(Timestamp (8 * i));
262 }
263 for (int i 0; i 4; i)
264 {
265 _header[11 - i] (byte)(SSRC (8 * i));
266 }
267
268 // fill the payload bitstream
269 using (MemoryStream ms new MemoryStream())
270 {
271 frame.Save(ms, ImageFormat.Jpeg);
272 _payload ms.ToArray();
273 _payloadSize _payload.Length;
274 }
275 }
276
277 /// summary
278 /// RTP(RFC3550)协议数据包
279 /// /summary
280 /// param namepacket数据包/param
281 /// param namepacketSize数据包长度/param
282 public RtpPacket(byte[] packet, int packetSize)
283 {
284 //check if total packet size is lower than the header size
285 if (packetSize HeaderSize)
286 {
287 //get the header bitsream
288 _header new byte[HeaderSize];
289 for (int i 0; i HeaderSize; i)
290 {
291 _header[i] packet[i];
292 }
293
294 //get the payload bitstream
295 _payloadSize packetSize - HeaderSize;
296 _payload new byte[_payloadSize];
297 for (int i HeaderSize; i packetSize; i)
298 {
299 _payload[i - HeaderSize] packet[i];
300 }
301
302 //interpret the changing fields of the header
303 PayloadType (RtpPayloadType)(_header[1] 127);
304 SequenceNumber UnsignedInt(_header[3]) 256 * UnsignedInt(_header[2]);
305 Timestamp UnsignedInt(_header[7])
306 256 * UnsignedInt(_header[6])
307 65536 * UnsignedInt(_header[5])
308 16777216 * UnsignedInt(_header[4]);
309 }
310 }
311
312 /// summary
313 /// 将消息转换成byte数组
314 /// /summary
315 /// returns消息byte数组/returns
316 public byte[] ToArray()
317 {
318 byte[] packet new byte[Length];
319
320 Array.Copy(_header, 0, packet, 0, HeaderSize);
321 Array.Copy(_payload, 0, packet, HeaderSize, PayloadSize);
322
323 return packet;
324 }
325
326 /// summary
327 /// 将消息体转换成图片
328 /// /summary
329 /// returns图片/returns
330 public Bitmap ToBitmap()
331 {
332 return new Bitmap(new MemoryStream(_payload));
333 }
334
335 /// summary
336 /// 将消息体转换成图片
337 /// /summary
338 /// returns图片/returns
339 public Image ToImage()
340 {
341 return Image.FromStream(new MemoryStream(_payload));
342 }
343
344 /// summary
345 /// 将图片转换成消息
346 /// /summary
347 /// param nameplayloadType数据报文有效载荷类型/param
348 /// param namesequenceNumber数据报文序列号值/param
349 /// param nametimestamp数据报文采样时刻/param
350 /// param nameframe图片帧/param
351 /// returns
352 /// RTP消息
353 /// /returns
354 public static RtpPacket FromImage(
355 RtpPayloadType playloadType,
356 int sequenceNumber,
357 long timestamp,
358 Image frame)
359 {
360 return new RtpPacket(playloadType, sequenceNumber, timestamp, frame);
361 }
362
363 /// summary
364 /// return the unsigned value of 8-bit integer nb
365 /// /summary
366 /// param namenb/param
367 /// returns/returns
368 private static int UnsignedInt(int nb)
369 {
370 if (nb 0)
371 return (nb);
372 else
373 return (256 nb);
374 }
375 }
