2 * MPEG2 transport stream (aka DVB) muxer
3 * Copyright (c) 2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 #include "libavutil/bswap.h"
23 #include "libavutil/crc.h"
24 #include "libavcodec/mpegvideo.h"
28 /* write DVB SI sections */
30 /*********************************************/
31 /* mpegts section writer */
33 typedef struct MpegTSSection
{
36 void (*write_packet
)(struct MpegTSSection
*s
, const uint8_t *packet
);
40 typedef struct MpegTSService
{
41 MpegTSSection pmt
; /* MPEG2 pmt table context */
42 int sid
; /* service ID */
50 typedef struct MpegTSWrite
{
51 MpegTSSection pat
; /* MPEG2 pat table */
52 MpegTSSection sdt
; /* MPEG2 sdt table context */
53 MpegTSService
**services
;
65 /* NOTE: 4 bytes must be left at the end for the crc32 */
66 static void mpegts_write_section(MpegTSSection
*s
, uint8_t *buf
, int len
)
68 MpegTSWrite
*ts
= ((AVFormatContext
*)s
->opaque
)->priv_data
;
70 unsigned char packet
[TS_PACKET_SIZE
];
71 const unsigned char *buf_ptr
;
73 int first
, b
, len1
, left
;
75 crc
= bswap_32(av_crc(av_crc_get_table(AV_CRC_32_IEEE
), -1, buf
, len
- 4));
76 buf
[len
- 4] = (crc
>> 24) & 0xff;
77 buf
[len
- 3] = (crc
>> 16) & 0xff;
78 buf
[len
- 2] = (crc
>> 8) & 0xff;
79 buf
[len
- 1] = (crc
) & 0xff;
81 /* send each packet */
84 first
= (buf
== buf_ptr
);
93 s
->cc
= (s
->cc
+ 1) & 0xf;
95 *q
++ = 0; /* 0 offset */
96 len1
= TS_PACKET_SIZE
- (q
- packet
);
99 memcpy(q
, buf_ptr
, len1
);
101 /* add known padding data */
102 left
= TS_PACKET_SIZE
- (q
- packet
);
104 memset(q
, 0xff, left
);
106 s
->write_packet(s
, packet
);
111 ts
->cur_pcr
+= TS_PACKET_SIZE
*8*90000LL/ts
->mux_rate
;
115 static inline void put16(uint8_t **q_ptr
, int val
)
124 static int mpegts_write_section1(MpegTSSection
*s
, int tid
, int id
,
125 int version
, int sec_num
, int last_sec_num
,
126 uint8_t *buf
, int len
)
128 uint8_t section
[1024], *q
;
129 unsigned int tot_len
;
131 tot_len
= 3 + 5 + len
+ 4;
132 /* check if not too big */
138 put16(&q
, 0xb000 | (len
+ 5 + 4)); /* 5 byte header + 4 byte CRC */
140 *q
++ = 0xc1 | (version
<< 1); /* current_next_indicator = 1 */
145 mpegts_write_section(s
, section
, tot_len
);
149 /*********************************************/
152 #define DEFAULT_PMT_START_PID 0x1000
153 #define DEFAULT_START_PID 0x0100
154 #define DEFAULT_PROVIDER_NAME "FFmpeg"
155 #define DEFAULT_SERVICE_NAME "Service01"
157 /* default network id, transport stream and service identifiers */
158 #define DEFAULT_ONID 0x0001
159 #define DEFAULT_TSID 0x0001
160 #define DEFAULT_SID 0x0001
162 /* a PES packet header is generated every DEFAULT_PES_HEADER_FREQ packets */
163 #define DEFAULT_PES_HEADER_FREQ 16
164 #define DEFAULT_PES_PAYLOAD_SIZE ((DEFAULT_PES_HEADER_FREQ - 1) * 184 + 170)
166 /* we retransmit the SI info at this rate */
167 #define SDT_RETRANS_TIME 500
168 #define PAT_RETRANS_TIME 100
169 #define PCR_RETRANS_TIME 20
171 typedef struct MpegTSWriteStream
{
172 struct MpegTSService
*service
;
173 int pid
; /* stream associated pid */
178 uint8_t payload
[DEFAULT_PES_PAYLOAD_SIZE
];
181 static void mpegts_write_pat(AVFormatContext
*s
)
183 MpegTSWrite
*ts
= s
->priv_data
;
184 MpegTSService
*service
;
185 uint8_t data
[1012], *q
;
189 for(i
= 0; i
< ts
->nb_services
; i
++) {
190 service
= ts
->services
[i
];
191 put16(&q
, service
->sid
);
192 put16(&q
, 0xe000 | service
->pmt
.pid
);
194 mpegts_write_section1(&ts
->pat
, PAT_TID
, ts
->tsid
, 0, 0, 0,
198 static void mpegts_write_pmt(AVFormatContext
*s
, MpegTSService
*service
)
200 // MpegTSWrite *ts = s->priv_data;
201 uint8_t data
[1012], *q
, *desc_length_ptr
, *program_info_length_ptr
;
202 int val
, stream_type
, i
;
205 put16(&q
, 0xe000 | service
->pcr_pid
);
207 program_info_length_ptr
= q
;
208 q
+= 2; /* patched after */
210 /* put program info here */
212 val
= 0xf000 | (q
- program_info_length_ptr
- 2);
213 program_info_length_ptr
[0] = val
>> 8;
214 program_info_length_ptr
[1] = val
;
216 for(i
= 0; i
< s
->nb_streams
; i
++) {
217 AVStream
*st
= s
->streams
[i
];
218 MpegTSWriteStream
*ts_st
= st
->priv_data
;
219 switch(st
->codec
->codec_id
) {
220 case CODEC_ID_MPEG1VIDEO
:
221 case CODEC_ID_MPEG2VIDEO
:
222 stream_type
= STREAM_TYPE_VIDEO_MPEG2
;
225 stream_type
= STREAM_TYPE_VIDEO_MPEG4
;
228 stream_type
= STREAM_TYPE_VIDEO_H264
;
231 stream_type
= STREAM_TYPE_VIDEO_DIRAC
;
235 stream_type
= STREAM_TYPE_AUDIO_MPEG1
;
238 stream_type
= STREAM_TYPE_AUDIO_AAC
;
241 stream_type
= STREAM_TYPE_AUDIO_AC3
;
244 stream_type
= STREAM_TYPE_PRIVATE_DATA
;
248 put16(&q
, 0xe000 | ts_st
->pid
);
250 q
+= 2; /* patched after */
252 /* write optional descriptors here */
253 switch(st
->codec
->codec_type
) {
254 case CODEC_TYPE_AUDIO
:
255 if (strlen(st
->language
) == 3) {
256 *q
++ = 0x0a; /* ISO 639 language descriptor */
258 *q
++ = st
->language
[0];
259 *q
++ = st
->language
[1];
260 *q
++ = st
->language
[2];
261 *q
++ = 0; /* undefined type */
264 case CODEC_TYPE_SUBTITLE
:
266 const char *language
;
267 language
= st
->language
;
268 if (strlen(language
) != 3)
275 *q
++ = 0x10; /* normal subtitles (0x20 = if hearing pb) */
276 put16(&q
, 1); /* page id */
277 put16(&q
, 1); /* ancillary page id */
280 case CODEC_TYPE_VIDEO
:
281 if (stream_type
== STREAM_TYPE_VIDEO_DIRAC
) {
282 *q
++ = 0x05; /*MPEG-2 registration descriptor*/
292 val
= 0xf000 | (q
- desc_length_ptr
- 2);
293 desc_length_ptr
[0] = val
>> 8;
294 desc_length_ptr
[1] = val
;
296 mpegts_write_section1(&service
->pmt
, PMT_TID
, service
->sid
, 0, 0, 0,
300 /* NOTE: str == NULL is accepted for an empty string */
301 static void putstr8(uint8_t **q_ptr
, const char *str
)
317 static void mpegts_write_sdt(AVFormatContext
*s
)
319 MpegTSWrite
*ts
= s
->priv_data
;
320 MpegTSService
*service
;
321 uint8_t data
[1012], *q
, *desc_list_len_ptr
, *desc_len_ptr
;
322 int i
, running_status
, free_ca_mode
, val
;
327 for(i
= 0; i
< ts
->nb_services
; i
++) {
328 service
= ts
->services
[i
];
329 put16(&q
, service
->sid
);
330 *q
++ = 0xfc | 0x00; /* currently no EIT info */
331 desc_list_len_ptr
= q
;
333 running_status
= 4; /* running */
336 /* write only one descriptor for the service name and provider */
340 *q
++ = 0x01; /* digital television service */
341 putstr8(&q
, service
->provider_name
);
342 putstr8(&q
, service
->name
);
343 desc_len_ptr
[0] = q
- desc_len_ptr
- 1;
345 /* fill descriptor length */
346 val
= (running_status
<< 13) | (free_ca_mode
<< 12) |
347 (q
- desc_list_len_ptr
- 2);
348 desc_list_len_ptr
[0] = val
>> 8;
349 desc_list_len_ptr
[1] = val
;
351 mpegts_write_section1(&ts
->sdt
, SDT_TID
, ts
->tsid
, 0, 0, 0,
355 static MpegTSService
*mpegts_add_service(MpegTSWrite
*ts
,
357 const char *provider_name
,
360 MpegTSService
*service
;
362 service
= av_mallocz(sizeof(MpegTSService
));
365 service
->pmt
.pid
= DEFAULT_PMT_START_PID
+ ts
->nb_services
- 1;
367 service
->provider_name
= av_strdup(provider_name
);
368 service
->name
= av_strdup(name
);
369 service
->pcr_pid
= 0x1fff;
370 dynarray_add(&ts
->services
, &ts
->nb_services
, service
);
374 static void section_write_packet(MpegTSSection
*s
, const uint8_t *packet
)
376 AVFormatContext
*ctx
= s
->opaque
;
377 put_buffer(ctx
->pb
, packet
, TS_PACKET_SIZE
);
380 static int mpegts_write_header(AVFormatContext
*s
)
382 MpegTSWrite
*ts
= s
->priv_data
;
383 MpegTSWriteStream
*ts_st
;
384 MpegTSService
*service
;
386 int i
, total_bit_rate
;
387 const char *service_name
;
388 uint64_t sdt_size
, pat_pmt_size
, pos
;
390 ts
->tsid
= DEFAULT_TSID
;
391 ts
->onid
= DEFAULT_ONID
;
392 /* allocate a single DVB service */
393 service_name
= s
->title
;
394 if (service_name
[0] == '\0')
395 service_name
= DEFAULT_SERVICE_NAME
;
396 service
= mpegts_add_service(ts
, DEFAULT_SID
,
397 DEFAULT_PROVIDER_NAME
, service_name
);
398 service
->pmt
.write_packet
= section_write_packet
;
399 service
->pmt
.opaque
= s
;
401 ts
->pat
.pid
= PAT_PID
;
403 ts
->pat
.write_packet
= section_write_packet
;
406 ts
->sdt
.pid
= SDT_PID
;
408 ts
->sdt
.write_packet
= section_write_packet
;
411 /* assign pids to each stream */
413 for(i
= 0;i
< s
->nb_streams
; i
++) {
415 ts_st
= av_mallocz(sizeof(MpegTSWriteStream
));
418 st
->priv_data
= ts_st
;
419 ts_st
->service
= service
;
420 ts_st
->pid
= DEFAULT_START_PID
+ i
;
421 ts_st
->payload_pts
= AV_NOPTS_VALUE
;
422 ts_st
->payload_dts
= AV_NOPTS_VALUE
;
423 /* update PCR pid by using the first video stream */
424 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
&&
425 service
->pcr_pid
== 0x1fff)
426 service
->pcr_pid
= ts_st
->pid
;
427 total_bit_rate
+= st
->codec
->bit_rate
;
430 /* if no video stream, use the first stream as PCR */
431 if (service
->pcr_pid
== 0x1fff && s
->nb_streams
> 0) {
432 ts_st
= s
->streams
[0]->priv_data
;
433 service
->pcr_pid
= ts_st
->pid
;
436 if (total_bit_rate
<= 8 * 1024)
437 total_bit_rate
= 8 * 1024;
438 service
->pcr_packet_freq
= (total_bit_rate
* PCR_RETRANS_TIME
) /
439 (TS_PACKET_SIZE
* 8 * 1000);
440 ts
->sdt_packet_freq
= (total_bit_rate
* SDT_RETRANS_TIME
) /
441 (TS_PACKET_SIZE
* 8 * 1000);
442 ts
->pat_packet_freq
= (total_bit_rate
* PAT_RETRANS_TIME
) /
443 (TS_PACKET_SIZE
* 8 * 1000);
445 ts
->mux_rate
= 1; // avoid div by 0
447 /* write info at the start of the file, so that it will be fast to
449 pos
= url_ftell(s
->pb
);
451 sdt_size
= url_ftell(s
->pb
) - pos
;
452 pos
= url_ftell(s
->pb
);
454 for(i
= 0; i
< ts
->nb_services
; i
++) {
455 mpegts_write_pmt(s
, ts
->services
[i
]);
457 pat_pmt_size
= url_ftell(s
->pb
) - pos
;
460 total_bit_rate
* 25 / (8 * DEFAULT_PES_PAYLOAD_SIZE
) + /* PES header size */
461 total_bit_rate
* 4 / (8 * TS_PACKET_SIZE
) + /* TS header size */
462 SDT_RETRANS_TIME
* sdt_size
+ /* SDT size */
463 PAT_RETRANS_TIME
* pat_pmt_size
+ /* PAT+PMT size */
464 PCR_RETRANS_TIME
* 8; /* PCR size */
466 av_log(s
, AV_LOG_DEBUG
, "muxrate %d freq sdt %d pat %d\n",
467 total_bit_rate
, ts
->sdt_packet_freq
, ts
->pat_packet_freq
);
470 ts
->mux_rate
= s
->mux_rate
;
472 ts
->mux_rate
= total_bit_rate
;
475 ts
->cur_pcr
/= ts
->mux_rate
;
477 put_flush_packet(s
->pb
);
482 for(i
= 0;i
< s
->nb_streams
; i
++) {
484 av_free(st
->priv_data
);
489 /* send SDT, PAT and PMT tables regulary */
490 static void retransmit_si_info(AVFormatContext
*s
)
492 MpegTSWrite
*ts
= s
->priv_data
;
495 if (++ts
->sdt_packet_count
== ts
->sdt_packet_freq
) {
496 ts
->sdt_packet_count
= 0;
499 if (++ts
->pat_packet_count
== ts
->pat_packet_freq
) {
500 ts
->pat_packet_count
= 0;
502 for(i
= 0; i
< ts
->nb_services
; i
++) {
503 mpegts_write_pmt(s
, ts
->services
[i
]);
508 static void write_pts(uint8_t *q
, int fourbits
, int64_t pts
)
512 val
= fourbits
<< 4 | (((pts
>> 30) & 0x07) << 1) | 1;
514 val
= (((pts
>> 15) & 0x7fff) << 1) | 1;
517 val
= (((pts
) & 0x7fff) << 1) | 1;
522 /* NOTE: pes_data contains all the PES packet */
523 static void mpegts_write_pes(AVFormatContext
*s
, AVStream
*st
,
524 const uint8_t *payload
, int payload_size
,
525 int64_t pts
, int64_t dts
)
527 MpegTSWriteStream
*ts_st
= st
->priv_data
;
528 MpegTSWrite
*ts
= s
->priv_data
;
529 uint8_t buf
[TS_PACKET_SIZE
];
531 int val
, is_start
, len
, header_len
, write_pcr
, private_code
, flags
;
532 int afc_len
, stuffing_len
;
533 int64_t pcr
= -1; /* avoid warning */
536 while (payload_size
> 0) {
537 retransmit_si_info(s
);
540 if (ts_st
->pid
== ts_st
->service
->pcr_pid
) {
541 ts_st
->service
->pcr_packet_count
++;
542 if (ts_st
->service
->pcr_packet_count
>=
543 ts_st
->service
->pcr_packet_freq
) {
544 ts_st
->service
->pcr_packet_count
= 0;
549 /* prepare packet header */
552 val
= (ts_st
->pid
>> 8);
557 *q
++ = 0x10 | ts_st
->cc
| (write_pcr
? 0x20 : 0);
558 ts_st
->cc
= (ts_st
->cc
+ 1) & 0xf;
560 // add 11, pcr references the last byte of program clock reference base
561 pcr
= ts
->cur_pcr
+ (4+7)*8*90000LL / ts
->mux_rate
;
562 if (dts
!= AV_NOPTS_VALUE
&& dts
< pcr
)
563 av_log(s
, AV_LOG_WARNING
, "dts < pcr, TS is invalid\n");
564 *q
++ = 7; /* AFC length */
565 *q
++ = 0x10; /* flags: PCR present */
570 *q
++ = (pcr
& 1) << 7;
574 int pes_extension
= 0;
575 /* write PES header */
580 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
581 if (st
->codec
->codec_id
== CODEC_ID_DIRAC
) {
585 } else if (st
->codec
->codec_type
== CODEC_TYPE_AUDIO
&&
586 (st
->codec
->codec_id
== CODEC_ID_MP2
||
587 st
->codec
->codec_id
== CODEC_ID_MP3
)) {
591 if (st
->codec
->codec_type
== CODEC_TYPE_SUBTITLE
) {
597 if (pts
!= AV_NOPTS_VALUE
) {
601 if (dts
!= AV_NOPTS_VALUE
&& dts
!= pts
) {
605 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
&&
606 st
->codec
->codec_id
== CODEC_ID_DIRAC
) {
607 /* set PES_extension_flag */
612 * One byte for PES2 extension flag +
613 * one byte for extension length +
614 * one byte for extension id
618 len
= payload_size
+ header_len
+ 3;
619 if (private_code
!= 0)
624 /* data alignment indicator is required for subtitle data */
625 if (st
->codec
->codec_type
== CODEC_TYPE_SUBTITLE
)
630 if (pts
!= AV_NOPTS_VALUE
) {
631 write_pts(q
, flags
>> 6, pts
);
634 if (dts
!= AV_NOPTS_VALUE
&& dts
!= pts
) {
635 write_pts(q
, 1, dts
);
638 if (pes_extension
&& st
->codec
->codec_id
== CODEC_ID_DIRAC
) {
639 flags
= 0x01; /* set PES_extension_flag_2 */
641 *q
++ = 0x80 | 0x01; /* marker bit + extension length */
643 * Set the stream id extension flag bit to 0 and
644 * write the extended stream id
648 if (private_code
!= 0)
653 header_len
= q
- buf
;
655 len
= TS_PACKET_SIZE
- header_len
;
656 if (len
> payload_size
)
658 stuffing_len
= TS_PACKET_SIZE
- header_len
- len
;
659 if (stuffing_len
> 0) {
660 /* add stuffing with AFC */
662 /* stuffing already present: increase its size */
663 afc_len
= buf
[4] + 1;
664 memmove(buf
+ 4 + afc_len
+ stuffing_len
,
666 header_len
- (4 + afc_len
));
667 buf
[4] += stuffing_len
;
668 memset(buf
+ 4 + afc_len
, 0xff, stuffing_len
);
671 memmove(buf
+ 4 + stuffing_len
, buf
+ 4, header_len
- 4);
673 buf
[4] = stuffing_len
- 1;
674 if (stuffing_len
>= 2) {
676 memset(buf
+ 6, 0xff, stuffing_len
- 2);
680 memcpy(buf
+ TS_PACKET_SIZE
- len
, payload
, len
);
683 put_buffer(s
->pb
, buf
, TS_PACKET_SIZE
);
684 ts
->cur_pcr
+= TS_PACKET_SIZE
*8*90000LL/ts
->mux_rate
;
686 put_flush_packet(s
->pb
);
689 static int mpegts_write_packet(AVFormatContext
*s
, AVPacket
*pkt
)
691 AVStream
*st
= s
->streams
[pkt
->stream_index
];
693 uint8_t *buf
= pkt
->data
;
695 MpegTSWriteStream
*ts_st
= st
->priv_data
;
696 int len
, max_payload_size
;
697 const uint8_t *access_unit_index
= NULL
;
698 const uint64_t delay
= av_rescale(s
->max_delay
, 90000, AV_TIME_BASE
);
699 int64_t dts
= AV_NOPTS_VALUE
, pts
= AV_NOPTS_VALUE
;
701 if (pkt
->pts
!= AV_NOPTS_VALUE
)
702 pts
= pkt
->pts
+ delay
;
703 if (pkt
->dts
!= AV_NOPTS_VALUE
)
704 dts
= pkt
->dts
+ delay
;
706 if (st
->codec
->codec_type
== CODEC_TYPE_SUBTITLE
) {
707 /* for subtitle, a single PES packet must be generated */
708 mpegts_write_pes(s
, st
, buf
, size
, pts
, AV_NOPTS_VALUE
);
712 if (st
->codec
->codec_id
== CODEC_ID_DIRAC
) {
713 /* for Dirac, a single PES packet must be generated */
714 mpegts_write_pes(s
, st
, buf
, size
, pts
, dts
);
717 max_payload_size
= DEFAULT_PES_PAYLOAD_SIZE
;
718 if (st
->codec
->codec_id
== CODEC_ID_MPEG2VIDEO
||
719 st
->codec
->codec_id
== CODEC_ID_MPEG1VIDEO
) {
720 const uint8_t *p
= pkt
->data
;
721 const uint8_t *end
= pkt
->data
+pkt
->size
;
724 p
= ff_find_start_code(p
, end
, &state
);
725 if (state
== PICTURE_START_CODE
) {
726 access_unit_index
= p
- 4;
730 } if (st
->codec
->codec_id
== CODEC_ID_H264
) {
731 if (pkt
->size
< 5 || AV_RB32(pkt
->data
) != 0x0000001) {
732 av_log(s
, AV_LOG_ERROR
, "h264 bitstream malformated\n");
735 if (pkt
->data
[4] != 0x09) { // AUD NAL
736 data
= av_malloc(pkt
->size
+6);
739 memcpy(data
+6, pkt
->data
, pkt
->size
);
740 AV_WB32(data
, 0x00000001);
742 data
[5] = 0xe0; // any slice type
746 access_unit_index
= buf
;
748 access_unit_index
= pkt
->data
;
751 if (!access_unit_index
) {
752 av_log(s
, AV_LOG_ERROR
, "error, could not find access unit start\n");
757 len
= max_payload_size
- ts_st
->payload_index
;
760 memcpy(ts_st
->payload
+ ts_st
->payload_index
, buf
, len
);
763 ts_st
->payload_index
+= len
;
764 if (access_unit_index
&& access_unit_index
< buf
&&
765 ts_st
->payload_pts
== AV_NOPTS_VALUE
&&
766 ts_st
->payload_dts
== AV_NOPTS_VALUE
) {
767 ts_st
->payload_dts
= dts
;
768 ts_st
->payload_pts
= pts
;
770 if (ts_st
->payload_index
>= max_payload_size
) {
771 mpegts_write_pes(s
, st
, ts_st
->payload
, ts_st
->payload_index
,
772 ts_st
->payload_pts
, ts_st
->payload_dts
);
773 ts_st
->payload_pts
= AV_NOPTS_VALUE
;
774 ts_st
->payload_dts
= AV_NOPTS_VALUE
;
775 ts_st
->payload_index
= 0;
776 access_unit_index
= NULL
; // unset access unit to avoid setting pts/dts again
785 static int mpegts_write_end(AVFormatContext
*s
)
787 MpegTSWrite
*ts
= s
->priv_data
;
788 MpegTSWriteStream
*ts_st
;
789 MpegTSService
*service
;
793 /* flush current packets */
794 for(i
= 0; i
< s
->nb_streams
; i
++) {
796 ts_st
= st
->priv_data
;
797 if (ts_st
->payload_index
> 0) {
798 mpegts_write_pes(s
, st
, ts_st
->payload
, ts_st
->payload_index
,
799 ts_st
->payload_pts
, ts_st
->payload_dts
);
802 put_flush_packet(s
->pb
);
804 for(i
= 0; i
< ts
->nb_services
; i
++) {
805 service
= ts
->services
[i
];
806 av_freep(&service
->provider_name
);
807 av_freep(&service
->name
);
810 av_free(ts
->services
);
815 AVOutputFormat mpegts_muxer
= {
817 NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),