mpegtsenc.c 25.3 KB
Newer Older
1
/*
2
 * MPEG2 transport stream (aka DVB) muxer
3
 * Copyright (c) 2003 Fabrice Bellard
4
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * 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 14 15 16 17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * 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 "libavcodec/mpegvideo.h"
25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
#include "avformat.h"
#include "mpegts.h"

/* write DVB SI sections */

/*********************************************/
/* mpegts section writer */

typedef struct MpegTSSection {
    int pid;
    int cc;
    void (*write_packet)(struct MpegTSSection *s, const uint8_t *packet);
    void *opaque;
} MpegTSSection;

40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
typedef struct MpegTSService {
    MpegTSSection pmt; /* MPEG2 pmt table context */
    int sid;           /* service ID */
    char *name;
    char *provider_name;
    int pcr_pid;
    int pcr_packet_count;
    int pcr_packet_freq;
} MpegTSService;

typedef struct MpegTSWrite {
    MpegTSSection pat; /* MPEG2 pat table */
    MpegTSSection sdt; /* MPEG2 sdt table context */
    MpegTSService **services;
    int sdt_packet_count;
    int sdt_packet_freq;
    int pat_packet_count;
    int pat_packet_freq;
    int nb_services;
    int onid;
    int tsid;
    uint64_t cur_pcr;
    int mux_rate;
} MpegTSWrite;

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)
67
{
68
    MpegTSWrite *ts = ((AVFormatContext*)s->opaque)->priv_data;
69 70 71 72 73 74
    unsigned int crc;
    unsigned char packet[TS_PACKET_SIZE];
    const unsigned char *buf_ptr;
    unsigned char *q;
    int first, b, len1, left;

Aurelien Jacobs's avatar
Aurelien Jacobs committed
75
    crc = bswap_32(av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1, buf, len - 4));
76 77 78 79
    buf[len - 4] = (crc >> 24) & 0xff;
    buf[len - 3] = (crc >> 16) & 0xff;
    buf[len - 2] = (crc >> 8) & 0xff;
    buf[len - 1] = (crc) & 0xff;
80

81 82 83 84 85 86 87 88 89 90 91 92
    /* send each packet */
    buf_ptr = buf;
    while (len > 0) {
        first = (buf == buf_ptr);
        q = packet;
        *q++ = 0x47;
        b = (s->pid >> 8);
        if (first)
            b |= 0x40;
        *q++ = b;
        *q++ = s->pid;
        *q++ = 0x10 | s->cc;
93
        s->cc = (s->cc + 1) & 0xf;
94 95 96
        if (first)
            *q++ = 0; /* 0 offset */
        len1 = TS_PACKET_SIZE - (q - packet);
97
        if (len1 > len)
98 99 100 101 102 103 104 105 106 107 108 109
            len1 = len;
        memcpy(q, buf_ptr, len1);
        q += len1;
        /* add known padding data */
        left = TS_PACKET_SIZE - (q - packet);
        if (left > 0)
            memset(q, 0xff, left);

        s->write_packet(s, packet);

        buf_ptr += len1;
        len -= len1;
110 111

        ts->cur_pcr += TS_PACKET_SIZE*8*90000LL/ts->mux_rate;
112 113 114 115 116 117 118 119 120 121 122 123
    }
}

static inline void put16(uint8_t **q_ptr, int val)
{
    uint8_t *q;
    q = *q_ptr;
    *q++ = val >> 8;
    *q++ = val;
    *q_ptr = q;
}

124
static int mpegts_write_section1(MpegTSSection *s, int tid, int id,
125 126 127 128 129
                          int version, int sec_num, int last_sec_num,
                          uint8_t *buf, int len)
{
    uint8_t section[1024], *q;
    unsigned int tot_len;
130

131 132 133 134 135 136 137 138 139 140 141 142 143
    tot_len = 3 + 5 + len + 4;
    /* check if not too big */
    if (tot_len > 1024)
        return -1;

    q = section;
    *q++ = tid;
    put16(&q, 0xb000 | (len + 5 + 4)); /* 5 byte header + 4 byte CRC */
    put16(&q, id);
    *q++ = 0xc1 | (version << 1); /* current_next_indicator = 1 */
    *q++ = sec_num;
    *q++ = last_sec_num;
    memcpy(q, buf, len);
144

145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
    mpegts_write_section(s, section, tot_len);
    return 0;
}

/*********************************************/
/* mpegts writer */

#define DEFAULT_PMT_START_PID   0x1000
#define DEFAULT_START_PID       0x0100
#define DEFAULT_PROVIDER_NAME   "FFmpeg"
#define DEFAULT_SERVICE_NAME    "Service01"

/* default network id, transport stream and service identifiers */
#define DEFAULT_ONID            0x0001
#define DEFAULT_TSID            0x0001
#define DEFAULT_SID             0x0001

/* a PES packet header is generated every DEFAULT_PES_HEADER_FREQ packets */
#define DEFAULT_PES_HEADER_FREQ 16
164
#define DEFAULT_PES_PAYLOAD_SIZE ((DEFAULT_PES_HEADER_FREQ - 1) * 184 + 170)
165 166 167 168

/* we retransmit the SI info at this rate */
#define SDT_RETRANS_TIME 500
#define PAT_RETRANS_TIME 100
169
#define PCR_RETRANS_TIME 20
170 171

typedef struct MpegTSWriteStream {
172
    struct MpegTSService *service;
173 174
    int pid; /* stream associated pid */
    int cc;
175 176
    int payload_index;
    int64_t payload_pts;
177
    int64_t payload_dts;
178
    uint8_t payload[DEFAULT_PES_PAYLOAD_SIZE];
179 180 181 182 183 184 185 186
} MpegTSWriteStream;

static void mpegts_write_pat(AVFormatContext *s)
{
    MpegTSWrite *ts = s->priv_data;
    MpegTSService *service;
    uint8_t data[1012], *q;
    int i;
187

188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214
    q = data;
    for(i = 0; i < ts->nb_services; i++) {
        service = ts->services[i];
        put16(&q, service->sid);
        put16(&q, 0xe000 | service->pmt.pid);
    }
    mpegts_write_section1(&ts->pat, PAT_TID, ts->tsid, 0, 0, 0,
                          data, q - data);
}

static void mpegts_write_pmt(AVFormatContext *s, MpegTSService *service)
{
    //    MpegTSWrite *ts = s->priv_data;
    uint8_t data[1012], *q, *desc_length_ptr, *program_info_length_ptr;
    int val, stream_type, i;

    q = data;
    put16(&q, 0xe000 | service->pcr_pid);

    program_info_length_ptr = q;
    q += 2; /* patched after */

    /* put program info here */

    val = 0xf000 | (q - program_info_length_ptr - 2);
    program_info_length_ptr[0] = val >> 8;
    program_info_length_ptr[1] = val;
215

216 217 218
    for(i = 0; i < s->nb_streams; i++) {
        AVStream *st = s->streams[i];
        MpegTSWriteStream *ts_st = st->priv_data;
219
        AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL,0);
220
        switch(st->codec->codec_id) {
221 222 223
        case CODEC_ID_MPEG1VIDEO:
        case CODEC_ID_MPEG2VIDEO:
            stream_type = STREAM_TYPE_VIDEO_MPEG2;
224
            break;
225 226 227 228 229 230
        case CODEC_ID_MPEG4:
            stream_type = STREAM_TYPE_VIDEO_MPEG4;
            break;
        case CODEC_ID_H264:
            stream_type = STREAM_TYPE_VIDEO_H264;
            break;
231 232 233
        case CODEC_ID_DIRAC:
            stream_type = STREAM_TYPE_VIDEO_DIRAC;
            break;
234 235
        case CODEC_ID_MP2:
        case CODEC_ID_MP3:
236
            stream_type = STREAM_TYPE_AUDIO_MPEG1;
237
            break;
238 239 240 241 242 243
        case CODEC_ID_AAC:
            stream_type = STREAM_TYPE_AUDIO_AAC;
            break;
        case CODEC_ID_AC3:
            stream_type = STREAM_TYPE_AUDIO_AC3;
            break;
244 245 246 247 248 249 250 251 252 253
        default:
            stream_type = STREAM_TYPE_PRIVATE_DATA;
            break;
        }
        *q++ = stream_type;
        put16(&q, 0xe000 | ts_st->pid);
        desc_length_ptr = q;
        q += 2; /* patched after */

        /* write optional descriptors here */
254
        switch(st->codec->codec_type) {
255
        case CODEC_TYPE_AUDIO:
256
            if (lang && strlen(lang->value) == 3) {
257 258
                *q++ = 0x0a; /* ISO 639 language descriptor */
                *q++ = 4;
259 260 261
                *q++ = lang->value[0];
                *q++ = lang->value[1];
                *q++ = lang->value[2];
262 263 264 265 266 267
                *q++ = 0; /* undefined type */
            }
            break;
        case CODEC_TYPE_SUBTITLE:
            {
                const char *language;
268
                language = lang && strlen(lang->value)==3 ? lang->value : "eng";
269 270 271 272 273 274 275 276 277 278
                *q++ = 0x59;
                *q++ = 8;
                *q++ = language[0];
                *q++ = language[1];
                *q++ = language[2];
                *q++ = 0x10; /* normal subtitles (0x20 = if hearing pb) */
                put16(&q, 1); /* page id */
                put16(&q, 1); /* ancillary page id */
            }
            break;
279 280 281 282 283 284 285 286 287 288
        case CODEC_TYPE_VIDEO:
            if (stream_type == STREAM_TYPE_VIDEO_DIRAC) {
                *q++ = 0x05; /*MPEG-2 registration descriptor*/
                *q++ = 4;
                *q++ = 'd';
                *q++ = 'r';
                *q++ = 'a';
                *q++ = 'c';
            }
            break;
289
        }
290 291 292 293 294 295 296

        val = 0xf000 | (q - desc_length_ptr - 2);
        desc_length_ptr[0] = val >> 8;
        desc_length_ptr[1] = val;
    }
    mpegts_write_section1(&service->pmt, PMT_TID, service->sid, 0, 0, 0,
                          data, q - data);
297
}
298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321

/* NOTE: str == NULL is accepted for an empty string */
static void putstr8(uint8_t **q_ptr, const char *str)
{
    uint8_t *q;
    int len;

    q = *q_ptr;
    if (!str)
        len = 0;
    else
        len = strlen(str);
    *q++ = len;
    memcpy(q, str, len);
    q += len;
    *q_ptr = q;
}

static void mpegts_write_sdt(AVFormatContext *s)
{
    MpegTSWrite *ts = s->priv_data;
    MpegTSService *service;
    uint8_t data[1012], *q, *desc_list_len_ptr, *desc_len_ptr;
    int i, running_status, free_ca_mode, val;
322

323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
    q = data;
    put16(&q, ts->onid);
    *q++ = 0xff;
    for(i = 0; i < ts->nb_services; i++) {
        service = ts->services[i];
        put16(&q, service->sid);
        *q++ = 0xfc | 0x00; /* currently no EIT info */
        desc_list_len_ptr = q;
        q += 2;
        running_status = 4; /* running */
        free_ca_mode = 0;

        /* write only one descriptor for the service name and provider */
        *q++ = 0x48;
        desc_len_ptr = q;
        q++;
        *q++ = 0x01; /* digital television service */
        putstr8(&q, service->provider_name);
        putstr8(&q, service->name);
        desc_len_ptr[0] = q - desc_len_ptr - 1;

        /* fill descriptor length */
345
        val = (running_status << 13) | (free_ca_mode << 12) |
346 347 348 349 350 351 352 353
            (q - desc_list_len_ptr - 2);
        desc_list_len_ptr[0] = val >> 8;
        desc_list_len_ptr[1] = val;
    }
    mpegts_write_section1(&ts->sdt, SDT_TID, ts->tsid, 0, 0, 0,
                          data, q - data);
}

354 355 356
static MpegTSService *mpegts_add_service(MpegTSWrite *ts,
                                         int sid,
                                         const char *provider_name,
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
                                         const char *name)
{
    MpegTSService *service;

    service = av_mallocz(sizeof(MpegTSService));
    if (!service)
        return NULL;
    service->pmt.pid = DEFAULT_PMT_START_PID + ts->nb_services - 1;
    service->sid = sid;
    service->provider_name = av_strdup(provider_name);
    service->name = av_strdup(name);
    service->pcr_pid = 0x1fff;
    dynarray_add(&ts->services, &ts->nb_services, service);
    return service;
}

static void section_write_packet(MpegTSSection *s, const uint8_t *packet)
{
    AVFormatContext *ctx = s->opaque;
376
    put_buffer(ctx->pb, packet, TS_PACKET_SIZE);
377 378 379 380 381 382 383 384
}

static int mpegts_write_header(AVFormatContext *s)
{
    MpegTSWrite *ts = s->priv_data;
    MpegTSWriteStream *ts_st;
    MpegTSService *service;
    AVStream *st;
385
    AVMetadataTag *title;
386
    int i, total_bit_rate;
387
    const char *service_name;
388
    uint64_t sdt_size, pat_pmt_size, pos;
389

390 391 392
    ts->tsid = DEFAULT_TSID;
    ts->onid = DEFAULT_ONID;
    /* allocate a single DVB service */
393 394
    title = av_metadata_get(s->metadata, "title", NULL, 0);
    service_name = title ? title->value : DEFAULT_SERVICE_NAME;
395
    service = mpegts_add_service(ts, DEFAULT_SID,
396
                                 DEFAULT_PROVIDER_NAME, service_name);
397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417
    service->pmt.write_packet = section_write_packet;
    service->pmt.opaque = s;

    ts->pat.pid = PAT_PID;
    ts->pat.cc = 0;
    ts->pat.write_packet = section_write_packet;
    ts->pat.opaque = s;

    ts->sdt.pid = SDT_PID;
    ts->sdt.cc = 0;
    ts->sdt.write_packet = section_write_packet;
    ts->sdt.opaque = s;

    /* assign pids to each stream */
    total_bit_rate = 0;
    for(i = 0;i < s->nb_streams; i++) {
        st = s->streams[i];
        ts_st = av_mallocz(sizeof(MpegTSWriteStream));
        if (!ts_st)
            goto fail;
        st->priv_data = ts_st;
418
        ts_st->service = service;
419
        ts_st->pid = DEFAULT_START_PID + i;
420
        ts_st->payload_pts = AV_NOPTS_VALUE;
421
        ts_st->payload_dts = AV_NOPTS_VALUE;
422
        /* update PCR pid by using the first video stream */
423
        if (st->codec->codec_type == CODEC_TYPE_VIDEO &&
424 425
            service->pcr_pid == 0x1fff)
            service->pcr_pid = ts_st->pid;
426
        total_bit_rate += st->codec->bit_rate;
427
    }
428

429 430 431 432 433 434
    /* if no video stream, use the first stream as PCR */
    if (service->pcr_pid == 0x1fff && s->nb_streams > 0) {
        ts_st = s->streams[0]->priv_data;
        service->pcr_pid = ts_st->pid;
    }

435 436
    if (total_bit_rate <= 8 * 1024)
        total_bit_rate = 8 * 1024;
437
    service->pcr_packet_freq = (total_bit_rate * PCR_RETRANS_TIME) /
438
        (TS_PACKET_SIZE * 8 * 1000);
439
    ts->sdt_packet_freq = (total_bit_rate * SDT_RETRANS_TIME) /
440
        (TS_PACKET_SIZE * 8 * 1000);
441
    ts->pat_packet_freq = (total_bit_rate * PAT_RETRANS_TIME) /
442 443
        (TS_PACKET_SIZE * 8 * 1000);

444
    ts->mux_rate = 1; // avoid div by 0
445

446 447
    /* write info at the start of the file, so that it will be fast to
       find them */
448
    pos = url_ftell(s->pb);
449
    mpegts_write_sdt(s);
450 451
    sdt_size = url_ftell(s->pb) - pos;
    pos = url_ftell(s->pb);
452 453 454 455
    mpegts_write_pat(s);
    for(i = 0; i < ts->nb_services; i++) {
        mpegts_write_pmt(s, ts->services[i]);
    }
456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
    pat_pmt_size = url_ftell(s->pb) - pos;

    total_bit_rate +=
        total_bit_rate * 25 / (8 * DEFAULT_PES_PAYLOAD_SIZE) + /* PES header size */
        total_bit_rate * 4 / (8 * TS_PACKET_SIZE) +            /* TS  header size */
        SDT_RETRANS_TIME * sdt_size +                          /* SDT size */
        PAT_RETRANS_TIME * pat_pmt_size +                      /* PAT+PMT size */
        PCR_RETRANS_TIME * 8;                                  /* PCR size */

    av_log(s, AV_LOG_DEBUG, "muxrate %d freq sdt %d pat %d\n",
           total_bit_rate, ts->sdt_packet_freq, ts->pat_packet_freq);

    if (s->mux_rate)
        ts->mux_rate = s->mux_rate;
    else
        ts->mux_rate = total_bit_rate;

    // adjust pcr
    ts->cur_pcr /= ts->mux_rate;

476
    put_flush_packet(s->pb);
477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506

    return 0;

 fail:
    for(i = 0;i < s->nb_streams; i++) {
        st = s->streams[i];
        av_free(st->priv_data);
    }
    return -1;
}

/* send SDT, PAT and PMT tables regulary */
static void retransmit_si_info(AVFormatContext *s)
{
    MpegTSWrite *ts = s->priv_data;
    int i;

    if (++ts->sdt_packet_count == ts->sdt_packet_freq) {
        ts->sdt_packet_count = 0;
        mpegts_write_sdt(s);
    }
    if (++ts->pat_packet_count == ts->pat_packet_freq) {
        ts->pat_packet_count = 0;
        mpegts_write_pat(s);
        for(i = 0; i < ts->nb_services; i++) {
            mpegts_write_pmt(s, ts->services[i]);
        }
    }
}

507 508 509 510 511 512 513 514 515 516 517 518 519 520
static void write_pts(uint8_t *q, int fourbits, int64_t pts)
{
    int val;

    val = fourbits << 4 | (((pts >> 30) & 0x07) << 1) | 1;
    *q++ = val;
    val = (((pts >> 15) & 0x7fff) << 1) | 1;
    *q++ = val >> 8;
    *q++ = val;
    val = (((pts) & 0x7fff) << 1) | 1;
    *q++ = val >> 8;
    *q++ = val;
}

521 522 523
/* NOTE: pes_data contains all the PES packet */
static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
                             const uint8_t *payload, int payload_size,
524
                             int64_t pts, int64_t dts)
525 526
{
    MpegTSWriteStream *ts_st = st->priv_data;
527
    MpegTSWrite *ts = s->priv_data;
528
    uint8_t buf[TS_PACKET_SIZE];
529
    uint8_t *q;
530
    int val, is_start, len, header_len, write_pcr, private_code, flags;
531 532
    int afc_len, stuffing_len;
    int64_t pcr = -1; /* avoid warning */
533

534 535 536
    is_start = 1;
    while (payload_size > 0) {
        retransmit_si_info(s);
537

538 539 540
        write_pcr = 0;
        if (ts_st->pid == ts_st->service->pcr_pid) {
            ts_st->service->pcr_packet_count++;
541
            if (ts_st->service->pcr_packet_count >=
542 543 544 545 546 547
                ts_st->service->pcr_packet_freq) {
                ts_st->service->pcr_packet_count = 0;
                write_pcr = 1;
            }
        }

548 549 550 551 552 553 554 555
        /* prepare packet header */
        q = buf;
        *q++ = 0x47;
        val = (ts_st->pid >> 8);
        if (is_start)
            val |= 0x40;
        *q++ = val;
        *q++ = ts_st->pid;
556
        *q++ = 0x10 | ts_st->cc | (write_pcr ? 0x20 : 0);
557
        ts_st->cc = (ts_st->cc + 1) & 0xf;
558
        if (write_pcr) {
559 560
            // add 11, pcr references the last byte of program clock reference base
            pcr = ts->cur_pcr + (4+7)*8*90000LL / ts->mux_rate;
561 562
            if (dts != AV_NOPTS_VALUE && dts < pcr)
                av_log(s, AV_LOG_WARNING, "dts < pcr, TS is invalid\n");
563 564 565 566 567 568 569 570 571
            *q++ = 7; /* AFC length */
            *q++ = 0x10; /* flags: PCR present */
            *q++ = pcr >> 25;
            *q++ = pcr >> 17;
            *q++ = pcr >> 9;
            *q++ = pcr >> 1;
            *q++ = (pcr & 1) << 7;
            *q++ = 0;
        }
572
        if (is_start) {
573
            int pes_extension = 0;
574 575 576 577
            /* write PES header */
            *q++ = 0x00;
            *q++ = 0x00;
            *q++ = 0x01;
578
            private_code = 0;
579
            if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
580 581 582 583
                if (st->codec->codec_id == CODEC_ID_DIRAC) {
                    *q++ = 0xfd;
                } else
                    *q++ = 0xe0;
584 585 586
            } else if (st->codec->codec_type == CODEC_TYPE_AUDIO &&
                       (st->codec->codec_id == CODEC_ID_MP2 ||
                        st->codec->codec_id == CODEC_ID_MP3)) {
587
                *q++ = 0xc0;
588 589
            } else {
                *q++ = 0xbd;
590
                if (st->codec->codec_type == CODEC_TYPE_SUBTITLE) {
591 592 593
                    private_code = 0x20;
                }
            }
594 595 596 597 598 599
            header_len = 0;
            flags = 0;
            if (pts != AV_NOPTS_VALUE) {
                header_len += 5;
                flags |= 0x80;
            }
600
            if (dts != AV_NOPTS_VALUE && dts != pts) {
601 602 603
                header_len += 5;
                flags |= 0x40;
            }
604 605 606 607 608 609 610 611 612 613 614 615 616
            if (st->codec->codec_type == CODEC_TYPE_VIDEO &&
                st->codec->codec_id == CODEC_ID_DIRAC) {
                /* set PES_extension_flag */
                pes_extension = 1;
                flags |= 0x01;

                /*
                * One byte for PES2 extension flag +
                * one byte for extension length +
                * one byte for extension id
                */
                header_len += 3;
            }
617
            len = payload_size + header_len + 3;
618
            if (private_code != 0)
619
                len++;
620 621
            *q++ = len >> 8;
            *q++ = len;
622 623
            val = 0x80;
            /* data alignment indicator is required for subtitle data */
624
            if (st->codec->codec_type == CODEC_TYPE_SUBTITLE)
625 626
                val |= 0x04;
            *q++ = val;
627 628
            *q++ = flags;
            *q++ = header_len;
629
            if (pts != AV_NOPTS_VALUE) {
630 631 632
                write_pts(q, flags >> 6, pts);
                q += 5;
            }
633
            if (dts != AV_NOPTS_VALUE && dts != pts) {
634 635
                write_pts(q, 1, dts);
                q += 5;
636
            }
637 638 639 640 641 642 643 644 645 646
            if (pes_extension && st->codec->codec_id == CODEC_ID_DIRAC) {
                flags = 0x01;  /* set PES_extension_flag_2 */
                *q++ = flags;
                *q++ = 0x80 | 0x01;  /* marker bit + extension length */
                /*
                * Set the stream id extension flag bit to 0 and
                * write the extended stream id
                */
                *q++ = 0x00 | 0x60;
            }
647 648
            if (private_code != 0)
                *q++ = private_code;
649
            is_start = 0;
650
        }
651 652 653 654
        /* header size */
        header_len = q - buf;
        /* data len */
        len = TS_PACKET_SIZE - header_len;
655 656
        if (len > payload_size)
            len = payload_size;
657 658 659 660 661 662 663
        stuffing_len = TS_PACKET_SIZE - header_len - len;
        if (stuffing_len > 0) {
            /* add stuffing with AFC */
            if (buf[3] & 0x20) {
                /* stuffing already present: increase its size */
                afc_len = buf[4] + 1;
                memmove(buf + 4 + afc_len + stuffing_len,
664
                        buf + 4 + afc_len,
665 666 667 668 669 670 671 672 673 674 675 676 677 678 679
                        header_len - (4 + afc_len));
                buf[4] += stuffing_len;
                memset(buf + 4 + afc_len, 0xff, stuffing_len);
            } else {
                /* add stuffing */
                memmove(buf + 4 + stuffing_len, buf + 4, header_len - 4);
                buf[3] |= 0x20;
                buf[4] = stuffing_len - 1;
                if (stuffing_len >= 2) {
                    buf[5] = 0x00;
                    memset(buf + 6, 0xff, stuffing_len - 2);
                }
            }
        }
        memcpy(buf + TS_PACKET_SIZE - len, payload, len);
680 681
        payload += len;
        payload_size -= len;
682
        put_buffer(s->pb, buf, TS_PACKET_SIZE);
683
        ts->cur_pcr += TS_PACKET_SIZE*8*90000LL/ts->mux_rate;
684
    }
685
    put_flush_packet(s->pb);
686 687
}

688
static int mpegts_write_packet(AVFormatContext *s, AVPacket *pkt)
689
{
690 691 692
    AVStream *st = s->streams[pkt->stream_index];
    int size= pkt->size;
    uint8_t *buf= pkt->data;
693
    uint8_t *data= NULL;
694
    MpegTSWriteStream *ts_st = st->priv_data;
695
    int len, max_payload_size;
696
    const uint8_t *access_unit_index = NULL;
697
    const uint64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE);
698 699 700 701 702 703
    int64_t dts = AV_NOPTS_VALUE, pts = AV_NOPTS_VALUE;

    if (pkt->pts != AV_NOPTS_VALUE)
        pts = pkt->pts + delay;
    if (pkt->dts != AV_NOPTS_VALUE)
        dts = pkt->dts + delay;
704

705
    if (st->codec->codec_type == CODEC_TYPE_SUBTITLE) {
706
        /* for subtitle, a single PES packet must be generated */
707
        mpegts_write_pes(s, st, buf, size, pts, AV_NOPTS_VALUE);
708 709
        return 0;
    }
710

711 712
    if (st->codec->codec_id == CODEC_ID_DIRAC) {
        /* for Dirac, a single PES packet must be generated */
713
        mpegts_write_pes(s, st, buf, size, pts, dts);
714 715
        return 0;
    }
716
    max_payload_size = DEFAULT_PES_PAYLOAD_SIZE;
717 718 719 720 721 722 723 724 725 726 727 728
    if (st->codec->codec_id == CODEC_ID_MPEG2VIDEO ||
        st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
        const uint8_t *p = pkt->data;
        const uint8_t *end = pkt->data+pkt->size;
        uint32_t state = -1;
        while (p < end) {
            p = ff_find_start_code(p, end, &state);
            if (state == PICTURE_START_CODE) {
                access_unit_index = p - 4;
                break;
            }
        }
729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745
    } if (st->codec->codec_id == CODEC_ID_H264) {
        if (pkt->size < 5 || AV_RB32(pkt->data) != 0x0000001) {
            av_log(s, AV_LOG_ERROR, "h264 bitstream malformated\n");
            return -1;
        }
        if (pkt->data[4] != 0x09) { // AUD NAL
            data = av_malloc(pkt->size+6);
            if (!data)
                return -1;
            memcpy(data+6, pkt->data, pkt->size);
            AV_WB32(data, 0x00000001);
            data[4] = 0x09;
            data[5] = 0xe0; // any slice type
            buf  = data;
            size = pkt->size+6;
        }
        access_unit_index = buf;
746
    } else {
747 748 749 750 751 752 753 754
        access_unit_index = pkt->data;
    }

    if (!access_unit_index) {
        av_log(s, AV_LOG_ERROR, "error, could not find access unit start\n");
        return -1;
    }

755
    while (size > 0) {
756
        len = max_payload_size - ts_st->payload_index;
757 758 759 760 761 762
        if (len > size)
            len = size;
        memcpy(ts_st->payload + ts_st->payload_index, buf, len);
        buf += len;
        size -= len;
        ts_st->payload_index += len;
763 764 765
        if (access_unit_index && access_unit_index < buf &&
            ts_st->payload_pts == AV_NOPTS_VALUE &&
            ts_st->payload_dts == AV_NOPTS_VALUE) {
766 767
            ts_st->payload_dts = dts;
            ts_st->payload_pts = pts;
768
        }
769
        if (ts_st->payload_index >= max_payload_size) {
770
            mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_index,
771
                             ts_st->payload_pts, ts_st->payload_dts);
772
            ts_st->payload_pts = AV_NOPTS_VALUE;
773
            ts_st->payload_dts = AV_NOPTS_VALUE;
774
            ts_st->payload_index = 0;
775
            access_unit_index = NULL; // unset access unit to avoid setting pts/dts again
776 777
        }
    }
778 779 780

    av_free(data);

781 782 783 784 785 786 787 788 789 790 791 792 793 794 795
    return 0;
}

static int mpegts_write_end(AVFormatContext *s)
{
    MpegTSWrite *ts = s->priv_data;
    MpegTSWriteStream *ts_st;
    MpegTSService *service;
    AVStream *st;
    int i;

    /* flush current packets */
    for(i = 0; i < s->nb_streams; i++) {
        st = s->streams[i];
        ts_st = st->priv_data;
796 797
        if (ts_st->payload_index > 0) {
            mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_index,
798
                             ts_st->payload_pts, ts_st->payload_dts);
799 800
        }
    }
801
    put_flush_packet(s->pb);
802

803 804 805 806 807 808 809 810 811 812 813
    for(i = 0; i < ts->nb_services; i++) {
        service = ts->services[i];
        av_freep(&service->provider_name);
        av_freep(&service->name);
        av_free(service);
    }
    av_free(ts->services);

    return 0;
}

814
AVOutputFormat mpegts_muxer = {
815
    "mpegts",
816
    NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
817
    "video/x-mpegts",
818
    "ts,m2t",
819 820
    sizeof(MpegTSWrite),
    CODEC_ID_MP2,
821
    CODEC_ID_MPEG2VIDEO,
822 823 824 825
    mpegts_write_header,
    mpegts_write_packet,
    mpegts_write_end,
};