mpegtsenc.c 27.4 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
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;
47
    int pcr_packet_period;
48 49 50 51 52 53 54
} MpegTSService;

typedef struct MpegTSWrite {
    MpegTSSection pat; /* MPEG2 pat table */
    MpegTSSection sdt; /* MPEG2 sdt table context */
    MpegTSService **services;
    int sdt_packet_count;
55
    int sdt_packet_period;
56
    int pat_packet_count;
57
    int pat_packet_period;
58 59 60 61 62 63 64
    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
    /* 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;
92
        s->cc = (s->cc + 1) & 0xf;
93
        *q++ = 0x10 | s->cc;
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
    int payload_index;
176
    int first_pts_check; ///< first pts check needed
177
    int64_t payload_pts;
178
    int64_t payload_dts;
179
    uint8_t payload[DEFAULT_PES_PAYLOAD_SIZE];
180 181 182 183 184 185 186 187
} MpegTSWriteStream;

static void mpegts_write_pat(AVFormatContext *s)
{
    MpegTSWrite *ts = s->priv_data;
    MpegTSService *service;
    uint8_t data[1012], *q;
    int i;
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 215
    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;
216

217 218 219
    for(i = 0; i < s->nb_streams; i++) {
        AVStream *st = s->streams[i];
        MpegTSWriteStream *ts_st = st->priv_data;
220
        AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL,0);
221
        switch(st->codec->codec_id) {
222 223 224
        case CODEC_ID_MPEG1VIDEO:
        case CODEC_ID_MPEG2VIDEO:
            stream_type = STREAM_TYPE_VIDEO_MPEG2;
225
            break;
226 227 228 229 230 231
        case CODEC_ID_MPEG4:
            stream_type = STREAM_TYPE_VIDEO_MPEG4;
            break;
        case CODEC_ID_H264:
            stream_type = STREAM_TYPE_VIDEO_H264;
            break;
232 233 234
        case CODEC_ID_DIRAC:
            stream_type = STREAM_TYPE_VIDEO_DIRAC;
            break;
235 236
        case CODEC_ID_MP2:
        case CODEC_ID_MP3:
237
            stream_type = STREAM_TYPE_AUDIO_MPEG1;
238
            break;
239 240 241 242
        case CODEC_ID_AAC:
            stream_type = STREAM_TYPE_AUDIO_AAC;
            break;
        case CODEC_ID_AC3:
243
            stream_type = STREAM_TYPE_AUDIO_AC3;
244
            break;
245 246 247 248 249 250 251 252 253 254
        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 */
255
        switch(st->codec->codec_type) {
256
        case CODEC_TYPE_AUDIO:
257
            if (lang && strlen(lang->value) == 3) {
258 259
                *q++ = 0x0a; /* ISO 639 language descriptor */
                *q++ = 4;
260 261 262
                *q++ = lang->value[0];
                *q++ = lang->value[1];
                *q++ = lang->value[2];
263 264 265 266 267 268
                *q++ = 0; /* undefined type */
            }
            break;
        case CODEC_TYPE_SUBTITLE:
            {
                const char *language;
269
                language = lang && strlen(lang->value)==3 ? lang->value : "eng";
270 271 272 273 274 275 276 277 278 279
                *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;
280 281 282 283 284 285 286 287 288 289
        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;
290
        }
291 292 293 294 295 296 297

        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);
298
}
299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322

/* 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;
323

324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
    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 */
346
        val = (running_status << 13) | (free_ca_mode << 12) |
347 348 349 350 351 352 353 354
            (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);
}

355 356 357
static MpegTSService *mpegts_add_service(MpegTSWrite *ts,
                                         int sid,
                                         const char *provider_name,
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376
                                         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;
377
    put_buffer(ctx->pb, packet, TS_PACKET_SIZE);
378 379 380 381 382 383 384 385
}

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

391 392 393
    ts->tsid = DEFAULT_TSID;
    ts->onid = DEFAULT_ONID;
    /* allocate a single DVB service */
394 395
    title = av_metadata_get(s->metadata, "title", NULL, 0);
    service_name = title ? title->value : DEFAULT_SERVICE_NAME;
396
    service = mpegts_add_service(ts, DEFAULT_SID,
397
                                 DEFAULT_PROVIDER_NAME, service_name);
398 399 400 401
    service->pmt.write_packet = section_write_packet;
    service->pmt.opaque = s;

    ts->pat.pid = PAT_PID;
402
    ts->pat.cc = 15; // Initialize at 15 so that it wraps and be equal to 0 for the first packet we write
403 404 405 406
    ts->pat.write_packet = section_write_packet;
    ts->pat.opaque = s;

    ts->sdt.pid = SDT_PID;
407
    ts->sdt.cc = 15;
408 409 410 411 412 413 414 415 416 417 418
    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;
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
        ts_st->first_pts_check = 1;
424
        /* update PCR pid by using the first video stream */
425
        if (st->codec->codec_type == CODEC_TYPE_VIDEO &&
426 427
            service->pcr_pid == 0x1fff)
            service->pcr_pid = ts_st->pid;
428 429 430 431 432 433 434 435 436 437
        if (st->codec->rc_max_rate)
            total_bit_rate += st->codec->rc_max_rate;
        else {
            if (!st->codec->bit_rate) {
                av_log(s, AV_LOG_WARNING,
                       "stream %d, bit rate is not set, this will cause problems\n",
                       st->index);
            }
            total_bit_rate += st->codec->bit_rate;
        }
438 439
        /* PES header size */
        if (st->codec->codec_type == CODEC_TYPE_VIDEO ||
440 441 442 443 444 445 446 447 448 449 450 451
            st->codec->codec_type == CODEC_TYPE_SUBTITLE) {
            /* 1 PES per frame
             * 19 bytes of PES header
             * on average a half TS-packet (184/2) of padding-overhead every PES */
            total_bit_rate += (19 + 184/2)*8 / av_q2d(st->codec->time_base);
        } else {
            /* 1 PES per DEFAULT_PES_PAYLOAD_SIZE bytes of audio data
             * 14 bytes of PES header
             * on average a half TS-packet (184/2) of padding-overhead every PES */
            total_bit_rate += (14 + 184/2) *
                st->codec->bit_rate / DEFAULT_PES_PAYLOAD_SIZE;
        }
452
    }
453

454 455 456 457 458 459
    /* 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;
    }

460
    ts->mux_rate = 1; // avoid div by 0
461

462 463
    /* write info at the start of the file, so that it will be fast to
       find them */
464
    pos = url_ftell(s->pb);
465
    mpegts_write_sdt(s);
466 467
    sdt_size = url_ftell(s->pb) - pos;
    pos = url_ftell(s->pb);
468 469 470 471
    mpegts_write_pat(s);
    for(i = 0; i < ts->nb_services; i++) {
        mpegts_write_pmt(s, ts->services[i]);
    }
472 473
    pat_pmt_size = url_ftell(s->pb) - pos;

474 475 476
    if (total_bit_rate <= 8 * 1024)
        total_bit_rate = 8 * 1024;

477
    total_bit_rate +=
478
        total_bit_rate * 4 / (TS_PACKET_SIZE-4)        + /* TS header size */
479 480 481
        1000 * 8 * sdt_size     / PAT_RETRANS_TIME     + /* SDT size */
        1000 * 8 * pat_pmt_size / SDT_RETRANS_TIME     + /* PAT+PMT size */
        1000 * 8 * 8            / PCR_RETRANS_TIME;      /* PCR size */
482 483 484 485 486 487

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

488 489 490 491 492 493 494
    service->pcr_packet_period = (ts->mux_rate * PCR_RETRANS_TIME) /
        (TS_PACKET_SIZE * 8 * 1000);
    ts->sdt_packet_period      = (ts->mux_rate * SDT_RETRANS_TIME) /
        (TS_PACKET_SIZE * 8 * 1000);
    ts->pat_packet_period      = (ts->mux_rate * PAT_RETRANS_TIME) /
        (TS_PACKET_SIZE * 8 * 1000);

495 496 497
    // output a PCR as soon as possible
    service->pcr_packet_count = service->pcr_packet_period;

498 499 500 501 502 503
    av_log(s, AV_LOG_DEBUG,
           "calculated bitrate %d bps, muxrate %d bps, "
           "sdt every %d, pat/pmt every %d pkts\n",
           total_bit_rate, ts->mux_rate, ts->sdt_packet_period,
           ts->pat_packet_period);

504 505 506
    // adjust pcr
    ts->cur_pcr /= ts->mux_rate;

507
    put_flush_packet(s->pb);
508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524

    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;

525
    if (++ts->sdt_packet_count == ts->sdt_packet_period) {
526 527 528
        ts->sdt_packet_count = 0;
        mpegts_write_sdt(s);
    }
529
    if (++ts->pat_packet_count == ts->pat_packet_period) {
530 531 532 533 534 535 536 537
        ts->pat_packet_count = 0;
        mpegts_write_pat(s);
        for(i = 0; i < ts->nb_services; i++) {
            mpegts_write_pmt(s, ts->services[i]);
        }
    }
}

538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586
/* Write a single null transport stream packet */
static void mpegts_insert_null_packet(AVFormatContext *s)
{
    MpegTSWrite *ts = s->priv_data;
    uint8_t *q;
    uint8_t buf[TS_PACKET_SIZE];

    q = buf;
    *q++ = 0x47;
    *q++ = 0x00 | 0x1f;
    *q++ = 0xff;
    *q++ = 0x10;
    memset(q, 0x0FF, TS_PACKET_SIZE - (q - buf));
    put_buffer(s->pb, buf, TS_PACKET_SIZE);
    ts->cur_pcr += TS_PACKET_SIZE*8*90000LL/ts->mux_rate;
}

/* Write a single transport stream packet with a PCR and no payload */
static void mpegts_insert_pcr_only(AVFormatContext *s, AVStream *st)
{
    MpegTSWrite *ts = s->priv_data;
    MpegTSWriteStream *ts_st = st->priv_data;
    uint8_t *q;
    uint64_t pcr = ts->cur_pcr;
    uint8_t buf[TS_PACKET_SIZE];

    q = buf;
    *q++ = 0x47;
    *q++ = ts_st->pid >> 8;
    *q++ = ts_st->pid;
    *q++ = 0x20 | ts_st->cc;   /* Adaptation only */
    /* Continuity Count field does not increment (see 13818-1 section 2.4.3.3) */
    *q++ = TS_PACKET_SIZE - 5; /* Adaptation Field Length */
    *q++ = 0x10;               /* Adaptation flags: PCR present */

    /* PCR coded into 6 bytes */
    *q++ = pcr >> 25;
    *q++ = pcr >> 17;
    *q++ = pcr >> 9;
    *q++ = pcr >> 1;
    *q++ = (pcr & 1) << 7;
    *q++ = 0;

    /* stuffing bytes */
    memset(q, 0xFF, TS_PACKET_SIZE - (q - buf));
    put_buffer(s->pb, buf, TS_PACKET_SIZE);
    ts->cur_pcr += TS_PACKET_SIZE*8*90000LL/ts->mux_rate;
}

587 588 589 590 591 592 593 594 595 596 597 598 599 600
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;
}

601 602 603 604 605
/* Add a pes header to the front of payload, and segment into an integer number of
 * ts packets. The final ts packet is padded using an over-sized adaptation header
 * to exactly fill the last ts packet.
 * NOTE: 'payload' contains a complete PES payload.
 */
606 607
static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
                             const uint8_t *payload, int payload_size,
608
                             int64_t pts, int64_t dts)
609 610
{
    MpegTSWriteStream *ts_st = st->priv_data;
611
    MpegTSWrite *ts = s->priv_data;
612
    uint8_t buf[TS_PACKET_SIZE];
613
    uint8_t *q;
614
    int val, is_start, len, header_len, write_pcr, private_code, flags;
615 616
    int afc_len, stuffing_len;
    int64_t pcr = -1; /* avoid warning */
617
    int64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE);
618

619 620 621
    is_start = 1;
    while (payload_size > 0) {
        retransmit_si_info(s);
622

623 624 625
        write_pcr = 0;
        if (ts_st->pid == ts_st->service->pcr_pid) {
            ts_st->service->pcr_packet_count++;
626
            if (ts_st->service->pcr_packet_count >=
627
                ts_st->service->pcr_packet_period) {
628 629 630 631 632
                ts_st->service->pcr_packet_count = 0;
                write_pcr = 1;
            }
        }

633 634 635 636 637 638 639 640 641
        if (dts != AV_NOPTS_VALUE && (dts - (int64_t)ts->cur_pcr) > delay) {
            /* pcr insert gets priority over null packet insert */
            if (write_pcr)
                mpegts_insert_pcr_only(s, st);
            else
                mpegts_insert_null_packet(s);
            continue; /* recalculate write_pcr and possibly retransmit si_info */
        }

642 643 644 645 646 647 648 649 650
        /* prepare packet header */
        q = buf;
        *q++ = 0x47;
        val = (ts_st->pid >> 8);
        if (is_start)
            val |= 0x40;
        *q++ = val;
        *q++ = ts_st->pid;
        ts_st->cc = (ts_st->cc + 1) & 0xf;
651
        *q++ = 0x10 | ts_st->cc | (write_pcr ? 0x20 : 0);
652
        if (write_pcr) {
653 654
            // add 11, pcr references the last byte of program clock reference base
            pcr = ts->cur_pcr + (4+7)*8*90000LL / ts->mux_rate;
655 656
            if (dts != AV_NOPTS_VALUE && dts < pcr)
                av_log(s, AV_LOG_WARNING, "dts < pcr, TS is invalid\n");
657 658 659 660 661 662 663 664 665
            *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;
        }
666
        if (is_start) {
667
            int pes_extension = 0;
668 669 670 671
            /* write PES header */
            *q++ = 0x00;
            *q++ = 0x00;
            *q++ = 0x01;
672
            private_code = 0;
673
            if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
674 675 676 677
                if (st->codec->codec_id == CODEC_ID_DIRAC) {
                    *q++ = 0xfd;
                } else
                    *q++ = 0xe0;
678 679 680
            } else if (st->codec->codec_type == CODEC_TYPE_AUDIO &&
                       (st->codec->codec_id == CODEC_ID_MP2 ||
                        st->codec->codec_id == CODEC_ID_MP3)) {
681
                *q++ = 0xc0;
682 683
            } else {
                *q++ = 0xbd;
684
                if (st->codec->codec_type == CODEC_TYPE_SUBTITLE) {
685 686 687
                    private_code = 0x20;
                }
            }
688 689 690 691 692 693
            header_len = 0;
            flags = 0;
            if (pts != AV_NOPTS_VALUE) {
                header_len += 5;
                flags |= 0x80;
            }
694
            if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
695 696 697
                header_len += 5;
                flags |= 0x40;
            }
698 699 700 701 702 703 704 705 706 707 708 709 710
            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;
            }
711
            len = payload_size + header_len + 3;
712
            if (private_code != 0)
713
                len++;
714 715
            if (len > 0xffff)
                len = 0;
716 717
            *q++ = len >> 8;
            *q++ = len;
718 719
            val = 0x80;
            /* data alignment indicator is required for subtitle data */
720
            if (st->codec->codec_type == CODEC_TYPE_SUBTITLE)
721 722
                val |= 0x04;
            *q++ = val;
723 724
            *q++ = flags;
            *q++ = header_len;
725
            if (pts != AV_NOPTS_VALUE) {
726 727 728
                write_pts(q, flags >> 6, pts);
                q += 5;
            }
729
            if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
730 731
                write_pts(q, 1, dts);
                q += 5;
732
            }
733 734 735 736 737 738 739 740 741 742
            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;
            }
743 744
            if (private_code != 0)
                *q++ = private_code;
745
            is_start = 0;
746
        }
747 748 749 750
        /* header size */
        header_len = q - buf;
        /* data len */
        len = TS_PACKET_SIZE - header_len;
751 752
        if (len > payload_size)
            len = payload_size;
753 754 755 756 757 758 759
        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,
760
                        buf + 4 + afc_len,
761 762 763 764 765 766 767 768 769 770 771 772 773 774 775
                        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);
776 777
        payload += len;
        payload_size -= len;
778
        put_buffer(s->pb, buf, TS_PACKET_SIZE);
779
        ts->cur_pcr += TS_PACKET_SIZE*8*90000LL/ts->mux_rate;
780
    }
781
    put_flush_packet(s->pb);
782 783
}

784
static int mpegts_write_packet(AVFormatContext *s, AVPacket *pkt)
785
{
786
    AVStream *st = s->streams[pkt->stream_index];
787
    int size = pkt->size;
788
    uint8_t *buf= pkt->data;
789
    uint8_t *data= NULL;
790
    MpegTSWriteStream *ts_st = st->priv_data;
791
    const uint64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE);
792 793 794 795 796 797
    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;
798

799 800 801 802 803 804
    if (ts_st->first_pts_check && pts == AV_NOPTS_VALUE) {
        av_log(s, AV_LOG_ERROR, "first pts value must set\n");
        return -1;
    }
    ts_st->first_pts_check = 0;

805
    if (st->codec->codec_id == CODEC_ID_H264) {
806 807 808 809 810 811 812 813 814 815 816 817 818 819 820
        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;
        }
821 822
    }

823
    if (st->codec->codec_type != CODEC_TYPE_AUDIO) {
824 825
        // for video and subtitle, write a single pes packet
        mpegts_write_pes(s, st, buf, size, pts, dts);
826
        av_free(data);
827 828 829
        return 0;
    }

830 831 832 833
    if (ts_st->payload_index + size > DEFAULT_PES_PAYLOAD_SIZE) {
        mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_index,
                         ts_st->payload_pts, ts_st->payload_dts);
        ts_st->payload_index = 0;
834 835
    }

836 837 838
    if (!ts_st->payload_index) {
        ts_st->payload_pts = pts;
        ts_st->payload_dts = dts;
839
    }
840

841 842 843
    memcpy(ts_st->payload + ts_st->payload_index, buf, size);
    ts_st->payload_index += size;

844 845 846 847 848 849 850 851 852 853 854 855 856 857 858
    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;
859 860
        if (ts_st->payload_index > 0) {
            mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_index,
861
                             ts_st->payload_pts, ts_st->payload_dts);
862 863
        }
    }
864
    put_flush_packet(s->pb);
865

866 867 868 869 870 871 872 873 874 875 876
    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;
}

877
AVOutputFormat mpegts_muxer = {
878
    "mpegts",
879
    NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
880
    "video/x-mpegts",
881
    "ts,m2t",
882 883
    sizeof(MpegTSWrite),
    CODEC_ID_MP2,
884
    CODEC_ID_MPEG2VIDEO,
885 886 887 888
    mpegts_write_header,
    mpegts_write_packet,
    mpegts_write_end,
};