Merge commit '3f7e94eccd1c0d64679f2c4eda8bb942a158dfac'
[ffmpeg.git] / libavformat / mpegtsenc.c
1 /*
2  * MPEG2 transport stream (aka DVB) muxer
3  * Copyright (c) 2003 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
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.
11  *
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.
16  *
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
20  */
21
22 #include "libavutil/bswap.h"
23 #include "libavutil/crc.h"
24 #include "libavutil/dict.h"
25 #include "libavutil/intreadwrite.h"
26 #include "libavutil/mathematics.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/avassert.h"
29 #include "libavcodec/internal.h"
30 #include "avformat.h"
31 #include "internal.h"
32 #include "mpegts.h"
33
34 #define PCR_TIME_BASE 27000000
35
36 /* write DVB SI sections */
37
38 /*********************************************/
39 /* mpegts section writer */
40
41 typedef struct MpegTSSection {
42     int pid;
43     int cc;
44     void (*write_packet)(struct MpegTSSection *s, const uint8_t *packet);
45     void *opaque;
46 } MpegTSSection;
47
48 typedef struct MpegTSService {
49     MpegTSSection pmt; /* MPEG2 pmt table context */
50     int sid;           /* service ID */
51     char *name;
52     char *provider_name;
53     int pcr_pid;
54     int pcr_packet_count;
55     int pcr_packet_period;
56 } MpegTSService;
57
58 typedef struct MpegTSWrite {
59     const AVClass *av_class;
60     MpegTSSection pat; /* MPEG2 pat table */
61     MpegTSSection sdt; /* MPEG2 sdt table context */
62     MpegTSService **services;
63     int sdt_packet_count;
64     int sdt_packet_period;
65     int pat_packet_count;
66     int pat_packet_period;
67     int nb_services;
68     int onid;
69     int tsid;
70     int64_t first_pcr;
71     int mux_rate; ///< set to 1 when VBR
72     int pes_payload_size;
73
74     int transport_stream_id;
75     int original_network_id;
76     int service_id;
77
78     int pmt_start_pid;
79     int start_pid;
80     int m2ts_mode;
81
82     int reemit_pat_pmt; // backward compatibility
83
84 #define MPEGTS_FLAG_REEMIT_PAT_PMT  0x01
85 #define MPEGTS_FLAG_AAC_LATM        0x02
86     int flags;
87     int copyts;
88     int tables_version;
89
90     int omit_video_pes_length;
91 } MpegTSWrite;
92
93 /* a PES packet header is generated every DEFAULT_PES_HEADER_FREQ packets */
94 #define DEFAULT_PES_HEADER_FREQ 16
95 #define DEFAULT_PES_PAYLOAD_SIZE ((DEFAULT_PES_HEADER_FREQ - 1) * 184 + 170)
96
97 /* NOTE: 4 bytes must be left at the end for the crc32 */
98 static void mpegts_write_section(MpegTSSection *s, uint8_t *buf, int len)
99 {
100     unsigned int crc;
101     unsigned char packet[TS_PACKET_SIZE];
102     const unsigned char *buf_ptr;
103     unsigned char *q;
104     int first, b, len1, left;
105
106     crc = av_bswap32(av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1, buf, len - 4));
107     buf[len - 4] = (crc >> 24) & 0xff;
108     buf[len - 3] = (crc >> 16) & 0xff;
109     buf[len - 2] = (crc >> 8) & 0xff;
110     buf[len - 1] = (crc) & 0xff;
111
112     /* send each packet */
113     buf_ptr = buf;
114     while (len > 0) {
115         first = (buf == buf_ptr);
116         q = packet;
117         *q++ = 0x47;
118         b = (s->pid >> 8);
119         if (first)
120             b |= 0x40;
121         *q++ = b;
122         *q++ = s->pid;
123         s->cc = (s->cc + 1) & 0xf;
124         *q++ = 0x10 | s->cc;
125         if (first)
126             *q++ = 0; /* 0 offset */
127         len1 = TS_PACKET_SIZE - (q - packet);
128         if (len1 > len)
129             len1 = len;
130         memcpy(q, buf_ptr, len1);
131         q += len1;
132         /* add known padding data */
133         left = TS_PACKET_SIZE - (q - packet);
134         if (left > 0)
135             memset(q, 0xff, left);
136
137         s->write_packet(s, packet);
138
139         buf_ptr += len1;
140         len -= len1;
141     }
142 }
143
144 static inline void put16(uint8_t **q_ptr, int val)
145 {
146     uint8_t *q;
147     q = *q_ptr;
148     *q++ = val >> 8;
149     *q++ = val;
150     *q_ptr = q;
151 }
152
153 static int mpegts_write_section1(MpegTSSection *s, int tid, int id,
154                           int version, int sec_num, int last_sec_num,
155                           uint8_t *buf, int len)
156 {
157     uint8_t section[1024], *q;
158     unsigned int tot_len;
159     /* reserved_future_use field must be set to 1 for SDT */
160     unsigned int flags = tid == SDT_TID ? 0xf000 : 0xb000;
161
162     tot_len = 3 + 5 + len + 4;
163     /* check if not too big */
164     if (tot_len > 1024)
165         return AVERROR_INVALIDDATA;
166
167     q = section;
168     *q++ = tid;
169     put16(&q, flags | (len + 5 + 4)); /* 5 byte header + 4 byte CRC */
170     put16(&q, id);
171     *q++ = 0xc1 | (version << 1); /* current_next_indicator = 1 */
172     *q++ = sec_num;
173     *q++ = last_sec_num;
174     memcpy(q, buf, len);
175
176     mpegts_write_section(s, section, tot_len);
177     return 0;
178 }
179
180 /*********************************************/
181 /* mpegts writer */
182
183 #define DEFAULT_PROVIDER_NAME   "FFmpeg"
184 #define DEFAULT_SERVICE_NAME    "Service01"
185
186 /* we retransmit the SI info at this rate */
187 #define SDT_RETRANS_TIME 500
188 #define PAT_RETRANS_TIME 100
189 #define PCR_RETRANS_TIME 20
190
191 typedef struct MpegTSWriteStream {
192     struct MpegTSService *service;
193     int pid; /* stream associated pid */
194     int cc;
195     int payload_size;
196     int first_pts_check; ///< first pts check needed
197     int prev_payload_key;
198     int64_t payload_pts;
199     int64_t payload_dts;
200     int payload_flags;
201     uint8_t *payload;
202     AVFormatContext *amux;
203 } MpegTSWriteStream;
204
205 static void mpegts_write_pat(AVFormatContext *s)
206 {
207     MpegTSWrite *ts = s->priv_data;
208     MpegTSService *service;
209     uint8_t data[1012], *q;
210     int i;
211
212     q = data;
213     for(i = 0; i < ts->nb_services; i++) {
214         service = ts->services[i];
215         put16(&q, service->sid);
216         put16(&q, 0xe000 | service->pmt.pid);
217     }
218     mpegts_write_section1(&ts->pat, PAT_TID, ts->tsid, ts->tables_version, 0, 0,
219                           data, q - data);
220 }
221
222 static int mpegts_write_pmt(AVFormatContext *s, MpegTSService *service)
223 {
224     MpegTSWrite *ts = s->priv_data;
225     uint8_t data[1012], *q, *desc_length_ptr, *program_info_length_ptr;
226     int val, stream_type, i;
227
228     q = data;
229     put16(&q, 0xe000 | service->pcr_pid);
230
231     program_info_length_ptr = q;
232     q += 2; /* patched after */
233
234     /* put program info here */
235
236     val = 0xf000 | (q - program_info_length_ptr - 2);
237     program_info_length_ptr[0] = val >> 8;
238     program_info_length_ptr[1] = val;
239
240     for(i = 0; i < s->nb_streams; i++) {
241         AVStream *st = s->streams[i];
242         MpegTSWriteStream *ts_st = st->priv_data;
243         AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL,0);
244         switch(st->codec->codec_id) {
245         case AV_CODEC_ID_MPEG1VIDEO:
246         case AV_CODEC_ID_MPEG2VIDEO:
247             stream_type = STREAM_TYPE_VIDEO_MPEG2;
248             break;
249         case AV_CODEC_ID_MPEG4:
250             stream_type = STREAM_TYPE_VIDEO_MPEG4;
251             break;
252         case AV_CODEC_ID_H264:
253             stream_type = STREAM_TYPE_VIDEO_H264;
254             break;
255         case AV_CODEC_ID_HEVC:
256             stream_type = STREAM_TYPE_VIDEO_HEVC;
257             break;
258         case AV_CODEC_ID_CAVS:
259             stream_type = STREAM_TYPE_VIDEO_CAVS;
260             break;
261         case AV_CODEC_ID_DIRAC:
262             stream_type = STREAM_TYPE_VIDEO_DIRAC;
263             break;
264         case AV_CODEC_ID_MP2:
265         case AV_CODEC_ID_MP3:
266             stream_type = STREAM_TYPE_AUDIO_MPEG1;
267             break;
268         case AV_CODEC_ID_AAC:
269             stream_type = (ts->flags & MPEGTS_FLAG_AAC_LATM) ? STREAM_TYPE_AUDIO_AAC_LATM : STREAM_TYPE_AUDIO_AAC;
270             break;
271         case AV_CODEC_ID_AAC_LATM:
272             stream_type = STREAM_TYPE_AUDIO_AAC_LATM;
273             break;
274         case AV_CODEC_ID_AC3:
275             stream_type = STREAM_TYPE_AUDIO_AC3;
276             break;
277         case AV_CODEC_ID_DTS:
278             stream_type = STREAM_TYPE_AUDIO_DTS;
279             break;
280         case AV_CODEC_ID_TRUEHD:
281             stream_type = STREAM_TYPE_AUDIO_TRUEHD;
282             break;
283         default:
284             stream_type = STREAM_TYPE_PRIVATE_DATA;
285             break;
286         }
287
288         if (q - data > sizeof(data) - 32)
289             return AVERROR(EINVAL);
290
291         *q++ = stream_type;
292         put16(&q, 0xe000 | ts_st->pid);
293         desc_length_ptr = q;
294         q += 2; /* patched after */
295
296         /* write optional descriptors here */
297         switch(st->codec->codec_type) {
298         case AVMEDIA_TYPE_AUDIO:
299             if(st->codec->codec_id==AV_CODEC_ID_EAC3){
300                 *q++=0x7a; // EAC3 descriptor see A038 DVB SI
301                 *q++=1; // 1 byte, all flags sets to 0
302                 *q++=0; // omit all fields...
303             }
304             if(st->codec->codec_id==AV_CODEC_ID_S302M){
305                 *q++ = 0x05; /* MPEG-2 registration descriptor*/
306                 *q++ = 4;
307                 *q++ = 'B';
308                 *q++ = 'S';
309                 *q++ = 'S';
310                 *q++ = 'D';
311             }
312
313             if (lang) {
314                 char *p;
315                 char *next = lang->value;
316                 uint8_t *len_ptr;
317
318                 *q++ = 0x0a; /* ISO 639 language descriptor */
319                 len_ptr = q++;
320                 *len_ptr = 0;
321
322                 for (p = lang->value; next && *len_ptr < 255 / 4 * 4 && q - data < sizeof(data) - 4; p = next + 1) {
323                     next = strchr(p, ',');
324                     if (strlen(p) != 3 && (!next || next != p + 3))
325                         continue; /* not a 3-letter code */
326
327                     *q++ = *p++;
328                     *q++ = *p++;
329                     *q++ = *p++;
330
331                 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
332                     *q++ = 0x01;
333                 else if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
334                     *q++ = 0x02;
335                 else if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
336                     *q++ = 0x03;
337                 else
338                     *q++ = 0; /* undefined type */
339
340                     *len_ptr += 4;
341                 }
342
343                 if (*len_ptr == 0)
344                     q -= 2; /* no language codes were written */
345             }
346             break;
347         case AVMEDIA_TYPE_SUBTITLE:
348             {
349                 const char default_language[] = "und";
350                 const char *language = lang && strlen(lang->value) >= 3 ? lang->value : default_language;
351
352                 if (st->codec->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
353                     uint8_t *len_ptr;
354                     int extradata_copied = 0;
355
356                     *q++ = 0x59; /* subtitling_descriptor */
357                     len_ptr = q++;
358
359                     while (strlen(language) >= 3 && (sizeof(data) - (q - data)) >= 8) { /* 8 bytes per DVB subtitle substream data */
360                         *q++ = *language++;
361                         *q++ = *language++;
362                         *q++ = *language++;
363                         /* Skip comma */
364                         if (*language != '\0')
365                             language++;
366
367                         if (st->codec->extradata_size - extradata_copied >= 5) {
368                             *q++ = st->codec->extradata[extradata_copied + 4]; /* subtitling_type */
369                             memcpy(q, st->codec->extradata + extradata_copied, 4); /* composition_page_id and ancillary_page_id */
370                             extradata_copied += 5;
371                             q += 4;
372                         } else {
373                             /* subtitling_type:
374                              * 0x10 - normal with no monitor aspect ratio criticality
375                              * 0x20 - for the hard of hearing with no monitor aspect ratio criticality */
376                             *q++ = (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED) ? 0x20 : 0x10;
377                             if ((st->codec->extradata_size == 4) && (extradata_copied == 0)) {
378                                 /* support of old 4-byte extradata format */
379                                 memcpy(q, st->codec->extradata, 4); /* composition_page_id and ancillary_page_id */
380                                 extradata_copied += 4;
381                                 q += 4;
382                             } else {
383                                 put16(&q, 1); /* composition_page_id */
384                                 put16(&q, 1); /* ancillary_page_id */
385                             }
386                         }
387                     }
388
389                     *len_ptr = q - len_ptr - 1;
390                 } else if (st->codec->codec_id == AV_CODEC_ID_DVB_TELETEXT) {
391                     uint8_t *len_ptr = NULL;
392                     int extradata_copied = 0;
393
394                     /* The descriptor tag. teletext_descriptor */
395                     *q++ = 0x56;
396                     len_ptr = q++;
397
398                     while (strlen(language) >= 3 && q - data < sizeof(data) - 6) {
399                         *q++ = *language++;
400                         *q++ = *language++;
401                         *q++ = *language++;
402                         /* Skip comma */
403                         if (*language != '\0')
404                             language++;
405
406                         if (st->codec->extradata_size - 1 > extradata_copied) {
407                             memcpy(q, st->codec->extradata + extradata_copied, 2);
408                             extradata_copied += 2;
409                             q += 2;
410                         } else {
411                             /* The Teletext descriptor:
412                              * teletext_type: This 5-bit field indicates the type of Teletext page indicated. (0x01 Initial Teletext page)
413                              * teletext_magazine_number: This is a 3-bit field which identifies the magazine number.
414                              * teletext_page_number: This is an 8-bit field giving two 4-bit hex digits identifying the page number. */
415                             *q++ = 0x08;
416                             *q++ = 0x00;
417                         }
418                     }
419
420                     *len_ptr = q - len_ptr - 1;
421                  }
422             }
423             break;
424         case AVMEDIA_TYPE_VIDEO:
425             if (stream_type == STREAM_TYPE_VIDEO_DIRAC) {
426                 *q++ = 0x05; /*MPEG-2 registration descriptor*/
427                 *q++ = 4;
428                 *q++ = 'd';
429                 *q++ = 'r';
430                 *q++ = 'a';
431                 *q++ = 'c';
432             }
433             break;
434         case AVMEDIA_TYPE_DATA:
435             if (st->codec->codec_id == AV_CODEC_ID_SMPTE_KLV) {
436                 *q++ = 0x05; /* MPEG-2 registration descriptor */
437                 *q++ = 4;
438                 *q++ = 'K';
439                 *q++ = 'L';
440                 *q++ = 'V';
441                 *q++ = 'A';
442             }
443             break;
444         }
445
446         val = 0xf000 | (q - desc_length_ptr - 2);
447         desc_length_ptr[0] = val >> 8;
448         desc_length_ptr[1] = val;
449     }
450     mpegts_write_section1(&service->pmt, PMT_TID, service->sid, ts->tables_version, 0, 0,
451                           data, q - data);
452     return 0;
453 }
454
455 /* NOTE: str == NULL is accepted for an empty string */
456 static void putstr8(uint8_t **q_ptr, const char *str)
457 {
458     uint8_t *q;
459     int len;
460
461     q = *q_ptr;
462     if (!str)
463         len = 0;
464     else
465         len = strlen(str);
466     *q++ = len;
467     memcpy(q, str, len);
468     q += len;
469     *q_ptr = q;
470 }
471
472 static void mpegts_write_sdt(AVFormatContext *s)
473 {
474     MpegTSWrite *ts = s->priv_data;
475     MpegTSService *service;
476     uint8_t data[1012], *q, *desc_list_len_ptr, *desc_len_ptr;
477     int i, running_status, free_ca_mode, val;
478
479     q = data;
480     put16(&q, ts->onid);
481     *q++ = 0xff;
482     for(i = 0; i < ts->nb_services; i++) {
483         service = ts->services[i];
484         put16(&q, service->sid);
485         *q++ = 0xfc | 0x00; /* currently no EIT info */
486         desc_list_len_ptr = q;
487         q += 2;
488         running_status = 4; /* running */
489         free_ca_mode = 0;
490
491         /* write only one descriptor for the service name and provider */
492         *q++ = 0x48;
493         desc_len_ptr = q;
494         q++;
495         *q++ = 0x01; /* digital television service */
496         putstr8(&q, service->provider_name);
497         putstr8(&q, service->name);
498         desc_len_ptr[0] = q - desc_len_ptr - 1;
499
500         /* fill descriptor length */
501         val = (running_status << 13) | (free_ca_mode << 12) |
502             (q - desc_list_len_ptr - 2);
503         desc_list_len_ptr[0] = val >> 8;
504         desc_list_len_ptr[1] = val;
505     }
506     mpegts_write_section1(&ts->sdt, SDT_TID, ts->tsid, ts->tables_version, 0, 0,
507                           data, q - data);
508 }
509
510 static MpegTSService *mpegts_add_service(MpegTSWrite *ts,
511                                          int sid,
512                                          const char *provider_name,
513                                          const char *name)
514 {
515     MpegTSService *service;
516
517     service = av_mallocz(sizeof(MpegTSService));
518     if (!service)
519         return NULL;
520     service->pmt.pid = ts->pmt_start_pid + ts->nb_services;
521     service->sid = sid;
522     service->provider_name = av_strdup(provider_name);
523     service->name = av_strdup(name);
524     service->pcr_pid = 0x1fff;
525     dynarray_add(&ts->services, &ts->nb_services, service);
526     return service;
527 }
528
529 static int64_t get_pcr(const MpegTSWrite *ts, AVIOContext *pb)
530 {
531     return av_rescale(avio_tell(pb) + 11, 8 * PCR_TIME_BASE, ts->mux_rate) +
532            ts->first_pcr;
533 }
534
535 static void mpegts_prefix_m2ts_header(AVFormatContext *s)
536 {
537     MpegTSWrite *ts = s->priv_data;
538     if (ts->m2ts_mode) {
539         int64_t pcr = get_pcr(s->priv_data, s->pb);
540         uint32_t tp_extra_header = pcr % 0x3fffffff;
541         tp_extra_header = AV_RB32(&tp_extra_header);
542         avio_write(s->pb, (unsigned char *) &tp_extra_header,
543                 sizeof(tp_extra_header));
544     }
545 }
546
547 static void section_write_packet(MpegTSSection *s, const uint8_t *packet)
548 {
549     AVFormatContext *ctx = s->opaque;
550     mpegts_prefix_m2ts_header(ctx);
551     avio_write(ctx->pb, packet, TS_PACKET_SIZE);
552 }
553
554 static int mpegts_write_header(AVFormatContext *s)
555 {
556     MpegTSWrite *ts = s->priv_data;
557     MpegTSWriteStream *ts_st;
558     MpegTSService *service;
559     AVStream *st, *pcr_st = NULL;
560     AVDictionaryEntry *title, *provider;
561     int i, j;
562     const char *service_name;
563     const char *provider_name;
564     int *pids;
565     int ret;
566
567     if (s->max_delay < 0) /* Not set by the caller */
568         s->max_delay = 0;
569
570     // round up to a whole number of TS packets
571     ts->pes_payload_size = (ts->pes_payload_size + 14 + 183) / 184 * 184 - 14;
572
573     ts->tsid = ts->transport_stream_id;
574     ts->onid = ts->original_network_id;
575     /* allocate a single DVB service */
576     title = av_dict_get(s->metadata, "service_name", NULL, 0);
577     if (!title)
578         title = av_dict_get(s->metadata, "title", NULL, 0);
579     service_name = title ? title->value : DEFAULT_SERVICE_NAME;
580     provider = av_dict_get(s->metadata, "service_provider", NULL, 0);
581     provider_name = provider ? provider->value : DEFAULT_PROVIDER_NAME;
582     service = mpegts_add_service(ts, ts->service_id, provider_name, service_name);
583     service->pmt.write_packet = section_write_packet;
584     service->pmt.opaque = s;
585     service->pmt.cc = 15;
586
587     ts->pat.pid = PAT_PID;
588     ts->pat.cc = 15; // Initialize at 15 so that it wraps and be equal to 0 for the first packet we write
589     ts->pat.write_packet = section_write_packet;
590     ts->pat.opaque = s;
591
592     ts->sdt.pid = SDT_PID;
593     ts->sdt.cc = 15;
594     ts->sdt.write_packet = section_write_packet;
595     ts->sdt.opaque = s;
596
597     pids = av_malloc_array(s->nb_streams, sizeof(*pids));
598     if (!pids)
599         return AVERROR(ENOMEM);
600
601     /* assign pids to each stream */
602     for(i = 0;i < s->nb_streams; i++) {
603         st = s->streams[i];
604         avpriv_set_pts_info(st, 33, 1, 90000);
605         ts_st = av_mallocz(sizeof(MpegTSWriteStream));
606         if (!ts_st) {
607             ret = AVERROR(ENOMEM);
608             goto fail;
609         }
610         st->priv_data = ts_st;
611         ts_st->payload = av_mallocz(ts->pes_payload_size);
612         if (!ts_st->payload) {
613             ret = AVERROR(ENOMEM);
614             goto fail;
615         }
616         ts_st->service = service;
617         /* MPEG pid values < 16 are reserved. Applications which set st->id in
618          * this range are assigned a calculated pid. */
619         if (st->id < 16) {
620             ts_st->pid = ts->start_pid + i;
621         } else if (st->id < 0x1FFF) {
622             ts_st->pid = st->id;
623         } else {
624             av_log(s, AV_LOG_ERROR, "Invalid stream id %d, must be less than 8191\n", st->id);
625             ret = AVERROR(EINVAL);
626             goto fail;
627         }
628         if (ts_st->pid == service->pmt.pid) {
629             av_log(s, AV_LOG_ERROR, "Duplicate stream id %d\n", ts_st->pid);
630             ret = AVERROR(EINVAL);
631             goto fail;
632         }
633         for (j = 0; j < i; j++)
634             if (pids[j] == ts_st->pid) {
635                 av_log(s, AV_LOG_ERROR, "Duplicate stream id %d\n", ts_st->pid);
636                 ret = AVERROR(EINVAL);
637                 goto fail;
638             }
639         pids[i] = ts_st->pid;
640         ts_st->payload_pts = AV_NOPTS_VALUE;
641         ts_st->payload_dts = AV_NOPTS_VALUE;
642         ts_st->first_pts_check = 1;
643         ts_st->cc = 15;
644         /* update PCR pid by using the first video stream */
645         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
646             service->pcr_pid == 0x1fff) {
647             service->pcr_pid = ts_st->pid;
648             pcr_st = st;
649         }
650         if (st->codec->codec_id == AV_CODEC_ID_AAC &&
651             st->codec->extradata_size > 0)
652         {
653             AVStream *ast;
654             ts_st->amux = avformat_alloc_context();
655             if (!ts_st->amux) {
656                 ret = AVERROR(ENOMEM);
657                 goto fail;
658             }
659             ts_st->amux->oformat = av_guess_format((ts->flags & MPEGTS_FLAG_AAC_LATM) ? "latm" : "adts", NULL, NULL);
660             if (!ts_st->amux->oformat) {
661                 ret = AVERROR(EINVAL);
662                 goto fail;
663             }
664             ast = avformat_new_stream(ts_st->amux, NULL);
665             if (!ast) {
666                 ret = AVERROR(ENOMEM);
667                 goto fail;
668             }
669             ret = avcodec_copy_context(ast->codec, st->codec);
670             if (ret != 0)
671                 goto fail;
672             ret = avformat_write_header(ts_st->amux, NULL);
673             if (ret < 0)
674                 goto fail;
675         }
676     }
677
678     av_free(pids);
679
680     /* if no video stream, use the first stream as PCR */
681     if (service->pcr_pid == 0x1fff && s->nb_streams > 0) {
682         pcr_st = s->streams[0];
683         ts_st = pcr_st->priv_data;
684         service->pcr_pid = ts_st->pid;
685     }
686
687     if (ts->mux_rate > 1) {
688         service->pcr_packet_period = (ts->mux_rate * PCR_RETRANS_TIME) /
689             (TS_PACKET_SIZE * 8 * 1000);
690         ts->sdt_packet_period      = (ts->mux_rate * SDT_RETRANS_TIME) /
691             (TS_PACKET_SIZE * 8 * 1000);
692         ts->pat_packet_period      = (ts->mux_rate * PAT_RETRANS_TIME) /
693             (TS_PACKET_SIZE * 8 * 1000);
694
695         if(ts->copyts < 1)
696             ts->first_pcr = av_rescale(s->max_delay, PCR_TIME_BASE, AV_TIME_BASE);
697     } else {
698         /* Arbitrary values, PAT/PMT will also be written on video key frames */
699         ts->sdt_packet_period = 200;
700         ts->pat_packet_period = 40;
701         if (pcr_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
702             if (!pcr_st->codec->frame_size) {
703                 av_log(s, AV_LOG_WARNING, "frame size not set\n");
704                 service->pcr_packet_period =
705                     pcr_st->codec->sample_rate/(10*512);
706             } else {
707                 service->pcr_packet_period =
708                     pcr_st->codec->sample_rate/(10*pcr_st->codec->frame_size);
709             }
710         } else {
711             // max delta PCR 0.1s
712             service->pcr_packet_period =
713                 pcr_st->codec->time_base.den/(10*pcr_st->codec->time_base.num);
714         }
715         if(!service->pcr_packet_period)
716             service->pcr_packet_period = 1;
717     }
718
719     // output a PCR as soon as possible
720     service->pcr_packet_count = service->pcr_packet_period;
721     ts->pat_packet_count = ts->pat_packet_period-1;
722     ts->sdt_packet_count = ts->sdt_packet_period-1;
723
724     if (ts->mux_rate == 1)
725         av_log(s, AV_LOG_VERBOSE, "muxrate VBR, ");
726     else
727         av_log(s, AV_LOG_VERBOSE, "muxrate %d, ", ts->mux_rate);
728     av_log(s, AV_LOG_VERBOSE, "pcr every %d pkts, "
729            "sdt every %d, pat/pmt every %d pkts\n",
730            service->pcr_packet_period,
731            ts->sdt_packet_period, ts->pat_packet_period);
732
733     if (ts->m2ts_mode == -1) {
734         if (av_match_ext(s->filename, "m2ts")) {
735             ts->m2ts_mode = 1;
736         } else {
737             ts->m2ts_mode = 0;
738         }
739     }
740
741     avio_flush(s->pb);
742
743     return 0;
744
745  fail:
746     av_free(pids);
747     for(i = 0;i < s->nb_streams; i++) {
748         MpegTSWriteStream *ts_st;
749         st = s->streams[i];
750         ts_st = st->priv_data;
751         if (ts_st) {
752             av_freep(&ts_st->payload);
753             if (ts_st->amux) {
754                 avformat_free_context(ts_st->amux);
755                 ts_st->amux = NULL;
756             }
757         }
758         av_freep(&st->priv_data);
759     }
760     return ret;
761 }
762
763 /* send SDT, PAT and PMT tables regulary */
764 static void retransmit_si_info(AVFormatContext *s, int force_pat)
765 {
766     MpegTSWrite *ts = s->priv_data;
767     int i;
768
769     if (++ts->sdt_packet_count == ts->sdt_packet_period) {
770         ts->sdt_packet_count = 0;
771         mpegts_write_sdt(s);
772     }
773     if (++ts->pat_packet_count == ts->pat_packet_period || force_pat) {
774         ts->pat_packet_count = 0;
775         mpegts_write_pat(s);
776         for(i = 0; i < ts->nb_services; i++) {
777             mpegts_write_pmt(s, ts->services[i]);
778         }
779     }
780 }
781
782 static int write_pcr_bits(uint8_t *buf, int64_t pcr)
783 {
784     int64_t pcr_low = pcr % 300, pcr_high = pcr / 300;
785
786     *buf++ = pcr_high >> 25;
787     *buf++ = pcr_high >> 17;
788     *buf++ = pcr_high >> 9;
789     *buf++ = pcr_high >> 1;
790     *buf++ = pcr_high << 7 | pcr_low >> 8 | 0x7e;
791     *buf++ = pcr_low;
792
793     return 6;
794 }
795
796 /* Write a single null transport stream packet */
797 static void mpegts_insert_null_packet(AVFormatContext *s)
798 {
799     uint8_t *q;
800     uint8_t buf[TS_PACKET_SIZE];
801
802     q = buf;
803     *q++ = 0x47;
804     *q++ = 0x00 | 0x1f;
805     *q++ = 0xff;
806     *q++ = 0x10;
807     memset(q, 0x0FF, TS_PACKET_SIZE - (q - buf));
808     mpegts_prefix_m2ts_header(s);
809     avio_write(s->pb, buf, TS_PACKET_SIZE);
810 }
811
812 /* Write a single transport stream packet with a PCR and no payload */
813 static void mpegts_insert_pcr_only(AVFormatContext *s, AVStream *st)
814 {
815     MpegTSWrite *ts = s->priv_data;
816     MpegTSWriteStream *ts_st = st->priv_data;
817     uint8_t *q;
818     uint8_t buf[TS_PACKET_SIZE];
819
820     q = buf;
821     *q++ = 0x47;
822     *q++ = ts_st->pid >> 8;
823     *q++ = ts_st->pid;
824     *q++ = 0x20 | ts_st->cc;   /* Adaptation only */
825     /* Continuity Count field does not increment (see 13818-1 section 2.4.3.3) */
826     *q++ = TS_PACKET_SIZE - 5; /* Adaptation Field Length */
827     *q++ = 0x10;               /* Adaptation flags: PCR present */
828
829     /* PCR coded into 6 bytes */
830     q += write_pcr_bits(q, get_pcr(ts, s->pb));
831
832     /* stuffing bytes */
833     memset(q, 0xFF, TS_PACKET_SIZE - (q - buf));
834     mpegts_prefix_m2ts_header(s);
835     avio_write(s->pb, buf, TS_PACKET_SIZE);
836 }
837
838 static void write_pts(uint8_t *q, int fourbits, int64_t pts)
839 {
840     int val;
841
842     val = fourbits << 4 | (((pts >> 30) & 0x07) << 1) | 1;
843     *q++ = val;
844     val = (((pts >> 15) & 0x7fff) << 1) | 1;
845     *q++ = val >> 8;
846     *q++ = val;
847     val = (((pts) & 0x7fff) << 1) | 1;
848     *q++ = val >> 8;
849     *q++ = val;
850 }
851
852 /* Set an adaptation field flag in an MPEG-TS packet*/
853 static void set_af_flag(uint8_t *pkt, int flag)
854 {
855     // expect at least one flag to set
856     av_assert0(flag);
857
858     if ((pkt[3] & 0x20) == 0) {
859         // no AF yet, set adaptation field flag
860         pkt[3] |= 0x20;
861         // 1 byte length, no flags
862         pkt[4] = 1;
863         pkt[5] = 0;
864     }
865     pkt[5] |= flag;
866 }
867
868 /* Extend the adaptation field by size bytes */
869 static void extend_af(uint8_t *pkt, int size)
870 {
871     // expect already existing adaptation field
872     av_assert0(pkt[3] & 0x20);
873     pkt[4] += size;
874 }
875
876 /* Get a pointer to MPEG-TS payload (right after TS packet header) */
877 static uint8_t *get_ts_payload_start(uint8_t *pkt)
878 {
879     if (pkt[3] & 0x20)
880         return pkt + 5 + pkt[4];
881     else
882         return pkt + 4;
883 }
884
885 /* Add a pes header to the front of payload, and segment into an integer number of
886  * ts packets. The final ts packet is padded using an over-sized adaptation header
887  * to exactly fill the last ts packet.
888  * NOTE: 'payload' contains a complete PES payload.
889  */
890 static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
891                              const uint8_t *payload, int payload_size,
892                              int64_t pts, int64_t dts, int key)
893 {
894     MpegTSWriteStream *ts_st = st->priv_data;
895     MpegTSWrite *ts = s->priv_data;
896     uint8_t buf[TS_PACKET_SIZE];
897     uint8_t *q;
898     int val, is_start, len, header_len, write_pcr, is_dvb_subtitle, is_dvb_teletext, flags;
899     int afc_len, stuffing_len;
900     int64_t pcr = -1; /* avoid warning */
901     int64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE);
902     int force_pat = st->codec->codec_type == AVMEDIA_TYPE_VIDEO && key && !ts_st->prev_payload_key;
903
904     is_start = 1;
905     while (payload_size > 0) {
906         retransmit_si_info(s, force_pat);
907         force_pat = 0;
908
909         write_pcr = 0;
910         if (ts_st->pid == ts_st->service->pcr_pid) {
911             if (ts->mux_rate > 1 || is_start) // VBR pcr period is based on frames
912                 ts_st->service->pcr_packet_count++;
913             if (ts_st->service->pcr_packet_count >=
914                 ts_st->service->pcr_packet_period) {
915                 ts_st->service->pcr_packet_count = 0;
916                 write_pcr = 1;
917             }
918         }
919
920         if (ts->mux_rate > 1 && dts != AV_NOPTS_VALUE &&
921             (dts - get_pcr(ts, s->pb)/300) > delay) {
922             /* pcr insert gets priority over null packet insert */
923             if (write_pcr)
924                 mpegts_insert_pcr_only(s, st);
925             else
926                 mpegts_insert_null_packet(s);
927             continue; /* recalculate write_pcr and possibly retransmit si_info */
928         }
929
930         /* prepare packet header */
931         q = buf;
932         *q++ = 0x47;
933         val = (ts_st->pid >> 8);
934         if (is_start)
935             val |= 0x40;
936         *q++ = val;
937         *q++ = ts_st->pid;
938         ts_st->cc = (ts_st->cc + 1) & 0xf;
939         *q++ = 0x10 | ts_st->cc; // payload indicator + CC
940         if (key && is_start && pts != AV_NOPTS_VALUE) {
941             // set Random Access for key frames
942             if (ts_st->pid == ts_st->service->pcr_pid)
943                 write_pcr = 1;
944             set_af_flag(buf, 0x40);
945             q = get_ts_payload_start(buf);
946         }
947         if (write_pcr) {
948             set_af_flag(buf, 0x10);
949             q = get_ts_payload_start(buf);
950             // add 11, pcr references the last byte of program clock reference base
951             if (ts->mux_rate > 1)
952                 pcr = get_pcr(ts, s->pb);
953             else
954                 pcr = (dts - delay)*300;
955             if (dts != AV_NOPTS_VALUE && dts < pcr / 300)
956                 av_log(s, AV_LOG_WARNING, "dts < pcr, TS is invalid\n");
957             extend_af(buf, write_pcr_bits(q, pcr));
958             q = get_ts_payload_start(buf);
959         }
960         if (is_start) {
961             int pes_extension = 0;
962             int pes_header_stuffing_bytes = 0;
963             /* write PES header */
964             *q++ = 0x00;
965             *q++ = 0x00;
966             *q++ = 0x01;
967             is_dvb_subtitle = 0;
968             is_dvb_teletext = 0;
969             if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
970                 if (st->codec->codec_id == AV_CODEC_ID_DIRAC) {
971                     *q++ = 0xfd;
972                 } else
973                     *q++ = 0xe0;
974             } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
975                        (st->codec->codec_id == AV_CODEC_ID_MP2 ||
976                         st->codec->codec_id == AV_CODEC_ID_MP3 ||
977                         st->codec->codec_id == AV_CODEC_ID_AAC)) {
978                 *q++ = 0xc0;
979             } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
980                         st->codec->codec_id == AV_CODEC_ID_AC3 &&
981                         ts->m2ts_mode) {
982                 *q++ = 0xfd;
983             } else {
984                 *q++ = 0xbd;
985                 if(st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
986                     if (st->codec->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
987                         is_dvb_subtitle = 1;
988                     } else if (st->codec->codec_id == AV_CODEC_ID_DVB_TELETEXT) {
989                         is_dvb_teletext = 1;
990                     }
991                 }
992             }
993             header_len = 0;
994             flags = 0;
995             if (pts != AV_NOPTS_VALUE) {
996                 header_len += 5;
997                 flags |= 0x80;
998             }
999             if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
1000                 header_len += 5;
1001                 flags |= 0x40;
1002             }
1003             if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1004                 st->codec->codec_id == AV_CODEC_ID_DIRAC) {
1005                 /* set PES_extension_flag */
1006                 pes_extension = 1;
1007                 flags |= 0x01;
1008
1009                 /*
1010                 * One byte for PES2 extension flag +
1011                 * one byte for extension length +
1012                 * one byte for extension id
1013                 */
1014                 header_len += 3;
1015             }
1016             /* for Blu-ray AC3 Audio the PES Extension flag should be as follow
1017              * otherwise it will not play sound on blu-ray
1018              */
1019             if (ts->m2ts_mode &&
1020                 st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1021                 st->codec->codec_id == AV_CODEC_ID_AC3) {
1022                         /* set PES_extension_flag */
1023                         pes_extension = 1;
1024                         flags |= 0x01;
1025                         header_len += 3;
1026             }
1027             if (is_dvb_teletext) {
1028                 pes_header_stuffing_bytes = 0x24 - header_len;
1029                 header_len = 0x24;
1030             }
1031             len = payload_size + header_len + 3;
1032             /* 3 extra bytes should be added to DVB subtitle payload: 0x20 0x00 at the beginning and trailing 0xff */
1033             if (is_dvb_subtitle) {
1034                 len += 3;
1035                 payload_size++;
1036             }
1037             if (len > 0xffff)
1038                 len = 0;
1039             if (ts->omit_video_pes_length && st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1040                 len = 0;
1041             }
1042             *q++ = len >> 8;
1043             *q++ = len;
1044             val = 0x80;
1045             /* data alignment indicator is required for subtitle and data streams */
1046             if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA)
1047                 val |= 0x04;
1048             *q++ = val;
1049             *q++ = flags;
1050             *q++ = header_len;
1051             if (pts != AV_NOPTS_VALUE) {
1052                 write_pts(q, flags >> 6, pts);
1053                 q += 5;
1054             }
1055             if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
1056                 write_pts(q, 1, dts);
1057                 q += 5;
1058             }
1059             if (pes_extension && st->codec->codec_id == AV_CODEC_ID_DIRAC) {
1060                 flags = 0x01;  /* set PES_extension_flag_2 */
1061                 *q++ = flags;
1062                 *q++ = 0x80 | 0x01;  /* marker bit + extension length */
1063                 /*
1064                 * Set the stream id extension flag bit to 0 and
1065                 * write the extended stream id
1066                 */
1067                 *q++ = 0x00 | 0x60;
1068             }
1069             /* For Blu-ray AC3 Audio Setting extended flags */
1070           if (ts->m2ts_mode &&
1071               pes_extension &&
1072               st->codec->codec_id == AV_CODEC_ID_AC3) {
1073                       flags = 0x01; /* set PES_extension_flag_2 */
1074                       *q++ = flags;
1075                       *q++ = 0x80 | 0x01; /* marker bit + extension length */
1076                       *q++ = 0x00 | 0x71; /* for AC3 Audio (specifically on blue-rays) */
1077               }
1078
1079
1080             if (is_dvb_subtitle) {
1081                 /* First two fields of DVB subtitles PES data:
1082                  * data_identifier: for DVB subtitle streams shall be coded with the value 0x20
1083                  * subtitle_stream_id: for DVB subtitle stream shall be identified by the value 0x00 */
1084                 *q++ = 0x20;
1085                 *q++ = 0x00;
1086             }
1087             if (is_dvb_teletext) {
1088                 memset(q, 0xff, pes_header_stuffing_bytes);
1089                 q += pes_header_stuffing_bytes;
1090             }
1091             is_start = 0;
1092         }
1093         /* header size */
1094         header_len = q - buf;
1095         /* data len */
1096         len = TS_PACKET_SIZE - header_len;
1097         if (len > payload_size)
1098             len = payload_size;
1099         stuffing_len = TS_PACKET_SIZE - header_len - len;
1100         if (stuffing_len > 0) {
1101             /* add stuffing with AFC */
1102             if (buf[3] & 0x20) {
1103                 /* stuffing already present: increase its size */
1104                 afc_len = buf[4] + 1;
1105                 memmove(buf + 4 + afc_len + stuffing_len,
1106                         buf + 4 + afc_len,
1107                         header_len - (4 + afc_len));
1108                 buf[4] += stuffing_len;
1109                 memset(buf + 4 + afc_len, 0xff, stuffing_len);
1110             } else {
1111                 /* add stuffing */
1112                 memmove(buf + 4 + stuffing_len, buf + 4, header_len - 4);
1113                 buf[3] |= 0x20;
1114                 buf[4] = stuffing_len - 1;
1115                 if (stuffing_len >= 2) {
1116                     buf[5] = 0x00;
1117                     memset(buf + 6, 0xff, stuffing_len - 2);
1118                 }
1119             }
1120         }
1121
1122         if (is_dvb_subtitle && payload_size == len) {
1123             memcpy(buf + TS_PACKET_SIZE - len, payload, len - 1);
1124             buf[TS_PACKET_SIZE - 1] = 0xff; /* end_of_PES_data_field_marker: an 8-bit field with fixed contents 0xff for DVB subtitle */
1125         } else {
1126             memcpy(buf + TS_PACKET_SIZE - len, payload, len);
1127         }
1128
1129         payload += len;
1130         payload_size -= len;
1131         mpegts_prefix_m2ts_header(s);
1132         avio_write(s->pb, buf, TS_PACKET_SIZE);
1133     }
1134     avio_flush(s->pb);
1135     ts_st->prev_payload_key = key;
1136 }
1137
1138 int ff_check_h264_startcode(AVFormatContext *s, const AVStream *st, const AVPacket *pkt)
1139 {
1140     if (pkt->size < 5 || AV_RB32(pkt->data) != 0x0000001) {
1141         if (!st->nb_frames) {
1142             av_log(s, AV_LOG_ERROR, "H.264 bitstream malformed, "
1143                    "no startcode found, use the h264_mp4toannexb bitstream filter (-bsf h264_mp4toannexb)\n");
1144             return AVERROR(EINVAL);
1145         }
1146         av_log(s, AV_LOG_WARNING, "H.264 bitstream error, startcode missing\n");
1147     }
1148     return 0;
1149 }
1150
1151 static int mpegts_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
1152 {
1153     AVStream *st = s->streams[pkt->stream_index];
1154     int size = pkt->size;
1155     uint8_t *buf= pkt->data;
1156     uint8_t *data= NULL;
1157     MpegTSWrite *ts = s->priv_data;
1158     MpegTSWriteStream *ts_st = st->priv_data;
1159     const int64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE)*2;
1160     int64_t dts = pkt->dts, pts = pkt->pts;
1161
1162     if (ts->reemit_pat_pmt) {
1163         av_log(s, AV_LOG_WARNING, "resend_headers option is deprecated, use -mpegts_flags resend_headers\n");
1164         ts->reemit_pat_pmt = 0;
1165         ts->flags |= MPEGTS_FLAG_REEMIT_PAT_PMT;
1166     }
1167
1168     if (ts->flags & MPEGTS_FLAG_REEMIT_PAT_PMT) {
1169         ts->pat_packet_count = ts->pat_packet_period - 1;
1170         ts->sdt_packet_count = ts->sdt_packet_period - 1;
1171         ts->flags &= ~MPEGTS_FLAG_REEMIT_PAT_PMT;
1172     }
1173
1174     if(ts->copyts < 1){
1175         if (pts != AV_NOPTS_VALUE)
1176             pts += delay;
1177         if (dts != AV_NOPTS_VALUE)
1178             dts += delay;
1179     }
1180
1181     if (ts_st->first_pts_check && pts == AV_NOPTS_VALUE) {
1182         av_log(s, AV_LOG_ERROR, "first pts value must be set\n");
1183         return AVERROR_INVALIDDATA;
1184     }
1185     ts_st->first_pts_check = 0;
1186
1187     if (st->codec->codec_id == AV_CODEC_ID_H264) {
1188         const uint8_t *p = buf, *buf_end = p+size;
1189         uint32_t state = -1;
1190         int ret = ff_check_h264_startcode(s, st, pkt);
1191         if (ret < 0)
1192             return ret;
1193
1194         do {
1195             p = avpriv_find_start_code(p, buf_end, &state);
1196             av_dlog(s, "nal %d\n", state & 0x1f);
1197         } while (p < buf_end && (state & 0x1f) != 9 &&
1198                  (state & 0x1f) != 5 && (state & 0x1f) != 1);
1199
1200         if ((state & 0x1f) != 9) { // AUD NAL
1201             data = av_malloc(pkt->size+6);
1202             if (!data)
1203                 return AVERROR(ENOMEM);
1204             memcpy(data+6, pkt->data, pkt->size);
1205             AV_WB32(data, 0x00000001);
1206             data[4] = 0x09;
1207             data[5] = 0xf0; // any slice type (0xe) + rbsp stop one bit
1208             buf  = data;
1209             size = pkt->size+6;
1210         }
1211     } else if (st->codec->codec_id == AV_CODEC_ID_AAC) {
1212         if (pkt->size < 2) {
1213             av_log(s, AV_LOG_ERROR, "AAC packet too short\n");
1214             return AVERROR_INVALIDDATA;
1215         }
1216         if ((AV_RB16(pkt->data) & 0xfff0) != 0xfff0) {
1217             int ret;
1218             AVPacket pkt2;
1219
1220             if (!ts_st->amux) {
1221                 av_log(s, AV_LOG_ERROR, "AAC bitstream not in ADTS format "
1222                        "and extradata missing\n");
1223                 return AVERROR_INVALIDDATA;
1224             }
1225
1226             av_init_packet(&pkt2);
1227             pkt2.data = pkt->data;
1228             pkt2.size = pkt->size;
1229             av_assert0(pkt->dts != AV_NOPTS_VALUE);
1230             pkt2.dts = av_rescale_q(pkt->dts, st->time_base, ts_st->amux->streams[0]->time_base);
1231             ret = avio_open_dyn_buf(&ts_st->amux->pb);
1232             if (ret < 0)
1233                 return AVERROR(ENOMEM);
1234
1235             ret = av_write_frame(ts_st->amux, &pkt2);
1236             if (ret < 0) {
1237                 avio_close_dyn_buf(ts_st->amux->pb, &data);
1238                 ts_st->amux->pb = NULL;
1239                 av_free(data);
1240                 return ret;
1241             }
1242             size = avio_close_dyn_buf(ts_st->amux->pb, &data);
1243             ts_st->amux->pb = NULL;
1244             buf = data;
1245         }
1246     }
1247
1248     if (pkt->dts != AV_NOPTS_VALUE) {
1249         int i;
1250         for(i=0; i<s->nb_streams; i++){
1251             AVStream *st2 = s->streams[i];
1252             MpegTSWriteStream *ts_st2 = st2->priv_data;
1253             if(   ts_st2->payload_size
1254                && (ts_st2->payload_dts == AV_NOPTS_VALUE || dts - ts_st2->payload_dts > delay/2)){
1255                 mpegts_write_pes(s, st2, ts_st2->payload, ts_st2->payload_size,
1256                                 ts_st2->payload_pts, ts_st2->payload_dts,
1257                                 ts_st2->payload_flags & AV_PKT_FLAG_KEY);
1258                 ts_st2->payload_size = 0;
1259             }
1260         }
1261     }
1262
1263     if (ts_st->payload_size && ts_st->payload_size + size > ts->pes_payload_size) {
1264         mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_size,
1265                          ts_st->payload_pts, ts_st->payload_dts,
1266                          ts_st->payload_flags & AV_PKT_FLAG_KEY);
1267         ts_st->payload_size = 0;
1268     }
1269
1270     if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO || size > ts->pes_payload_size) {
1271         av_assert0(!ts_st->payload_size);
1272         // for video and subtitle, write a single pes packet
1273         mpegts_write_pes(s, st, buf, size, pts, dts, pkt->flags & AV_PKT_FLAG_KEY);
1274         av_free(data);
1275         return 0;
1276     }
1277
1278     if (!ts_st->payload_size) {
1279         ts_st->payload_pts = pts;
1280         ts_st->payload_dts = dts;
1281         ts_st->payload_flags = pkt->flags;
1282     }
1283
1284     memcpy(ts_st->payload + ts_st->payload_size, buf, size);
1285     ts_st->payload_size += size;
1286
1287     av_free(data);
1288
1289     return 0;
1290 }
1291
1292 static void mpegts_write_flush(AVFormatContext *s)
1293 {
1294     int i;
1295
1296     /* flush current packets */
1297     for(i = 0; i < s->nb_streams; i++) {
1298         AVStream *st = s->streams[i];
1299         MpegTSWriteStream *ts_st = st->priv_data;
1300         if (ts_st->payload_size > 0) {
1301             mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_size,
1302                              ts_st->payload_pts, ts_st->payload_dts,
1303                              ts_st->payload_flags & AV_PKT_FLAG_KEY);
1304             ts_st->payload_size = 0;
1305         }
1306     }
1307     avio_flush(s->pb);
1308 }
1309
1310 static int mpegts_write_packet(AVFormatContext *s, AVPacket *pkt)
1311 {
1312     if (!pkt) {
1313         mpegts_write_flush(s);
1314         return 1;
1315     } else {
1316         return mpegts_write_packet_internal(s, pkt);
1317     }
1318 }
1319
1320 static int mpegts_write_end(AVFormatContext *s)
1321 {
1322     MpegTSWrite *ts = s->priv_data;
1323     MpegTSService *service;
1324     int i;
1325
1326     mpegts_write_flush(s);
1327
1328     for(i = 0; i < s->nb_streams; i++) {
1329         AVStream *st = s->streams[i];
1330         MpegTSWriteStream *ts_st = st->priv_data;
1331         av_freep(&ts_st->payload);
1332         if (ts_st->amux) {
1333             avformat_free_context(ts_st->amux);
1334             ts_st->amux = NULL;
1335         }
1336     }
1337
1338     for(i = 0; i < ts->nb_services; i++) {
1339         service = ts->services[i];
1340         av_freep(&service->provider_name);
1341         av_freep(&service->name);
1342         av_free(service);
1343     }
1344     av_free(ts->services);
1345
1346     return 0;
1347 }
1348
1349 static const AVOption options[] = {
1350     { "mpegts_transport_stream_id", "Set transport_stream_id field.",
1351       offsetof(MpegTSWrite, transport_stream_id), AV_OPT_TYPE_INT, {.i64 = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM},
1352     { "mpegts_original_network_id", "Set original_network_id field.",
1353       offsetof(MpegTSWrite, original_network_id), AV_OPT_TYPE_INT, {.i64 = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM},
1354     { "mpegts_service_id", "Set service_id field.",
1355       offsetof(MpegTSWrite, service_id), AV_OPT_TYPE_INT, {.i64 = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM},
1356     { "mpegts_pmt_start_pid", "Set the first pid of the PMT.",
1357       offsetof(MpegTSWrite, pmt_start_pid), AV_OPT_TYPE_INT, {.i64 = 0x1000 }, 0x0010, 0x1f00, AV_OPT_FLAG_ENCODING_PARAM},
1358     { "mpegts_start_pid", "Set the first pid.",
1359       offsetof(MpegTSWrite, start_pid), AV_OPT_TYPE_INT, {.i64 = 0x0100 }, 0x0100, 0x0f00, AV_OPT_FLAG_ENCODING_PARAM},
1360     {"mpegts_m2ts_mode", "Enable m2ts mode.",
1361         offsetof(MpegTSWrite, m2ts_mode), AV_OPT_TYPE_INT, {.i64 = -1 },
1362         -1,1, AV_OPT_FLAG_ENCODING_PARAM},
1363     { "muxrate", NULL, offsetof(MpegTSWrite, mux_rate), AV_OPT_TYPE_INT, {.i64 = 1}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
1364     { "pes_payload_size", "Minimum PES packet payload in bytes",
1365       offsetof(MpegTSWrite, pes_payload_size), AV_OPT_TYPE_INT, {.i64 = DEFAULT_PES_PAYLOAD_SIZE}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
1366     { "mpegts_flags", "MPEG-TS muxing flags", offsetof(MpegTSWrite, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, INT_MAX,
1367       AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags" },
1368     { "resend_headers", "Reemit PAT/PMT before writing the next packet",
1369       0, AV_OPT_TYPE_CONST, {.i64 = MPEGTS_FLAG_REEMIT_PAT_PMT}, 0, INT_MAX,
1370       AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags"},
1371     { "latm", "Use LATM packetization for AAC",
1372       0, AV_OPT_TYPE_CONST, {.i64 = MPEGTS_FLAG_AAC_LATM}, 0, INT_MAX,
1373       AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags"},
1374     // backward compatibility
1375     { "resend_headers", "Reemit PAT/PMT before writing the next packet",
1376       offsetof(MpegTSWrite, reemit_pat_pmt), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
1377     { "mpegts_copyts", "don't offset dts/pts",
1378       offsetof(MpegTSWrite, copyts), AV_OPT_TYPE_INT, {.i64=-1}, -1, 1, AV_OPT_FLAG_ENCODING_PARAM},
1379     { "tables_version", "set PAT, PMT and SDT version",
1380       offsetof(MpegTSWrite, tables_version), AV_OPT_TYPE_INT, {.i64=0}, 0, 31, AV_OPT_FLAG_ENCODING_PARAM},
1381     { "omit_video_pes_length", "Omit the PES packet length for video packets",
1382       offsetof(MpegTSWrite, omit_video_pes_length), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
1383     { NULL },
1384 };
1385
1386 static const AVClass mpegts_muxer_class = {
1387     .class_name     = "MPEGTS muxer",
1388     .item_name      = av_default_item_name,
1389     .option         = options,
1390     .version        = LIBAVUTIL_VERSION_INT,
1391 };
1392
1393 AVOutputFormat ff_mpegts_muxer = {
1394     .name              = "mpegts",
1395     .long_name         = NULL_IF_CONFIG_SMALL("MPEG-TS (MPEG-2 Transport Stream)"),
1396     .mime_type         = "video/MP2T",
1397     .extensions        = "ts,m2t,m2ts,mts",
1398     .priv_data_size    = sizeof(MpegTSWrite),
1399     .audio_codec       = AV_CODEC_ID_MP2,
1400     .video_codec       = AV_CODEC_ID_MPEG2VIDEO,
1401     .write_header      = mpegts_write_header,
1402     .write_packet      = mpegts_write_packet,
1403     .write_trailer     = mpegts_write_end,
1404     .flags             = AVFMT_ALLOW_FLUSH,
1405     .priv_class        = &mpegts_muxer_class,
1406 };