?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
remove \r
[extl.git] / extl / media / ts / transport_packet_.h
blobcf2e75a1d57dba7e60c38bdcbc520cb771ab2a04
1 /* ///////////////////////////////////////////////////////////////////////
2 * File: transport_packet.h
3 *
4 * Created: 09.02.06
5 * Updated: 09.02.06
6 *
7 * Brief: the transport_packet class - TS packet
8 *
9 * [<Home>]
10 * Copyright (c) 2008-2020, Waruqi All rights reserved.
11 * //////////////////////////////////////////////////////////////////// */
12
13 #ifndef EXTL_MEDIA_TS_TRANSPORT_PACKET_H
14 #define EXTL_MEDIA_TS_TRANSPORT_PACKET_H
15
16 /*!\file transport_packet.h
17 * \brief the transport_packet class - TS packet
18 */
19 #ifndef __cplusplus
20 # error transport_packet.h need be supported by c++.
21 #endif
22
23 /* ///////////////////////////////////////////////////////////////////////
24 * Includes
25 */
26 #include "prefix.h"
27 #include "../../memory/buffer.h"
28 #include "../../algorithm/algorithm.h"
29 #include "../../utility/bit_op.h"
30 #include "../../type/traits/is_unsigned.h"
31
32 /* ///////////////////////////////////////////////////////////////////////
33 * ::extl::media namespace
34 */
35 EXTL_MEDIA_BEGIN_WHOLE_NAMESPACE
36
37
38 /*!brief transport_packet
39 *
40 * \ingroup extl_group_media
41 *
42 * \code
43 * // transport packet format - TS
44 * struct transport_packet
45 {
46 // header
47 sync_byte : 8 ;
48 transport_error_indicator : 1 ;
49 payload_unit_start_indicator : 1 ;
50 transport_priority : 1 ;
51 pid : 13 ;
52 transport_scrambling_control : 2 ;
53 adaptation_field_control : 2 ;
54 continuity_counter : 4 ;
55
56 // adaptation field
57 if (adaptation_field_control == 0x2
58 || adaptation_field_control == 0x3 )
59 {
60 struct adaptation_field
61 {
62 // adaptation field header
63 adaptation_field_length : 8 ;
64 discontinuity_indicator : 1 ;
65 random_access_indicator : 1 ;
66 elementary_stream_priority_indicator : 1 ;
67 pcr_flag : 1 ;
68 opcr_flag : 1 ;
69 splicing_point_flag : 1 ;
70 transport_private_data_flag : 1 ;
71 adaptation_field_extension_flag : 1 ;
72
73 // program clock reference
74 if (pcr_flag == 1)
75 {
76 pcr_base : 33 ;
77 reseved : 6 ;
78 pcr_extension : 9 ;
79
80 }
81
82 // original program clock reference
83 if (opcr_flag == 1)
84 {
85 opcr_base : 33 ;
86 reseved : 6 ;
87 opcr_extension : 9 ;
88 }
89
90 // splicing point
91 if (splicing_point_flag == 1)
92 {
93 splice_countdown : 8 ;
94 }
95
96 // transport private data
97 if (transport_private_data_flag == 1)
98 {
99 for (i = 0; i < transport_private_data_length; ++i)
100 private_data_byte : 8 ;
101
102 if (adaptation_field_extension_flag == 1)
103 {
104 adaptation_field_extension_length : 8 ;
105 ltw_flag : 1 ;
106 piecewise_rate_flag : 1 ;
107 seamless_splice_flag : 1 ;
108 reserved : 5 ;
109
110 if (ltw_flag == 1)
111 {
112 ltw_valid_flag : 1 ;
113 ltw_offset : 15 ;
114 }
115
116 if (piecewise_rate_flag == 1)
117 {
118 reserved : 2 ;
119 piecewise_rate : 22 ;
120 }
121
122 if (seamless_splice_flag == 1)
123 {
124 splice_type : 4 ;
125 dts_next_au[32..30] : 3 ;
126 marker_bit : 1 ;
127 dts_next_au[29..15] : 15 ;
128 marker_bit : 1 ;
129 dts_next_au[14..0] : 15 ;
130 marker_bit : 1 ;
131 }
132
133 for (i = 0; i < N; ++i)
134 reserved : 8 ;
135 }
136 }
137
138 for (i = 0; i < N; ++i)
139 stuffing_byte : 8 ;
140 };
141 }
142
143 // payload data
144 if (adaptation_field_control == 0x1
145 || adaptation_field_control == 0x3 )
146 {
147 for (i = 0; i < N; ++i)
148 data_byte : 8 ;
149 }
150 };
151 * \endcode
152 *
153 * \note member methods and attributes need using attach and detach, static methods need not
154 * \code
155 // non-static
156 transport_packet p1;
157 p1.attach(buf);
158 printf("%x\n", p1.sync_byte());
159 printf("%x\n", p1.transport_error_indicator());
160 printf("%x\n", p1.payload_unit_start_indicator());
161 printf("%x\n", p1.transport_priority());
162 printf("%x\n", p1.pid());
163 printf("%x\n", p1.transport_scrambling_control());
164 printf("%x\n", p1.adaptation_field_control());
165 printf("%x\n", p1.continuity_counter());
166 // modify payload ...
167 p1.detach();
168
169 // static
170 printf("%x\n", transport_packet::pid(buf));
171 *
172 * \endcode
173 */
174 class transport_packet
175 {
176 /// \name Types
177 /// @{
178 public:
179 typedef transport_packet class_type;
180 typedef e_byte_t byte_type;
181 typedef e_uint16_t word_type;
182 typedef e_uint32_t dword_type;
183 typedef e_uint64_t qword_type;
184 typedef byte_type* pointer;
185 typedef byte_type const* const_pointer;
186 typedef attached_buffer<byte_type, 188> buffer_type;
187 typedef e_size_t size_type;
188 typedef size_type index_type;
189 typedef e_bool_t bool_type;
190 struct header_type
191 {
192 // \note defined in reverse order by dword_type
193 dword_type continuity_counter : 4 ; //< low bit
194 dword_type adaptation_field_control : 2 ;
195 dword_type transport_scrambling_control : 2 ;
196 dword_type pid : 13 ;
197 dword_type transport_priority : 1 ;
198 dword_type payload_unit_start_indicator : 1 ;
199 dword_type transport_error_indicator : 1 ;
200 dword_type sync_byte : 8 ; //< high bit
201 };
202
203 struct adaptation_field_header_type
204 {
205 byte_type adaptation_field_length ;
206
207 // \note defined in reverse order by byte_type
208 byte_type adaptation_field_extension_flag : 1 ; //< low bit
209 byte_type transport_private_data_flag : 1 ;
210 byte_type splicing_point_flag : 1 ;
211 byte_type opcr_flag : 1 ;
212 byte_type pcr_flag : 1 ;
213 byte_type elementary_stream_priority_indicator : 1 ;
214 byte_type random_access_indicator : 1 ;
215 byte_type discontinuity_indicator : 1 ; //< high bit
216 };
217
218 // program_clock_reference
219 // pcr_base + base1 + reseved + pcr_extension
220 // |=> 33bit <=| 6 9
221 struct pcr_type
222 {
223 // 32(pcr_base) + 1(base1)
224 dword_type pcr_base ;
225
226 // \note defined in reverse order by word_type
227 word_type pcr_extension : 9 ; //< low bit
228 word_type reseved : 6 ;
229 word_type base1 : 1 ; //< high bit
230 };
231
232 // original_program_clock_reference
233 // opcr_base + base1 + reseved + pcr_extension
234 // |=> 33bit <=| 6 9
235 struct opcr_type
236 {
237 // 32(opcr_base) + 1(base1)
238 dword_type opcr_base ;
239
240 // \note defined in reverse order by word_type
241 word_type opcr_extension : 9 ; //< low bit
242 word_type reseved : 6 ;
243 word_type base1 : 1 ; //< high bit
244 };
245
246 // adaptation_field_extension_header
247 struct adaptation_field_extension_header_type
248 {
249 byte_type adaptation_field_extension_length : 8 ;
250
251 // \note defined in reverse order by byte_type
252 byte_type reserved : 5 ;
253 byte_type seamless_splice_flag : 1 ;
254 byte_type piecewise_rate_flag : 1 ;
255 byte_type ltw_flag : 1 ;
256 };
257
258 // ltw
259 struct ltw_type
260 {
261 // \note defined in reverse order by word_type
262 word_type ltw_offset : 15 ;
263 word_type ltw_valid_flag : 1 ;
264 };
265 /// @}
266
267 /// \name Enumerators
268 /// @{
269 public:
270 // the packet header size
271 enum { en_header_size = sizeof(header_type) };
272 // the whole packet size
273 enum { en_packet_size = 188 };
274 //
275 enum { en_adaptation_field_header_size = sizeof(adaptation_field_header_type) };
276 // the pcr size
277 enum { en_pcr_size = sizeof(pcr_type) };
278 // the whole packet size
279 enum { en_opcr_size = sizeof(opcr_type) };
280 // the splice size
281 enum { en_splicing_size = 1 };
282 // the adaptation field extension _header size
283 enum { en_adaptation_field_extension_header_size = sizeof(adaptation_field_extension_header_type) };
284 // the ltw size
285 enum { en_ltw_size = sizeof(ltw_type) };
286
287
288 // for header_type::sync_byte
289 enum { en_sync_byte = 0x47 };
290
291 // for header_type::pid
292 enum { en_pid_pat = 0x0000 };
293 enum { en_pid_cat = 0x0001 };
294 enum { en_pid_tsdt = 0x0002 };
295 enum { en_pid_null = 0x1FFF }; //!<? 0xFFFF or 0x 1FFF
296 /// @}
297
298 /// \name Members
299 /// @{
300 private:
301 buffer_type m_buffer;
302 /// @}
303
304 /// \name Constructors
305 /// @{
306 public:
307 explicit_k transport_packet(const_pointer data = NULL)
308 {
309 attach(data);
310 }
311 ~transport_packet()
312 {
313 EXTL_STATIC_ASSERT(sizeof(header_type) == 4);
314 EXTL_STATIC_ASSERT(sizeof(byte_type) == 1);
315 EXTL_STATIC_ASSERT(is_unsigned<byte_type>::value);
316 EXTL_STATIC_ASSERT(is_unsigned<dword_type>::value);
317 }
318 /// @}
319
320 /// \name Accessors
321 /// @{
322 public:
323 buffer_type& buffer() { return m_buffer; }
324 buffer_type const& buffer() const { return m_buffer; }
325
326 pointer data() { return buffer().data(); }
327 const_pointer data() const { return buffer().data(); }
328
329 pointer adaptation_field_data() { return (data() + en_header_size); }
330 const_pointer adaptation_field_data() const { return (data() + en_header_size); }
331
332 pointer pcr_data() { return (exists_pcr()? (adaptation_field_data() + en_adaptation_field_header_size) : adaptation_field_data()); }
333 const_pointer pcr_data() const { return (exists_pcr()? (adaptation_field_data() + en_adaptation_field_header_size) : adaptation_field_data()); }
334
335 pointer opcr_data() { return (exists_opcr()? (pcr_data() + en_pcr_size) : pcr_data()); }
336 const_pointer opcr_data() const { return (exists_opcr()? (pcr_data() + en_pcr_size) : pcr_data()); }
337
338 pointer splicing_data() { return (exists_splicing()? (opcr_data() + en_opcr_size) : opcr_data()); }
339 const_pointer splicing_data() const { return (exists_splicing()? (opcr_data() + en_opcr_size) : opcr_data()); }
340
341 pointer transport_private_data() { return (exists_private_data()? (splicing_data() + en_splicing_size) : splicing_data()); }
342 const_pointer transport_private_data() const { return (exists_private_data()? (splicing_data() + en_splicing_size) : splicing_data()); }
343
344 pointer private_data() { return &(transport_private_data()[1]); }
345 const_pointer private_data() const { return &(transport_private_data()[1]); }
346
347 pointer adaptation_field_extension_data() { return (exists_adaptation_field_extension()? (private_data() + private_data_length()) : transport_private_data()); }
348 const_pointer adaptation_field_extension_data() const { return (exists_adaptation_field_extension()? (private_data() + private_data_length()) : transport_private_data()); }
349
350 pointer ltw_data() { return (exists_ltw()? (adaptation_field_extension_data() + en_adaptation_field_extension_header_size) : adaptation_field_extension_data()); }
351 const_pointer ltw_data() const { return (exists_ltw()? (adaptation_field_extension_data() + en_adaptation_field_extension_header_size) : adaptation_field_extension_data()); }
352 /// @}
353
354 /// \name Protected Accessors
355 /// @{
356 public:
357 header_type& header() { return *reinterpret_cast<header_type*>(data()); }
358 header_type const& header() const { return *reinterpret_cast<header_type const*>(data()); }
359
360 adaptation_field_header_type& adaptation_field_header() { return *reinterpret_cast<adaptation_field_header_type*>(adaptation_field_data()); }
361 adaptation_field_header_type const& adaptation_field_header() const { return *reinterpret_cast<adaptation_field_header_type const*>(adaptation_field_data()); }
362
363 pcr_type& pcr_body() { return *reinterpret_cast<pcr_type*>(pcr_data()); }
364 pcr_type const& pcr_body() const { return *reinterpret_cast<pcr_type const*>(pcr_data()); }
365
366 opcr_type& opcr_body() { return *reinterpret_cast<opcr_type*>(opcr_data()); }
367 opcr_type const& opcr_body() const { return *reinterpret_cast<opcr_type const*>(opcr_data()); }
368
369 adaptation_field_extension_header_type& adaptation_field_extension() { return *reinterpret_cast<adaptation_field_extension_header_type*>(adaptation_field_extension_data()); }
370 adaptation_field_extension_header_type const& adaptation_field_extension() const { return *reinterpret_cast<adaptation_field_extension_header_type const*>(adaptation_field_extension_data()); }
371
372 ltw_type& ltw() { return *reinterpret_cast<ltw_type*>(ltw_data()); }
373 ltw_type const& ltw() const { return *reinterpret_cast<ltw_type const*>(ltw_data()); }
374
375 /// @}
376
377 /// \name Mutators
378 /// @{
379 public:
380 /// attaches packet buffer - size: 188b
381 /// \note maybe modify the buffer for performance
382 void attach(const_pointer p);
383 /// detaches packet buffer
384 /// \note maybe modify the buffer for performance
385 const_pointer detach();
386 /// @}
387
388 /// \name Header Attributes
389 /// @{
390 public:
391 size_type sync_byte() const { return static_cast<size_type>(header().sync_byte); }
392 void sync_byte(size_type value) { header().sync_byte = static_cast<dword_type>(value); }
393
394 size_type transport_error_indicator() const { return static_cast<size_type>(header().transport_error_indicator); }
395 void transport_error_indicator(size_type value) { header().transport_error_indicator = static_cast<dword_type>(value); }
396
397 size_type payload_unit_start_indicator() const { return static_cast<size_type>(header().payload_unit_start_indicator); }
398 void payload_unit_start_indicator(size_type value) { header().payload_unit_start_indicator = static_cast<dword_type>(value); }
399
400 size_type transport_priority() const { return static_cast<size_type>(header().transport_priority); }
401 void transport_priority(size_type value) { header().transport_priority = static_cast<dword_type>(value); }
402
403 size_type pid() const { return static_cast<size_type>(header().pid); }
404 void pid(size_type value) { header().pid = static_cast<dword_type>(value); }
405
406 size_type transport_scrambling_control() const { return static_cast<size_type>(header().transport_scrambling_control); }
407 void transport_scrambling_control(size_type value) { header().transport_scrambling_control = static_cast<dword_type>(value); }
408
409 size_type adaptation_field_control() const { return static_cast<size_type>(header().adaptation_field_control); }
410 void adaptation_field_control(size_type value) { header().adaptation_field_control = static_cast<dword_type>(value); }
411
412 size_type continuity_counter() const { return static_cast<size_type>(header().continuity_counter); }
413 void continuity_counter(size_type value) { header().continuity_counter = static_cast<dword_type>(value); }
414 /// @}
415
416 /// \name Adaptation Field Header Attributes
417 /// @{
418 public:
419 size_type adaptation_field_length() const { return static_cast<size_type>(adaptation_field_header().adaptation_field_length); }
420 void adaptation_field_length(size_type value) { adaptation_field_header().adaptation_field_length = static_cast<byte_type>(value); }
421
422 size_type discontinuity_indicator() const { return static_cast<size_type>(adaptation_field_header().discontinuity_indicator); }
423 void discontinuity_indicator(size_type value) { adaptation_field_header().discontinuity_indicator = static_cast<byte_type>(value); }
424
425 size_type random_access_indicator() const { return static_cast<size_type>(adaptation_field_header().random_access_indicator); }
426 void random_access_indicator(size_type value) { adaptation_field_header().random_access_indicator = static_cast<byte_type>(value); }
427
428 size_type elementary_stream_priority_indicator() const { return static_cast<size_type>(adaptation_field_header().elementary_stream_priority_indicator); }
429 void elementary_stream_priority_indicator(size_type value) { adaptation_field_header().elementary_stream_priority_indicator = static_cast<byte_type>(value); }
430
431 size_type pcr_flag() const { return static_cast<size_type>(adaptation_field_header().pcr_flag); }
432 void pcr_flag(size_type value) { adaptation_field_header().pcr_flag = static_cast<byte_type>(value); }
433
434 size_type opcr_flag() const { return static_cast<size_type>(adaptation_field_header().opcr_flag); }
435 void opcr_flag(size_type value) { adaptation_field_header().opcr_flag = static_cast<byte_type>(value); }
436
437 size_type splicing_point_flag() const { return static_cast<size_type>(adaptation_field_header().splicing_point_flag); }
438 void splicing_point_flag(size_type value) { adaptation_field_header().splicing_point_flag = static_cast<byte_type>(value); }
439
440 size_type transport_private_data_flag() const { return static_cast<size_type>(adaptation_field_header().transport_private_data_flag); }
441 void transport_private_data_flag(size_type value) { adaptation_field_header().transport_private_data_flag = static_cast<byte_type>(value); }
442
443 size_type adaptation_field_extension_flag() const { return static_cast<size_type>(adaptation_field_header().adaptation_field_extension_flag); }
444 void adaptation_field_extension_flag(size_type value) { adaptation_field_header().adaptation_field_extension_flag = static_cast<byte_type>(value); }
445
446 bool_type exists_pcr() const { return (1 == pcr_flag()); }
447 bool_type exists_opcr() const { return (1 == opcr_flag()); }
448 bool_type exists_splicing() const { return (1 == splicing_point_flag()); }
449 bool_type exists_private_data() const { return (1 == transport_private_data_flag()); }
450 bool_type exists_adaptation_field_extension() const { return (1 == adaptation_field_extension_flag()); }
451 /// @}
452
453 /// \name Adaptation Field PCR Attributes
454 /// @{
455 public:
456 qword_type pcr() const { return (pcr_base() * 300 + pcr_extension()); }
457 qword_type opcr() const { return (opcr_base() * 300 + opcr_extension()); }
458
459 qword_type pcr_base() const { return ((static_cast<qword_type>(pcr_body().pcr_base) << 1) | pcr_body().base1); }
460 void pcr_base(qword_type value) { pcr_body().pcr_base = static_cast<dword_type>(value >> 1); pcr_body().base1 = static_cast<word_type>(value & 0x1); }
461
462 size_type pcr_extension() const { return static_cast<size_type>(pcr_body().pcr_extension); }
463 void pcr_extension(size_type value) { pcr_body().pcr_extension = static_cast<word_type>(value); }
464
465 qword_type opcr_base() const { return ((static_cast<qword_type>(opcr_body().opcr_base) << 1) | opcr_body().base1); }
466 void opcr_base(qword_type value) { opcr_body().opcr_base = static_cast<dword_type>(value >> 1); opcr_body().base1 = static_cast<word_type>(value & 0x1); }
467
468 size_type opcr_extension() const { return static_cast<size_type>(opcr_body().opcr_extension); }
469 void opcr_extension(size_type value) { opcr_body().opcr_extension = static_cast<word_type>(value); }
470 /// @}
471
472 /// \name Adaptation Field Other Attributes
473 /// @{
474 public:
475 size_type splice_countdown() const { return splicing_data()[0]; }
476 void splice_countdown(size_type value) { splicing_data()[0] = static_cast<byte_type>(value); }
477
478 size_type private_data_length() const { return transport_private_data()[0]; }
479 void private_data_length(size_type value){ transport_private_data()[0] = static_cast<byte_type>(value); }
480
481 // size_type adaptation_field_extension_length() const { return adaptation_field_extension().adaptation_field_extension_length; }
482 //void adaptation_field_extension_length(size_type value) { adaptation_field_extension().adaptation_field_extension_length = static_cast<byte_type>(adaptation_field_extension_length); }
483
484 size_type ltw_flag() const { return adaptation_field_extension().ltw_flag; }
485 void ltw_flag(size_type value) { adaptation_field_extension().ltw_flag = static_cast<byte_type>(value); }
486
487 size_type piecewise_rate_flag() const { return adaptation_field_extension().piecewise_rate_flag; }
488 void piecewise_rate_flag(size_type value) { adaptation_field_extension().piecewise_rate_flag = static_cast<byte_type>(value); }
489
490 size_type seamless_splice_flag() const { return adaptation_field_extension().seamless_splice_flag; }
491 void seamless_splice_flag(size_type value) { adaptation_field_extension().seamless_splice_flag = static_cast<byte_type>(value); }
492
493 bool_type exists_ltw() const { return (1 == ltw_flag()); }
494 bool_type exists_piecewise_rate() const { return (1 == piecewise_rate_flag()); }
495 bool_type exists_seamless_splice() const { return (1 == seamless_splice_flag()); }
496
497 size_type ltw_valid_flag() const { return ltw().ltw_valid_flag; }
498 void ltw_valid_flag(size_type value) { ltw().ltw_valid_flag = static_cast<word_type>(value); }
499
500 size_type ltw_offset() const { return ltw().ltw_offset; }
501 void ltw_offset(size_type value) { ltw().ltw_offset = static_cast<word_type>(value); }
502
503 /// @}
504
505 /// \name Packet Attributes
506 /// @{
507 public:
508 /// return \true if packet is pat(program association table)
509 bool_type is_pat() const { return (pid() == en_pid_pat); }
510 /// the packet is set to be pat
511 void set_pat() { pid(en_pid_pat); }
512
513 /// return \true if packet is cat(conditional access table)
514 bool_type is_cat() const { return (pid() == en_pid_cat); }
515 /// the packet is set to be cat
516 void set_cat() { pid(en_pid_cat); }
517
518 /// return \true if packet is tsdt(transport stream description table)
519 bool_type is_tsdt() const { return (pid() == en_pid_tsdt); }
520 /// the packet is set to be tsdt
521 void set_tsdt() { pid(en_pid_tsdt); }
522
523 /// return \true if packet is null
524 bool_type is_null() const { return (pid() == en_pid_null); }
525 /// the packet is set to be null
526 void set_null() { pid(en_pid_null); }
527
528 /// return \true if packet is scrambled
529 bool_type is_scrambling() const { return (transport_scrambling_control() != 0); }
530
531 /// return \true if packet exists error
532 bool_type exists_error() const { return (transport_error_indicator() != 0); }
533
534 /// return \true if the packet exists adaptation field
535 bool_type exists_adaptation_field() const { return (adaptation_field_control() == 0x2 || adaptation_field_control() == 0x3); }
536
537 /// return \true if the adaptation field is valid
538 bool_type adaptation_field_is_valid() const { return !((adaptation_field_control() == 0x2 && adaptation_field_length() != 183) || (adaptation_field_control() == 0x3 && adaptation_field_length() > 182)); }
539 /// @}
540
541 /// \name Other Attributes
542 /// @{
543 public:
544 bool_type is_valid() const { return (sync_byte() == en_sync_byte); }
545 /// @}
546
547 /// \name Static Methods
548 /// @{
549 public:
550 static size_type pid(const_pointer data) { return (((data[1] & 0x1F) << 8) | data[2]); }
551 /// @}
552
553 /// \name Protected Helpers
554 /// @{
555 protected:
556 /// reverse byte stream and \note size must be divided by 1, 2, 4
557 void reverse(pointer data, size_type size);
558 /// @}
559
560 };
561
562 /* ///////////////////////////////////////////////////////////////////////
563 * Implemention
564 */
565 inline void transport_packet::reverse(pointer data, size_type size)
566 {
567 // \note size must be divided by 1, 2, 4
568 EXTL_ASSERT(size == 1 || size == 2 || (size % 4) == 0);
569
570 pointer pb = data;
571 pointer pe = pb + size - 1;
572 while(pb < pe)
573 {
574 std_swap(*pb, *pe);
575 ++pb;
576 --pe;
577 }
578 }
579
580 inline void transport_packet::attach(const_pointer p)
581 {
582 if (NULL != p)
583 {
584 // attach packet data
585 buffer().attach(p, en_packet_size);
586
587 // adjust header data
588 reverse(data(), en_header_size);
589
590 // adjust pcr data
591 if (exists_pcr())
592 {
593 reverse(pcr_data(), 4);
594 reverse(pcr_data() + 4, 2);
595 }
596
597 // adjust opcr data
598 if (exists_opcr())
599 {
600 reverse(opcr_data(), 4);
601 reverse(opcr_data() + 4, 2);
602 }
603
604 // adjust ltw data
605 if (exists_ltw())
606 {
607 reverse(ltw_data(), en_ltw_size);
608 }
609 }
610 }
611 inline transport_packet::
612 const_pointer transport_packet::detach()
613 {
614 if (NULL != data())
615 {
616 // adjust ltw data
617 if (exists_ltw())
618 {
619 reverse(ltw_data(), en_ltw_size);
620 }
621
622 // resume opcr data
623 if (exists_opcr())
624 {
625 reverse(opcr_data() + 4, 2);
626 reverse(opcr_data(), 4);
627 }
628
629 // resume pcr data
630 if (exists_pcr())
631 {
632 reverse(pcr_data() + 4, 2);
633 reverse(pcr_data(), 4);
634 }
635
636 // resume header data
637 reverse(data(), en_header_size);
638
639 return data();
640 }
641 else return NULL;
642 }
643 /* ///////////////////////////////////////////////////////////////////////
644 * ::extl::media namespace
645 */
646 EXTL_MEDIA_END_WHOLE_NAMESPACE
647
648 /* //////////////////////////////////////////////////////////////////// */
649 #endif /* EXTL_MEDIA_TS_TRANSPORT_PACKET_H */
650 /* //////////////////////////////////////////////////////////////////// */
a c++ generic library