mpegtsenc.c 35 KB
Newer Older
1
/*
2
 * MPEG2 transport stream (aka DVB) muxer
3
 * Copyright (c) 2003 Fabrice Bellard
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav 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
 * Libav 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 Libav; 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/mathematics.h"
26
#include "libavutil/opt.h"
27
#include "libavcodec/mpegvideo.h"
28
#include "avformat.h"
29
#include "internal.h"
30
#include "mpegts.h"
31
#include "adts.h"
32

33 34
#define PCR_TIME_BASE 27000000

35 36 37 38 39 40 41 42 43 44 45 46
/* 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;

47 48 49 50 51 52 53
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;
54
    int pcr_packet_period;
55 56 57
} MpegTSService;

typedef struct MpegTSWrite {
58
    const AVClass *av_class;
59 60 61 62
    MpegTSSection pat; /* MPEG2 pat table */
    MpegTSSection sdt; /* MPEG2 sdt table context */
    MpegTSService **services;
    int sdt_packet_count;
63
    int sdt_packet_period;
64
    int pat_packet_count;
65
    int pat_packet_period;
66 67 68
    int nb_services;
    int onid;
    int tsid;
69
    int64_t first_pcr;
70
    int mux_rate; ///< set to 1 when VBR
71
    int pes_payload_size;
72 73 74 75 76 77 78

    int transport_stream_id;
    int original_network_id;
    int service_id;

    int pmt_start_pid;
    int start_pid;
79 80
} MpegTSWrite;

81 82 83 84
/* a PES packet header is generated every DEFAULT_PES_HEADER_FREQ packets */
#define DEFAULT_PES_HEADER_FREQ 16
#define DEFAULT_PES_PAYLOAD_SIZE ((DEFAULT_PES_HEADER_FREQ - 1) * 184 + 170)

85 86
static const AVOption options[] = {
    { "mpegts_transport_stream_id", "Set transport_stream_id field.",
87
      offsetof(MpegTSWrite, transport_stream_id), AV_OPT_TYPE_INT, {.dbl = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM},
88
    { "mpegts_original_network_id", "Set original_network_id field.",
89
      offsetof(MpegTSWrite, original_network_id), AV_OPT_TYPE_INT, {.dbl = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM},
90
    { "mpegts_service_id", "Set service_id field.",
91
      offsetof(MpegTSWrite, service_id), AV_OPT_TYPE_INT, {.dbl = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM},
92
    { "mpegts_pmt_start_pid", "Set the first pid of the PMT.",
93
      offsetof(MpegTSWrite, pmt_start_pid), AV_OPT_TYPE_INT, {.dbl = 0x1000 }, 0x1000, 0x1f00, AV_OPT_FLAG_ENCODING_PARAM},
94
    { "mpegts_start_pid", "Set the first pid.",
95
      offsetof(MpegTSWrite, start_pid), AV_OPT_TYPE_INT, {.dbl = 0x0100 }, 0x0100, 0x0f00, AV_OPT_FLAG_ENCODING_PARAM},
96
    { "muxrate", NULL, offsetof(MpegTSWrite, mux_rate), AV_OPT_TYPE_INT, {1}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
97 98
    { "pes_payload_size", "Minimum PES packet payload in bytes",
      offsetof(MpegTSWrite, pes_payload_size), AV_OPT_TYPE_INT, {DEFAULT_PES_PAYLOAD_SIZE}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
99 100 101 102
    { NULL },
};

static const AVClass mpegts_muxer_class = {
103 104 105 106
    .class_name     = "MPEGTS muxer",
    .item_name      = av_default_item_name,
    .option         = options,
    .version        = LIBAVUTIL_VERSION_INT,
107 108
};

109
/* NOTE: 4 bytes must be left at the end for the crc32 */
110
static void mpegts_write_section(MpegTSSection *s, uint8_t *buf, int len)
111 112 113 114 115 116 117
{
    unsigned int crc;
    unsigned char packet[TS_PACKET_SIZE];
    const unsigned char *buf_ptr;
    unsigned char *q;
    int first, b, len1, left;

118
    crc = av_bswap32(av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1, buf, len - 4));
119 120 121 122
    buf[len - 4] = (crc >> 24) & 0xff;
    buf[len - 3] = (crc >> 16) & 0xff;
    buf[len - 2] = (crc >> 8) & 0xff;
    buf[len - 1] = (crc) & 0xff;
123

124 125 126 127 128 129 130 131 132 133 134
    /* 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;
135
        s->cc = (s->cc + 1) & 0xf;
136
        *q++ = 0x10 | s->cc;
137 138 139
        if (first)
            *q++ = 0; /* 0 offset */
        len1 = TS_PACKET_SIZE - (q - packet);
140
        if (len1 > len)
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
            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;
    }
}

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

165
static int mpegts_write_section1(MpegTSSection *s, int tid, int id,
166 167 168 169 170
                          int version, int sec_num, int last_sec_num,
                          uint8_t *buf, int len)
{
    uint8_t section[1024], *q;
    unsigned int tot_len;
171 172
    /* reserved_future_use field must be set to 1 for SDT */
    unsigned int flags = tid == SDT_TID ? 0xf000 : 0xb000;
173

174 175 176 177 178 179 180
    tot_len = 3 + 5 + len + 4;
    /* check if not too big */
    if (tot_len > 1024)
        return -1;

    q = section;
    *q++ = tid;
181
    put16(&q, flags | (len + 5 + 4)); /* 5 byte header + 4 byte CRC */
182 183 184 185 186
    put16(&q, id);
    *q++ = 0xc1 | (version << 1); /* current_next_indicator = 1 */
    *q++ = sec_num;
    *q++ = last_sec_num;
    memcpy(q, buf, len);
187

188 189 190 191 192 193 194
    mpegts_write_section(s, section, tot_len);
    return 0;
}

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

195
#define DEFAULT_PROVIDER_NAME   "Libav"
196 197 198 199 200
#define DEFAULT_SERVICE_NAME    "Service01"

/* we retransmit the SI info at this rate */
#define SDT_RETRANS_TIME 500
#define PAT_RETRANS_TIME 100
201
#define PCR_RETRANS_TIME 20
202 203

typedef struct MpegTSWriteStream {
204
    struct MpegTSService *service;
205 206
    int pid; /* stream associated pid */
    int cc;
207
    int payload_size;
208
    int first_pts_check; ///< first pts check needed
209
    int64_t payload_pts;
210
    int64_t payload_dts;
211
    int payload_flags;
212
    uint8_t *payload;
213
    ADTSContext *adts;
214 215 216 217 218 219 220 221
} MpegTSWriteStream;

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

223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
    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;
250

251 252 253
    for(i = 0; i < s->nb_streams; i++) {
        AVStream *st = s->streams[i];
        MpegTSWriteStream *ts_st = st->priv_data;
254
        AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL,0);
255
        switch(st->codec->codec_id) {
256 257 258
        case CODEC_ID_MPEG1VIDEO:
        case CODEC_ID_MPEG2VIDEO:
            stream_type = STREAM_TYPE_VIDEO_MPEG2;
259
            break;
260 261 262 263 264 265
        case CODEC_ID_MPEG4:
            stream_type = STREAM_TYPE_VIDEO_MPEG4;
            break;
        case CODEC_ID_H264:
            stream_type = STREAM_TYPE_VIDEO_H264;
            break;
266 267 268
        case CODEC_ID_DIRAC:
            stream_type = STREAM_TYPE_VIDEO_DIRAC;
            break;
269 270
        case CODEC_ID_MP2:
        case CODEC_ID_MP3:
271
            stream_type = STREAM_TYPE_AUDIO_MPEG1;
272
            break;
273 274 275
        case CODEC_ID_AAC:
            stream_type = STREAM_TYPE_AUDIO_AAC;
            break;
276 277 278
        case CODEC_ID_AAC_LATM:
            stream_type = STREAM_TYPE_AUDIO_AAC_LATM;
            break;
279
        case CODEC_ID_AC3:
280
            stream_type = STREAM_TYPE_AUDIO_AC3;
281
            break;
282 283 284 285 286 287 288 289 290 291
        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 */
292
        switch(st->codec->codec_type) {
293
        case AVMEDIA_TYPE_AUDIO:
294 295 296 297 298
            if (lang) {
                char *p;
                char *next = lang->value;
                uint8_t *len_ptr;

299
                *q++ = 0x0a; /* ISO 639 language descriptor */
300 301 302 303 304 305 306 307 308 309 310 311
                len_ptr = q++;
                *len_ptr = 0;

                for (p = lang->value; next && *len_ptr < 255 / 4 * 4; p = next + 1) {
                    next = strchr(p, ',');
                    if (strlen(p) != 3 && (!next || next != p + 3))
                        continue; /* not a 3-letter code */

                    *q++ = *p++;
                    *q++ = *p++;
                    *q++ = *p++;

312 313 314 315 316 317 318
                if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
                    *q++ = 0x01;
                else if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
                    *q++ = 0x02;
                else if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
                    *q++ = 0x03;
                else
319
                    *q++ = 0; /* undefined type */
320 321 322 323 324 325

                    *len_ptr += 4;
                }

                if (*len_ptr == 0)
                    q -= 2; /* no language codes were written */
326 327
            }
            break;
328
        case AVMEDIA_TYPE_SUBTITLE:
329 330
            {
                const char *language;
331
                language = lang && strlen(lang->value)==3 ? lang->value : "eng";
332 333 334 335 336 337
                *q++ = 0x59;
                *q++ = 8;
                *q++ = language[0];
                *q++ = language[1];
                *q++ = language[2];
                *q++ = 0x10; /* normal subtitles (0x20 = if hearing pb) */
338 339 340 341
                if(st->codec->extradata_size == 4) {
                    memcpy(q, st->codec->extradata, 4);
                    q += 4;
                } else {
Tomas Härdin's avatar
Tomas Härdin committed
342 343
                    put16(&q, 1); /* page id */
                    put16(&q, 1); /* ancillary page id */
344
                }
345 346
            }
            break;
347
        case AVMEDIA_TYPE_VIDEO:
348 349 350 351 352 353 354 355 356
            if (stream_type == STREAM_TYPE_VIDEO_DIRAC) {
                *q++ = 0x05; /*MPEG-2 registration descriptor*/
                *q++ = 4;
                *q++ = 'd';
                *q++ = 'r';
                *q++ = 'a';
                *q++ = 'c';
            }
            break;
357
        }
358 359 360 361 362 363 364

        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);
365
}
366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389

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

391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412
    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 */
413
        val = (running_status << 13) | (free_ca_mode << 12) |
414 415 416 417 418 419 420 421
            (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);
}

422 423 424
static MpegTSService *mpegts_add_service(MpegTSWrite *ts,
                                         int sid,
                                         const char *provider_name,
425 426 427 428 429 430 431
                                         const char *name)
{
    MpegTSService *service;

    service = av_mallocz(sizeof(MpegTSService));
    if (!service)
        return NULL;
432
    service->pmt.pid = ts->pmt_start_pid + ts->nb_services;
433 434 435 436 437 438 439 440 441 442 443
    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;
444
    avio_write(ctx->pb, packet, TS_PACKET_SIZE);
445 446 447 448 449 450 451
}

static int mpegts_write_header(AVFormatContext *s)
{
    MpegTSWrite *ts = s->priv_data;
    MpegTSWriteStream *ts_st;
    MpegTSService *service;
452
    AVStream *st, *pcr_st = NULL;
453
    AVDictionaryEntry *title, *provider;
454
    int i, j;
455
    const char *service_name;
456
    const char *provider_name;
457
    int *pids;
458

459 460 461
    // round up to a whole number of TS packets
    ts->pes_payload_size = (ts->pes_payload_size + 14 + 183) / 184 * 184 - 14;

462 463
    ts->tsid = ts->transport_stream_id;
    ts->onid = ts->original_network_id;
464
    /* allocate a single DVB service */
465
    title = av_dict_get(s->metadata, "service_name", NULL, 0);
466
    if (!title)
467
        title = av_dict_get(s->metadata, "title", NULL, 0);
468
    service_name = title ? title->value : DEFAULT_SERVICE_NAME;
469
    provider = av_dict_get(s->metadata, "service_provider", NULL, 0);
470
    provider_name = provider ? provider->value : DEFAULT_PROVIDER_NAME;
471
    service = mpegts_add_service(ts, ts->service_id, provider_name, service_name);
472 473
    service->pmt.write_packet = section_write_packet;
    service->pmt.opaque = s;
474
    service->pmt.cc = 15;
475 476

    ts->pat.pid = PAT_PID;
477
    ts->pat.cc = 15; // Initialize at 15 so that it wraps and be equal to 0 for the first packet we write
478 479 480 481
    ts->pat.write_packet = section_write_packet;
    ts->pat.opaque = s;

    ts->sdt.pid = SDT_PID;
482
    ts->sdt.cc = 15;
483 484 485
    ts->sdt.write_packet = section_write_packet;
    ts->sdt.opaque = s;

486
    pids = av_malloc(s->nb_streams * sizeof(*pids));
487 488 489
    if (!pids)
        return AVERROR(ENOMEM);

490 491 492
    /* assign pids to each stream */
    for(i = 0;i < s->nb_streams; i++) {
        st = s->streams[i];
493
        avpriv_set_pts_info(st, 33, 1, 90000);
494 495 496 497
        ts_st = av_mallocz(sizeof(MpegTSWriteStream));
        if (!ts_st)
            goto fail;
        st->priv_data = ts_st;
498 499 500
        ts_st->payload = av_mallocz(ts->pes_payload_size);
        if (!ts_st->payload)
            goto fail;
501
        ts_st->service = service;
502 503 504
        /* MPEG pid values < 16 are reserved. Applications which set st->id in
         * this range are assigned a calculated pid. */
        if (st->id < 16) {
505
            ts_st->pid = ts->start_pid + i;
506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521
        } else if (st->id < 0x1FFF) {
            ts_st->pid = st->id;
        } else {
            av_log(s, AV_LOG_ERROR, "Invalid stream id %d, must be less than 8191\n", st->id);
            goto fail;
        }
        if (ts_st->pid == service->pmt.pid) {
            av_log(s, AV_LOG_ERROR, "Duplicate stream id %d\n", ts_st->pid);
            goto fail;
        }
        for (j = 0; j < i; j++)
            if (pids[j] == ts_st->pid) {
                av_log(s, AV_LOG_ERROR, "Duplicate stream id %d\n", ts_st->pid);
                goto fail;
            }
        pids[i] = ts_st->pid;
522
        ts_st->payload_pts = AV_NOPTS_VALUE;
523
        ts_st->payload_dts = AV_NOPTS_VALUE;
524
        ts_st->first_pts_check = 1;
525
        ts_st->cc = 15;
526
        /* update PCR pid by using the first video stream */
527
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
528
            service->pcr_pid == 0x1fff) {
529
            service->pcr_pid = ts_st->pid;
530
            pcr_st = st;
531
        }
532 533 534 535
        if (st->codec->codec_id == CODEC_ID_AAC &&
            st->codec->extradata_size > 0) {
            ts_st->adts = av_mallocz(sizeof(*ts_st->adts));
            if (!ts_st->adts)
536
                goto fail;
537 538
            if (ff_adts_decode_extradata(s, ts_st->adts, st->codec->extradata,
                                         st->codec->extradata_size) < 0)
539
                goto fail;
540
        }
541
    }
542

543 544
    av_free(pids);

545 546
    /* if no video stream, use the first stream as PCR */
    if (service->pcr_pid == 0x1fff && s->nb_streams > 0) {
547 548
        pcr_st = s->streams[0];
        ts_st = pcr_st->priv_data;
549 550 551
        service->pcr_pid = ts_st->pid;
    }

552
    if (ts->mux_rate > 1) {
Baptiste Coudurier's avatar
Baptiste Coudurier committed
553 554 555 556 557 558 559
        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);

560
        ts->first_pcr = av_rescale(s->max_delay, PCR_TIME_BASE, AV_TIME_BASE);
561 562 563 564
    } else {
        /* Arbitrary values, PAT/PMT could be written on key frames */
        ts->sdt_packet_period = 200;
        ts->pat_packet_period = 40;
565
        if (pcr_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
566 567 568 569 570 571 572 573 574 575 576 577 578 579 580
            if (!pcr_st->codec->frame_size) {
                av_log(s, AV_LOG_WARNING, "frame size not set\n");
                service->pcr_packet_period =
                    pcr_st->codec->sample_rate/(10*512);
            } else {
                service->pcr_packet_period =
                    pcr_st->codec->sample_rate/(10*pcr_st->codec->frame_size);
            }
        } else {
            // max delta PCR 0.1s
            service->pcr_packet_period =
                pcr_st->codec->time_base.den/(10*pcr_st->codec->time_base.num);
        }
    }

581 582
    // output a PCR as soon as possible
    service->pcr_packet_count = service->pcr_packet_period;
583 584
    ts->pat_packet_count = ts->pat_packet_period-1;
    ts->sdt_packet_count = ts->sdt_packet_period-1;
585

586 587 588 589 590
    if (ts->mux_rate == 1)
        av_log(s, AV_LOG_INFO, "muxrate VBR, ");
    else
        av_log(s, AV_LOG_INFO, "muxrate %d, ", ts->mux_rate);
    av_log(s, AV_LOG_INFO, "pcr every %d pkts, "
591
           "sdt every %d, pat/pmt every %d pkts\n",
592
           service->pcr_packet_period,
593
           ts->sdt_packet_period, ts->pat_packet_period);
594

595
    avio_flush(s->pb);
596 597 598 599

    return 0;

 fail:
600
    av_free(pids);
601
    for(i = 0;i < s->nb_streams; i++) {
602
        MpegTSWriteStream *ts_st;
603
        st = s->streams[i];
604 605 606 607 608
        ts_st = st->priv_data;
        if (ts_st) {
            av_freep(&ts_st->payload);
            av_freep(&ts_st->adts);
        }
609
        av_freep(&st->priv_data);
610 611 612 613 614 615 616 617 618 619
    }
    return -1;
}

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

620
    if (++ts->sdt_packet_count == ts->sdt_packet_period) {
621 622 623
        ts->sdt_packet_count = 0;
        mpegts_write_sdt(s);
    }
624
    if (++ts->pat_packet_count == ts->pat_packet_period) {
625 626 627 628 629 630 631 632
        ts->pat_packet_count = 0;
        mpegts_write_pat(s);
        for(i = 0; i < ts->nb_services; i++) {
            mpegts_write_pmt(s, ts->services[i]);
        }
    }
}

633
static int64_t get_pcr(const MpegTSWrite *ts, AVIOContext *pb)
634
{
635
    return av_rescale(avio_tell(pb) + 11, 8 * PCR_TIME_BASE, ts->mux_rate) +
636 637 638
           ts->first_pcr;
}

639
static int write_pcr_bits(uint8_t *buf, int64_t pcr)
640 641 642 643 644 645 646
{
    int64_t pcr_low = pcr % 300, pcr_high = pcr / 300;

    *buf++ = pcr_high >> 25;
    *buf++ = pcr_high >> 17;
    *buf++ = pcr_high >> 9;
    *buf++ = pcr_high >> 1;
647
    *buf++ = pcr_high << 7 | pcr_low >> 8 | 0x7e;
648 649
    *buf++ = pcr_low;

650
    return 6;
651 652
}

653 654 655 656 657 658 659 660 661 662 663 664
/* Write a single null transport stream packet */
static void mpegts_insert_null_packet(AVFormatContext *s)
{
    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));
665
    avio_write(s->pb, buf, TS_PACKET_SIZE);
666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685
}

/* 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;
    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 */
686
    q += write_pcr_bits(q, get_pcr(ts, s->pb));
687 688 689

    /* stuffing bytes */
    memset(q, 0xFF, TS_PACKET_SIZE - (q - buf));
690
    avio_write(s->pb, buf, TS_PACKET_SIZE);
691 692
}

693 694 695 696 697 698 699 700 701 702 703 704 705 706
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;
}

707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739
/* Set an adaptation field flag in an MPEG-TS packet*/
static void set_af_flag(uint8_t *pkt, int flag)
{
    // expect at least one flag to set
    assert(flag);

    if ((pkt[3] & 0x20) == 0) {
        // no AF yet, set adaptation field flag
        pkt[3] |= 0x20;
        // 1 byte length, no flags
        pkt[4] = 1;
        pkt[5] = 0;
    }
    pkt[5] |= flag;
}

/* Extend the adaptation field by size bytes */
static void extend_af(uint8_t *pkt, int size)
{
    // expect already existing adaptation field
    assert(pkt[3] & 0x20);
    pkt[4] += size;
}

/* Get a pointer to MPEG-TS payload (right after TS packet header) */
static uint8_t *get_ts_payload_start(uint8_t *pkt)
{
    if (pkt[3] & 0x20)
        return pkt + 5 + pkt[4];
    else
        return pkt + 4;
}

740 741 742 743 744
/* 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.
 */
745 746
static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
                             const uint8_t *payload, int payload_size,
747
                             int64_t pts, int64_t dts, int key)
748 749
{
    MpegTSWriteStream *ts_st = st->priv_data;
750
    MpegTSWrite *ts = s->priv_data;
751
    uint8_t buf[TS_PACKET_SIZE];
752
    uint8_t *q;
753
    int val, is_start, len, header_len, write_pcr, private_code, flags;
754 755
    int afc_len, stuffing_len;
    int64_t pcr = -1; /* avoid warning */
756
    int64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE);
757

758 759 760
    is_start = 1;
    while (payload_size > 0) {
        retransmit_si_info(s);
761

762 763
        write_pcr = 0;
        if (ts_st->pid == ts_st->service->pcr_pid) {
764 765
            if (ts->mux_rate > 1 || is_start) // VBR pcr period is based on frames
                ts_st->service->pcr_packet_count++;
766
            if (ts_st->service->pcr_packet_count >=
767
                ts_st->service->pcr_packet_period) {
768 769 770 771 772
                ts_st->service->pcr_packet_count = 0;
                write_pcr = 1;
            }
        }

773
        if (ts->mux_rate > 1 && dts != AV_NOPTS_VALUE &&
774
            (dts - get_pcr(ts, s->pb)/300) > delay) {
775 776 777 778 779 780 781 782
            /* 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 */
        }

783 784 785 786 787 788 789 790 791
        /* 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;
792 793 794 795 796 797 798 799
        *q++ = 0x10 | ts_st->cc; // payload indicator + CC
        if (key && is_start && pts != AV_NOPTS_VALUE) {
            // set Random Access for key frames
            if (ts_st->pid == ts_st->service->pcr_pid)
                write_pcr = 1;
            set_af_flag(buf, 0x40);
            q = get_ts_payload_start(buf);
        }
800
        if (write_pcr) {
801 802
            set_af_flag(buf, 0x10);
            q = get_ts_payload_start(buf);
803
            // add 11, pcr references the last byte of program clock reference base
804
            if (ts->mux_rate > 1)
805
                pcr = get_pcr(ts, s->pb);
806
            else
807 808
                pcr = (dts - delay)*300;
            if (dts != AV_NOPTS_VALUE && dts < pcr / 300)
809
                av_log(s, AV_LOG_WARNING, "dts < pcr, TS is invalid\n");
810 811
            extend_af(buf, write_pcr_bits(q, pcr));
            q = get_ts_payload_start(buf);
812
        }
813
        if (is_start) {
814
            int pes_extension = 0;
815 816 817 818
            /* write PES header */
            *q++ = 0x00;
            *q++ = 0x00;
            *q++ = 0x01;
819
            private_code = 0;
820
            if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
821 822 823 824
                if (st->codec->codec_id == CODEC_ID_DIRAC) {
                    *q++ = 0xfd;
                } else
                    *q++ = 0xe0;
825
            } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
826
                       (st->codec->codec_id == CODEC_ID_MP2 ||
827 828
                        st->codec->codec_id == CODEC_ID_MP3 ||
                        st->codec->codec_id == CODEC_ID_AAC)) {
829
                *q++ = 0xc0;
830 831
            } else {
                *q++ = 0xbd;
832
                if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
833 834 835
                    private_code = 0x20;
                }
            }
836 837 838 839 840 841
            header_len = 0;
            flags = 0;
            if (pts != AV_NOPTS_VALUE) {
                header_len += 5;
                flags |= 0x80;
            }
842
            if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
843 844 845
                header_len += 5;
                flags |= 0x40;
            }
846
            if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
847 848 849 850 851 852 853 854 855 856 857 858
                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;
            }
859
            len = payload_size + header_len + 3;
860
            if (private_code != 0)
861
                len++;
862 863
            if (len > 0xffff)
                len = 0;
864 865
            *q++ = len >> 8;
            *q++ = len;
866 867
            val = 0x80;
            /* data alignment indicator is required for subtitle data */
868
            if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
869 870
                val |= 0x04;
            *q++ = val;
871 872
            *q++ = flags;
            *q++ = header_len;
873
            if (pts != AV_NOPTS_VALUE) {
874 875 876
                write_pts(q, flags >> 6, pts);
                q += 5;
            }
877
            if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
878 879
                write_pts(q, 1, dts);
                q += 5;
880
            }
881 882 883 884 885 886 887 888 889 890
            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;
            }
891 892
            if (private_code != 0)
                *q++ = private_code;
893
            is_start = 0;
894
        }
895 896 897 898
        /* header size */
        header_len = q - buf;
        /* data len */
        len = TS_PACKET_SIZE - header_len;
899 900
        if (len > payload_size)
            len = payload_size;
901 902 903 904 905 906 907
        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,
908
                        buf + 4 + afc_len,
909 910 911 912 913 914 915 916 917 918 919 920 921 922 923
                        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);
924 925
        payload += len;
        payload_size -= len;
926
        avio_write(s->pb, buf, TS_PACKET_SIZE);
927
    }
928
    avio_flush(s->pb);
929 930
}

931
static int mpegts_write_packet(AVFormatContext *s, AVPacket *pkt)
932
{
933
    AVStream *st = s->streams[pkt->stream_index];
934
    int size = pkt->size;
935
    uint8_t *buf= pkt->data;
936
    uint8_t *data= NULL;
937
    MpegTSWrite *ts = s->priv_data;
938
    MpegTSWriteStream *ts_st = st->priv_data;
939
    const uint64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE)*2;
940 941 942 943 944 945
    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;
946

947 948 949 950 951 952
    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;

953
    if (st->codec->codec_id == CODEC_ID_H264) {
954 955 956
        const uint8_t *p = buf, *buf_end = p+size;
        uint32_t state = -1;

957
        if (pkt->size < 5 || AV_RB32(pkt->data) != 0x0000001) {
958
            av_log(s, AV_LOG_ERROR, "H.264 bitstream malformed, "
Mike Melanson's avatar
Mike Melanson committed
959
                   "no startcode found, use -bsf h264_mp4toannexb\n");
960 961
            return -1;
        }
962 963

        do {
964
            p = avpriv_mpv_find_start_code(p, buf_end, &state);
965 966 967 968 969
            //av_log(s, AV_LOG_INFO, "nal %d\n", state & 0x1f);
        } while (p < buf_end && (state & 0x1f) != 9 &&
                 (state & 0x1f) != 5 && (state & 0x1f) != 1);

        if ((state & 0x1f) != 9) { // AUD NAL
970 971 972 973 974 975
            data = av_malloc(pkt->size+6);
            if (!data)
                return -1;
            memcpy(data+6, pkt->data, pkt->size);
            AV_WB32(data, 0x00000001);
            data[4] = 0x09;
976
            data[5] = 0xf0; // any slice type (0xe) + rbsp stop one bit
977 978 979
            buf  = data;
            size = pkt->size+6;
        }
980 981 982 983 984
    } else if (st->codec->codec_id == CODEC_ID_AAC) {
        if (pkt->size < 2)
            return -1;
        if ((AV_RB16(pkt->data) & 0xfff0) != 0xfff0) {
            ADTSContext *adts = ts_st->adts;
985
            int new_size, err;
986 987 988 989 990 991 992 993 994 995
            if (!adts) {
                av_log(s, AV_LOG_ERROR, "aac bitstream not in adts format "
                       "and extradata missing\n");
                return -1;
            }
            new_size = ADTS_HEADER_SIZE+adts->pce_size+pkt->size;
            if ((unsigned)new_size >= INT_MAX)
                return -1;
            data = av_malloc(new_size);
            if (!data)
996
                return AVERROR(ENOMEM);
997 998 999 1000 1001 1002
            err = ff_adts_write_frame_header(adts, data, pkt->size,
                                             adts->pce_size);
            if (err < 0) {
                av_free(data);
                return err;
            }
1003 1004 1005 1006 1007 1008 1009 1010
            if (adts->pce_size) {
                memcpy(data+ADTS_HEADER_SIZE, adts->pce_data, adts->pce_size);
                adts->pce_size = 0;
            }
            memcpy(data+ADTS_HEADER_SIZE+adts->pce_size, pkt->data, pkt->size);
            buf = data;
            size = new_size;
        }
1011 1012
    }

1013
    if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
1014
        // for video and subtitle, write a single pes packet
1015
        mpegts_write_pes(s, st, buf, size, pts, dts, pkt->flags & AV_PKT_FLAG_KEY);
1016
        av_free(data);
1017 1018 1019
        return 0;
    }

1020
    if (ts_st->payload_size + size > ts->pes_payload_size) {
1021 1022 1023 1024 1025 1026
        if (ts_st->payload_size) {
            mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_size,
                             ts_st->payload_pts, ts_st->payload_dts,
                             ts_st->payload_flags & AV_PKT_FLAG_KEY);
            ts_st->payload_size = 0;
        }
1027
        if (size > ts->pes_payload_size) {
1028 1029 1030 1031 1032
            mpegts_write_pes(s, st, buf, size, pts, dts,
                             pkt->flags & AV_PKT_FLAG_KEY);
            av_free(data);
            return 0;
        }
1033 1034
    }

1035
    if (!ts_st->payload_size) {
1036 1037
        ts_st->payload_pts = pts;
        ts_st->payload_dts = dts;
1038
        ts_st->payload_flags = pkt->flags;
1039
    }
1040

1041 1042
    memcpy(ts_st->payload + ts_st->payload_size, buf, size);
    ts_st->payload_size += size;
1043

1044 1045
    av_free(data);

1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
    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;
1061 1062
        if (ts_st->payload_size > 0) {
            mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_size,
1063 1064
                             ts_st->payload_pts, ts_st->payload_dts,
                             ts_st->payload_flags & AV_PKT_FLAG_KEY);
1065
        }
1066
        av_freep(&ts_st->payload);
1067
        av_freep(&ts_st->adts);
1068
    }
1069
    avio_flush(s->pb);
1070

1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
    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;
}

1082
AVOutputFormat ff_mpegts_muxer = {
1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
    .name              = "mpegts",
    .long_name         = NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
    .mime_type         = "video/x-mpegts",
    .extensions        = "ts,m2t",
    .priv_data_size    = sizeof(MpegTSWrite),
    .audio_codec       = CODEC_ID_MP2,
    .video_codec       = CODEC_ID_MPEG2VIDEO,
    .write_header      = mpegts_write_header,
    .write_packet      = mpegts_write_packet,
    .write_trailer     = mpegts_write_end,
1093
    .priv_class = &mpegts_muxer_class,
1094
};