mpegts.c 44.2 KB
Newer Older
1
/*
2
 * MPEG2 transport stream (aka DVB) demuxer
3
 * Copyright (c) 2002-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
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21 22

#include "libavutil/crc.h"
23
#include "libavutil/intreadwrite.h"
24
#include "libavcodec/bytestream.h"
25
#include "avformat.h"
26
#include "mpegts.h"
27
#include "internal.h"
28

29
//#define DEBUG
Fabrice Bellard's avatar
Fabrice Bellard committed
30
//#define DEBUG_SEEK
31 32

/* 1.0 second at 24Mbit/s */
33 34 35 36 37
#define MAX_SCAN_PACKETS 32000

/* maximum size in which we look for synchronisation if
   synchronisation is lost */
#define MAX_RESYNC_SIZE 4096
38
#define REGISTRATION_DESCRIPTOR 5
39

40 41
typedef struct PESContext PESContext;

42
static PESContext* add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid, int stream_type);
43
static AVStream* new_pes_av_stream(PESContext *pes, uint32_t code);
44 45 46 47

enum MpegTSFilterType {
    MPEGTS_PES,
    MPEGTS_SECTION,
48 49
};

50 51
typedef struct MpegTSFilter MpegTSFilter;

52
typedef void PESCallback(MpegTSFilter *f, const uint8_t *buf, int len, int is_start, int64_t pos);
53

54 55 56 57 58
typedef struct MpegTSPESFilter {
    PESCallback *pes_cb;
    void *opaque;
} MpegTSPESFilter;

59
typedef void SectionCallback(MpegTSFilter *f, const uint8_t *buf, int len);
60 61 62 63 64 65 66

typedef void SetServiceCallback(void *opaque, int ret);

typedef struct MpegTSSectionFilter {
    int section_index;
    int section_h_size;
    uint8_t *section_buf;
67 68
    unsigned int check_crc:1;
    unsigned int end_of_section_reached:1;
69 70 71 72
    SectionCallback *section_cb;
    void *opaque;
} MpegTSSectionFilter;

73
struct MpegTSFilter {
74 75
    int pid;
    int last_cc; /* last cc code (-1 if first packet) */
76 77 78 79 80
    enum MpegTSFilterType type;
    union {
        MpegTSPESFilter pes_filter;
        MpegTSSectionFilter section_filter;
    } u;
81
};
82

83
#define MAX_PIDS_PER_PROGRAM 64
84
struct Program {
85 86 87
    unsigned int id; //program id/service id
    unsigned int nb_pids;
    unsigned int pids[MAX_PIDS_PER_PROGRAM];
88
};
89

90
struct MpegTSContext {
91 92
    /* user data */
    AVFormatContext *stream;
93 94
    /** raw packet size, including FEC if present            */
    int raw_packet_size;
95 96 97

    int pos47;

98 99
    /** if true, all pids are analyzed to find streams       */
    int auto_guess;
100

101 102
    /** compute exact PCR for each transport stream packet   */
    int mpeg2ts_compute_pcr;
103

104 105
    int64_t cur_pcr;    /**< used to estimate the exact PCR  */
    int pcr_incr;       /**< used to estimate the exact PCR  */
106

107
    /* data needed to handle file based ts */
108 109 110 111
    /** stop parsing loop                                    */
    int stop_parse;
    /** packet containing Audio/Video data                   */
    AVPacket *pkt;
112 113 114 115

    /******************************************/
    /* private mpegts data */
    /* scan context */
116 117
    /** structure to keep track of Program->pids mapping     */
    unsigned int nb_prg;
118
    struct Program *prg;
119

120

121
    /** filters for various streams specified by PMT + for the PAT and PMT */
122
    MpegTSFilter *pids[NB_PID_MAX];
123
};
124

125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
/* TS stream handling */

enum MpegTSState {
    MPEGTS_HEADER = 0,
    MPEGTS_PESHEADER_FILL,
    MPEGTS_PAYLOAD,
    MPEGTS_SKIP,
};

/* enough for PES header + length */
#define PES_START_SIZE 9
#define MAX_PES_HEADER_SIZE (9 + 255)

struct PESContext {
    int pid;
140
    int pcr_pid; /**< if -1 then all packets containing PCR are considered */
141 142 143 144 145 146 147 148 149 150
    int stream_type;
    MpegTSContext *ts;
    AVFormatContext *stream;
    AVStream *st;
    enum MpegTSState state;
    /* used to get the format */
    int data_index;
    int total_size;
    int pes_header_size;
    int64_t pts, dts;
151
    int64_t ts_packet_pos; /**< position of first TS packet of this PES packet */
152 153 154
    uint8_t header[MAX_PES_HEADER_SIZE];
};

155 156
extern AVInputFormat mpegts_demuxer;

157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
static void clear_program(MpegTSContext *ts, unsigned int programid)
{
    int i;

    for(i=0; i<ts->nb_prg; i++)
        if(ts->prg[i].id == programid)
            ts->prg[i].nb_pids = 0;
}

static void clear_programs(MpegTSContext *ts)
{
    av_freep(&ts->prg);
    ts->nb_prg=0;
}

static void add_pat_entry(MpegTSContext *ts, unsigned int programid)
{
174 175
    struct Program *p;
    void *tmp = av_realloc(ts->prg, (ts->nb_prg+1)*sizeof(struct Program));
176 177 178 179 180 181 182 183 184 185 186 187
    if(!tmp)
        return;
    ts->prg = tmp;
    p = &ts->prg[ts->nb_prg];
    p->id = programid;
    p->nb_pids = 0;
    ts->nb_prg++;
}

static void add_pid_to_pmt(MpegTSContext *ts, unsigned int programid, unsigned int pid)
{
    int i;
188
    struct Program *p = NULL;
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
    for(i=0; i<ts->nb_prg; i++) {
        if(ts->prg[i].id == programid) {
            p = &ts->prg[i];
            break;
        }
    }
    if(!p)
        return;

    if(p->nb_pids >= MAX_PIDS_PER_PROGRAM)
        return;
    p->pids[p->nb_pids++] = pid;
}

/**
 * \brief discard_pid() decides if the pid is to be discarded according
 *                      to caller's programs selection
 * \param ts    : - TS context
 * \param pid   : - pid
 * \return 1 if the pid is only comprised in programs that have .discard=AVDISCARD_ALL
 *         0 otherwise
 */
static int discard_pid(MpegTSContext *ts, unsigned int pid)
{
    int i, j, k;
    int used = 0, discarded = 0;
215
    struct Program *p;
216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
    for(i=0; i<ts->nb_prg; i++) {
        p = &ts->prg[i];
        for(j=0; j<p->nb_pids; j++) {
            if(p->pids[j] != pid)
                continue;
            //is program with id p->id set to be discarded?
            for(k=0; k<ts->stream->nb_programs; k++) {
                if(ts->stream->programs[k]->id == p->id) {
                    if(ts->stream->programs[k]->discard == AVDISCARD_ALL)
                        discarded++;
                    else
                        used++;
                }
            }
        }
    }

233
    return !used && discarded;
234 235
}

236 237 238 239
/**
 *  Assembles PES packets out of TS packets, and then calls the "section_cb"
 *  function when they are complete.
 */
240 241 242 243 244
static void write_section_data(AVFormatContext *s, MpegTSFilter *tss1,
                               const uint8_t *buf, int buf_size, int is_start)
{
    MpegTSSectionFilter *tss = &tss1->u.section_filter;
    int len;
245

246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
    if (is_start) {
        memcpy(tss->section_buf, buf, buf_size);
        tss->section_index = buf_size;
        tss->section_h_size = -1;
        tss->end_of_section_reached = 0;
    } else {
        if (tss->end_of_section_reached)
            return;
        len = 4096 - tss->section_index;
        if (buf_size < len)
            len = buf_size;
        memcpy(tss->section_buf + tss->section_index, buf, len);
        tss->section_index += len;
    }

    /* compute section length if possible */
    if (tss->section_h_size == -1 && tss->section_index >= 3) {
263
        len = (AV_RB16(tss->section_buf + 1) & 0xfff) + 3;
264 265 266 267 268 269 270
        if (len > 4096)
            return;
        tss->section_h_size = len;
    }

    if (tss->section_h_size != -1 && tss->section_index >= tss->section_h_size) {
        tss->end_of_section_reached = 1;
271
        if (!tss->check_crc ||
Aurelien Jacobs's avatar
Aurelien Jacobs committed
272 273
            av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1,
                   tss->section_buf, tss->section_h_size) == 0)
274
            tss->section_cb(tss1, tss->section_buf, tss->section_h_size);
275 276 277
    }
}

278
static MpegTSFilter *mpegts_open_section_filter(MpegTSContext *ts, unsigned int pid,
279 280 281 282 283 284
                                         SectionCallback *section_cb, void *opaque,
                                         int check_crc)

{
    MpegTSFilter *filter;
    MpegTSSectionFilter *sec;
285

286 287
    dprintf(ts->stream, "Filter: pid=0x%x\n", pid);

288 289 290
    if (pid >= NB_PID_MAX || ts->pids[pid])
        return NULL;
    filter = av_mallocz(sizeof(MpegTSFilter));
291
    if (!filter)
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308
        return NULL;
    ts->pids[pid] = filter;
    filter->type = MPEGTS_SECTION;
    filter->pid = pid;
    filter->last_cc = -1;
    sec = &filter->u.section_filter;
    sec->section_cb = section_cb;
    sec->opaque = opaque;
    sec->section_buf = av_malloc(MAX_SECTION_SIZE);
    sec->check_crc = check_crc;
    if (!sec->section_buf) {
        av_free(filter);
        return NULL;
    }
    return filter;
}

309
static MpegTSFilter *mpegts_open_pes_filter(MpegTSContext *ts, unsigned int pid,
310 311 312 313 314 315 316 317 318
                                     PESCallback *pes_cb,
                                     void *opaque)
{
    MpegTSFilter *filter;
    MpegTSPESFilter *pes;

    if (pid >= NB_PID_MAX || ts->pids[pid])
        return NULL;
    filter = av_mallocz(sizeof(MpegTSFilter));
319
    if (!filter)
320 321 322 323 324 325 326 327 328 329 330
        return NULL;
    ts->pids[pid] = filter;
    filter->type = MPEGTS_PES;
    filter->pid = pid;
    filter->last_cc = -1;
    pes = &filter->u.pes_filter;
    pes->pes_cb = pes_cb;
    pes->opaque = opaque;
    return filter;
}

331
static void mpegts_close_filter(MpegTSContext *ts, MpegTSFilter *filter)
332 333 334 335 336 337
{
    int pid;

    pid = filter->pid;
    if (filter->type == MPEGTS_SECTION)
        av_freep(&filter->u.section_filter.section_buf);
338 339 340 341 342 343 344
    else if (filter->type == MPEGTS_PES) {
        /* referenced private data will be freed later in
         * av_close_input_stream */
        if (!((PESContext *)filter->u.pes_filter.opaque)->st) {
            av_freep(&filter->u.pes_filter.opaque);
        }
    }
345

346 347 348 349
    av_free(filter);
    ts->pids[pid] = NULL;
}

350 351 352 353 354 355 356 357
static int analyze(const uint8_t *buf, int size, int packet_size, int *index){
    int stat[packet_size];
    int i;
    int x=0;
    int best_score=0;

    memset(stat, 0, packet_size*sizeof(int));

358 359
    for(x=i=0; i<size-3; i++){
        if(buf[i] == 0x47 && !(buf[i+1] & 0x80) && (buf[i+3] & 0x30)){
360 361 362 363 364 365 366 367 368 369 370 371 372 373
            stat[x]++;
            if(stat[x] > best_score){
                best_score= stat[x];
                if(index) *index= x;
            }
        }

        x++;
        if(x == packet_size) x= 0;
    }

    return best_score;
}

374
/* autodetect fec presence. Must have at least 1024 bytes  */
375
static int get_packet_size(const uint8_t *buf, int size)
376
{
377
    int score, fec_score, dvhs_score;
378 379 380

    if (size < (TS_FEC_PACKET_SIZE * 5 + 1))
        return -1;
381

382
    score    = analyze(buf, size, TS_PACKET_SIZE, NULL);
383
    dvhs_score    = analyze(buf, size, TS_DVHS_PACKET_SIZE, NULL);
384
    fec_score= analyze(buf, size, TS_FEC_PACKET_SIZE, NULL);
385
//    av_log(NULL, AV_LOG_DEBUG, "score: %d, dvhs_score: %d, fec_score: %d \n", score, dvhs_score, fec_score);
386

387 388 389
    if     (score > fec_score && score > dvhs_score) return TS_PACKET_SIZE;
    else if(dvhs_score > score && dvhs_score > fec_score) return TS_DVHS_PACKET_SIZE;
    else if(score < fec_score && dvhs_score < fec_score) return TS_FEC_PACKET_SIZE;
390
    else                       return -1;
391 392
}

393 394 395 396 397 398 399 400 401
typedef struct SectionHeader {
    uint8_t tid;
    uint16_t id;
    uint8_t version;
    uint8_t sec_num;
    uint8_t last_sec_num;
} SectionHeader;

static inline int get8(const uint8_t **pp, const uint8_t *p_end)
402
{
403 404 405 406 407 408 409 410 411
    const uint8_t *p;
    int c;

    p = *pp;
    if (p >= p_end)
        return -1;
    c = *p++;
    *pp = p;
    return c;
412 413
}

414 415 416 417 418 419 420 421
static inline int get16(const uint8_t **pp, const uint8_t *p_end)
{
    const uint8_t *p;
    int c;

    p = *pp;
    if ((p + 1) >= p_end)
        return -1;
422
    c = AV_RB16(p);
423 424 425 426 427 428 429
    p += 2;
    *pp = p;
    return c;
}

/* read and allocate a DVB string preceeded by its length */
static char *getstr8(const uint8_t **pp, const uint8_t *p_end)
430 431
{
    int len;
432 433
    const uint8_t *p;
    char *str;
434

435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450
    p = *pp;
    len = get8(&p, p_end);
    if (len < 0)
        return NULL;
    if ((p + len) > p_end)
        return NULL;
    str = av_malloc(len + 1);
    if (!str)
        return NULL;
    memcpy(str, p, len);
    str[len] = '\0';
    p += len;
    *pp = p;
    return str;
}

451
static int parse_section_header(SectionHeader *h,
452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476
                                const uint8_t **pp, const uint8_t *p_end)
{
    int val;

    val = get8(pp, p_end);
    if (val < 0)
        return -1;
    h->tid = val;
    *pp += 2;
    val = get16(pp, p_end);
    if (val < 0)
        return -1;
    h->id = val;
    val = get8(pp, p_end);
    if (val < 0)
        return -1;
    h->version = (val >> 1) & 0x1f;
    val = get8(pp, p_end);
    if (val < 0)
        return -1;
    h->sec_num = val;
    val = get8(pp, p_end);
    if (val < 0)
        return -1;
    h->last_sec_num = val;
477
    return 0;
478 479 480
}


481
static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
482
{
483
    MpegTSContext *ts = filter->u.section_filter.opaque;
484
    SectionHeader h1, *h = &h1;
485 486 487 488 489
    PESContext *pes;
    AVStream *st;
    const uint8_t *p, *p_end, *desc_list_end, *desc_end;
    int program_info_length, pcr_pid, pid, stream_type;
    int desc_list_len, desc_len, desc_tag;
490
    int comp_page = 0, anc_page = 0; /* initialize to kill warnings */
491
    char language[4] = {0}; /* initialize to kill warnings */
492
    int has_hdmv_descr = 0;
493
    int has_dirac_descr = 0;
494
    uint32_t reg_desc = 0; /* registration descriptor */
495

496 497
#ifdef DEBUG
    dprintf(ts->stream, "PMT: len %i\n", section_len);
498
    av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
499
#endif
500

501 502 503 504
    p_end = section + section_len - 4;
    p = section;
    if (parse_section_header(h, &p, p_end) < 0)
        return;
505 506

    dprintf(ts->stream, "sid=0x%x sec_num=%d/%d\n",
507
           h->id, h->sec_num, h->last_sec_num);
508

509
    if (h->tid != PMT_TID)
510 511
        return;

512
    clear_program(ts, h->id);
513 514 515
    pcr_pid = get16(&p, p_end) & 0x1fff;
    if (pcr_pid < 0)
        return;
516
    add_pid_to_pmt(ts, h->id, pcr_pid);
517 518 519

    dprintf(ts->stream, "pcr_pid=0x%x\n", pcr_pid);

520 521 522
    program_info_length = get16(&p, p_end) & 0xfff;
    if (program_info_length < 0)
        return;
523 524 525 526 527 528 529 530 531
    while(program_info_length >= 2) {
        uint8_t tag, len;
        tag = get8(&p, p_end);
        len = get8(&p, p_end);
        if(len > program_info_length - 2)
            //something else is broken, exit the program_descriptors_loop
            break;
        program_info_length -= len + 2;
        if(tag == REGISTRATION_DESCRIPTOR && len >= 4) {
532
            reg_desc = bytestream_get_le32(&p);
533
            len -= 4;
534
            if(reg_desc == AV_RL32("HDMV"))
535 536 537 538
                has_hdmv_descr = 1;
        }
        p += len;
    }
539 540 541 542
    p += program_info_length;
    if (p >= p_end)
        return;
    for(;;) {
543 544
        language[0] = 0;
        st = 0;
545 546 547 548 549 550
        stream_type = get8(&p, p_end);
        if (stream_type < 0)
            break;
        pid = get16(&p, p_end) & 0x1fff;
        if (pid < 0)
            break;
551 552 553 554
        desc_list_len = get16(&p, p_end) & 0xfff;
        if (desc_list_len < 0)
            break;
        desc_list_end = p + desc_list_len;
555
        if (desc_list_end > p_end)
556
            break;
557 558 559 560
        for(;;) {
            desc_tag = get8(&p, desc_list_end);
            if (desc_tag < 0)
                break;
561 562
            if (stream_type == STREAM_TYPE_PRIVATE_DATA) {
                if((desc_tag == 0x6A) || (desc_tag == 0x7A)) {
563 564
                    /*assume DVB AC-3 Audio*/
                    stream_type = STREAM_TYPE_AUDIO_AC3;
565 566 567 568
                } else if(desc_tag == 0x7B) {
                    /* DVB DTS audio */
                    stream_type = STREAM_TYPE_AUDIO_DTS;
                }
569
            }
570
            desc_len = get8(&p, desc_list_end);
571 572
            if (desc_len < 0)
                break;
573 574 575
            desc_end = p + desc_len;
            if (desc_end > desc_list_end)
                break;
576 577

            dprintf(ts->stream, "tag: 0x%02x len=%d\n",
578
                   desc_tag, desc_len);
579

580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599
            switch(desc_tag) {
            case DVB_SUBT_DESCID:
                if (stream_type == STREAM_TYPE_PRIVATE_DATA)
                    stream_type = STREAM_TYPE_SUBTITLE_DVB;

                language[0] = get8(&p, desc_end);
                language[1] = get8(&p, desc_end);
                language[2] = get8(&p, desc_end);
                language[3] = 0;
                get8(&p, desc_end);
                comp_page = get16(&p, desc_end);
                anc_page = get16(&p, desc_end);

                break;
            case 0x0a: /* ISO 639 language descriptor */
                language[0] = get8(&p, desc_end);
                language[1] = get8(&p, desc_end);
                language[2] = get8(&p, desc_end);
                language[3] = 0;
                break;
600
            case REGISTRATION_DESCRIPTOR: /*MPEG-2 Registration descriptor */
601 602 603
                reg_desc = bytestream_get_le32(&p);
                if(reg_desc == AV_RL32("drac"))
                    has_dirac_descr = 1;
604 605
                else if(reg_desc == AV_RL32("AC-3"))
                    stream_type = STREAM_TYPE_AUDIO_AC3;
606
                break;
607 608 609 610 611 612
            default:
                break;
            }
            p = desc_end;
        }
        p = desc_list_end;
613

614
        dprintf(ts->stream, "stream_type=%x pid=0x%x\n",
615
               stream_type, pid);
616 617 618

        /* now create ffmpeg stream */
        switch(stream_type) {
619 620 621 622
        case STREAM_TYPE_AUDIO_MPEG1:
        case STREAM_TYPE_AUDIO_MPEG2:
        case STREAM_TYPE_VIDEO_MPEG1:
        case STREAM_TYPE_VIDEO_MPEG2:
623 624
        case STREAM_TYPE_VIDEO_MPEG4:
        case STREAM_TYPE_VIDEO_H264:
Nico Sabbi's avatar
Nico Sabbi committed
625
        case STREAM_TYPE_VIDEO_VC1:
626
        case STREAM_TYPE_VIDEO_DIRAC:
627
        case STREAM_TYPE_AUDIO_AAC:
628
        case STREAM_TYPE_AUDIO_AC3:
629
        case STREAM_TYPE_AUDIO_DTS:
630
        case STREAM_TYPE_AUDIO_HDMV_DTS:
631
        case STREAM_TYPE_SUBTITLE_DVB:
632 633
            if((stream_type == STREAM_TYPE_AUDIO_HDMV_DTS && !has_hdmv_descr)
            || (stream_type == STREAM_TYPE_VIDEO_DIRAC    && !has_dirac_descr))
634
                break;
635
            if(ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES){
636 637 638
                pes= ts->pids[pid]->u.pes_filter.opaque;
                st= pes->st;
            }else{
639
                if (ts->pids[pid]) mpegts_close_filter(ts, ts->pids[pid]); //wrongly added sdt filter probably
640
                pes = add_pes_stream(ts, pid, pcr_pid, stream_type);
Michael Niedermayer's avatar
Michael Niedermayer committed
641 642
                if (pes)
                    st = new_pes_av_stream(pes, 0);
643
            }
644
            add_pid_to_pmt(ts, h->id, pid);
645 646
            if(st)
                av_program_add_stream_index(ts->stream, h->id, st->index);
Michael Niedermayer's avatar
Michael Niedermayer committed
647
            break;
648 649 650 651
        default:
            /* we ignore the other streams */
            break;
        }
652 653 654

        if (st) {
            if (language[0] != 0) {
655
                av_metadata_set(&st->metadata, "language", language);
656 657 658
            }

            if (stream_type == STREAM_TYPE_SUBTITLE_DVB) {
659
                st->codec->sub_id = (anc_page << 16) | comp_page;
660 661
            }
        }
662 663
    }
    /* all parameters are there */
664
    ts->stop_parse++;
665
    mpegts_close_filter(ts, filter);
666 667
}

668
static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
669
{
670
    MpegTSContext *ts = filter->u.section_filter.opaque;
671 672 673 674
    SectionHeader h1, *h = &h1;
    const uint8_t *p, *p_end;
    int sid, pmt_pid;

675 676
#ifdef DEBUG
    dprintf(ts->stream, "PAT:\n");
677
    av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
678 679 680 681 682 683 684 685
#endif
    p_end = section + section_len - 4;
    p = section;
    if (parse_section_header(h, &p, p_end) < 0)
        return;
    if (h->tid != PAT_TID)
        return;

686
    clear_programs(ts);
687 688 689 690 691 692 693
    for(;;) {
        sid = get16(&p, p_end);
        if (sid < 0)
            break;
        pmt_pid = get16(&p, p_end) & 0x1fff;
        if (pmt_pid < 0)
            break;
694 695 696

        dprintf(ts->stream, "sid=0x%x pid=0x%x\n", sid, pmt_pid);

697 698 699
        if (sid == 0x0000) {
            /* NIT info */
        } else {
700
            av_new_program(ts->stream, sid);
701
            ts->stop_parse--;
Michael Niedermayer's avatar
Michael Niedermayer committed
702
            mpegts_open_section_filter(ts, pmt_pid, pmt_cb, ts, 1);
703 704 705
            add_pat_entry(ts, sid);
            add_pid_to_pmt(ts, sid, 0); //add pat pid to program
            add_pid_to_pmt(ts, sid, pmt_pid);
706 707 708
        }
    }
    /* not found */
709
    ts->stop_parse++;
710

711
    mpegts_close_filter(ts, filter);
712 713
}

714
static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
715
{
716
    MpegTSContext *ts = filter->u.section_filter.opaque;
717 718 719 720 721
    SectionHeader h1, *h = &h1;
    const uint8_t *p, *p_end, *desc_list_end, *desc_end;
    int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type;
    char *name, *provider_name;

722 723
#ifdef DEBUG
    dprintf(ts->stream, "SDT:\n");
724
    av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759
#endif

    p_end = section + section_len - 4;
    p = section;
    if (parse_section_header(h, &p, p_end) < 0)
        return;
    if (h->tid != SDT_TID)
        return;
    onid = get16(&p, p_end);
    if (onid < 0)
        return;
    val = get8(&p, p_end);
    if (val < 0)
        return;
    for(;;) {
        sid = get16(&p, p_end);
        if (sid < 0)
            break;
        val = get8(&p, p_end);
        if (val < 0)
            break;
        desc_list_len = get16(&p, p_end) & 0xfff;
        if (desc_list_len < 0)
            break;
        desc_list_end = p + desc_list_len;
        if (desc_list_end > p_end)
            break;
        for(;;) {
            desc_tag = get8(&p, desc_list_end);
            if (desc_tag < 0)
                break;
            desc_len = get8(&p, desc_list_end);
            desc_end = p + desc_len;
            if (desc_end > desc_list_end)
                break;
760 761

            dprintf(ts->stream, "tag: 0x%02x len=%d\n",
762
                   desc_tag, desc_len);
763

764 765 766 767 768 769 770 771 772
            switch(desc_tag) {
            case 0x48:
                service_type = get8(&p, p_end);
                if (service_type < 0)
                    break;
                provider_name = getstr8(&p, p_end);
                if (!provider_name)
                    break;
                name = getstr8(&p, p_end);
773 774
                if (name) {
                    AVProgram *program = av_new_program(ts->stream, sid);
775 776 777 778
                    if(program) {
                        av_metadata_set(&program->metadata, "name", name);
                        av_metadata_set(&program->metadata, "provider_name", provider_name);
                    }
779
                }
Michael Niedermayer's avatar
Michael Niedermayer committed
780 781
                av_free(name);
                av_free(provider_name);
782 783 784 785 786 787 788 789 790 791 792 793
                break;
            default:
                break;
            }
            p = desc_end;
        }
        p = desc_list_end;
    }
}

static int64_t get_pts(const uint8_t *p)
{
794 795 796
    int64_t pts = (int64_t)((p[0] >> 1) & 0x07) << 30;
    pts |= (AV_RB16(p + 1) >> 1) << 15;
    pts |=  AV_RB16(p + 3) >> 1;
797
    return pts;
798 799 800
}

/* return non zero if a packet could be constructed */
801
static void mpegts_push_data(MpegTSFilter *filter,
802 803
                             const uint8_t *buf, int buf_size, int is_start,
                             int64_t pos)
804
{
805
    PESContext *pes = filter->u.pes_filter.opaque;
806
    MpegTSContext *ts = pes->ts;
807
    const uint8_t *p;
808
    int len, code;
809

810 811 812
    if(!ts->pkt)
        return;

813
    if (is_start) {
814 815
        pes->state = MPEGTS_HEADER;
        pes->data_index = 0;
816
        pes->ts_packet_pos = pos;
817 818 819
    }
    p = buf;
    while (buf_size > 0) {
820
        switch(pes->state) {
821
        case MPEGTS_HEADER:
822 823 824 825 826
            len = PES_START_SIZE - pes->data_index;
            if (len > buf_size)
                len = buf_size;
            memcpy(pes->header + pes->data_index, p, len);
            pes->data_index += len;
827 828
            p += len;
            buf_size -= len;
829
            if (pes->data_index == PES_START_SIZE) {
830 831 832
                /* we got all the PES or section header. We can now
                   decide */
#if 0
833
                av_hex_dump_log(pes->stream, AV_LOG_DEBUG, pes->header, pes->data_index);
834
#endif
835 836
                if (pes->header[0] == 0x00 && pes->header[1] == 0x00 &&
                    pes->header[2] == 0x01) {
837
                    /* it must be an mpeg2 PES stream */
838
                    code = pes->header[3] | 0x100;
839 840
                    if (!pes->st ||
                        !((code >= 0x1c0 && code <= 0x1df) ||
841
                          (code >= 0x1e0 && code <= 0x1ef) ||
Nico Sabbi's avatar
Nico Sabbi committed
842
                          (code == 0x1bd) || (code == 0x1fd)))
843
                        goto skip;
844
                    pes->state = MPEGTS_PESHEADER_FILL;
845
                    pes->total_size = AV_RB16(pes->header + 4);
846 847 848 849 850
                    /* NOTE: a zero total size means the PES size is
                       unbounded */
                    if (pes->total_size)
                        pes->total_size += 6;
                    pes->pes_header_size = pes->header[8] + 9;
851 852 853 854
                } else {
                    /* otherwise, it should be a table */
                    /* skip packet */
                skip:
855
                    pes->state = MPEGTS_SKIP;
856 857 858 859 860 861 862
                    continue;
                }
            }
            break;
            /**********************************************/
            /* PES packing parsing */
        case MPEGTS_PESHEADER_FILL:
863 864 865 866 867
            len = pes->pes_header_size - pes->data_index;
            if (len > buf_size)
                len = buf_size;
            memcpy(pes->header + pes->data_index, p, len);
            pes->data_index += len;
868 869
            p += len;
            buf_size -= len;
870 871 872 873 874 875 876 877 878
            if (pes->data_index == pes->pes_header_size) {
                const uint8_t *r;
                unsigned int flags;

                flags = pes->header[7];
                r = pes->header + 9;
                pes->pts = AV_NOPTS_VALUE;
                pes->dts = AV_NOPTS_VALUE;
                if ((flags & 0xc0) == 0x80) {
879
                    pes->dts = pes->pts = get_pts(r);
880 881 882 883 884 885 886 887 888 889
                    r += 5;
                } else if ((flags & 0xc0) == 0xc0) {
                    pes->pts = get_pts(r);
                    r += 5;
                    pes->dts = get_pts(r);
                    r += 5;
                }
                /* we got the full header. We parse it and get the payload */
                pes->state = MPEGTS_PAYLOAD;
            }
890 891
            break;
        case MPEGTS_PAYLOAD:
892 893 894 895 896 897 898
            if (pes->total_size) {
                len = pes->total_size - pes->data_index;
                if (len > buf_size)
                    len = buf_size;
            } else {
                len = buf_size;
            }
899
            if (len > 0) {
900 901 902 903 904
                AVPacket *pkt = ts->pkt;
                if (pes->st && av_new_packet(pkt, len) == 0) {
                    memcpy(pkt->data, p, len);
                    pkt->stream_index = pes->st->index;
                    pkt->pts = pes->pts;
905
                    pkt->dts = pes->dts;
906 907
                    /* store position of first TS packet of this PES packet */
                    pkt->pos = pes->ts_packet_pos;
908 909 910 911 912
                    /* reset pts values */
                    pes->pts = AV_NOPTS_VALUE;
                    pes->dts = AV_NOPTS_VALUE;
                    ts->stop_parse = 1;
                    return;
913 914 915 916 917 918 919 920 921
                }
            }
            buf_size = 0;
            break;
        case MPEGTS_SKIP:
            buf_size = 0;
            break;
        }
    }
922 923
}

924 925 926
static AVStream* new_pes_av_stream(PESContext *pes, uint32_t code)
{
    AVStream *st;
927 928
    enum CodecID codec_id;
    enum CodecType codec_type;
929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948

    switch(pes->stream_type){
    case STREAM_TYPE_AUDIO_MPEG1:
    case STREAM_TYPE_AUDIO_MPEG2:
        codec_type = CODEC_TYPE_AUDIO;
        codec_id = CODEC_ID_MP3;
        break;
    case STREAM_TYPE_VIDEO_MPEG1:
    case STREAM_TYPE_VIDEO_MPEG2:
        codec_type = CODEC_TYPE_VIDEO;
        codec_id = CODEC_ID_MPEG2VIDEO;
        break;
    case STREAM_TYPE_VIDEO_MPEG4:
        codec_type = CODEC_TYPE_VIDEO;
        codec_id = CODEC_ID_MPEG4;
        break;
    case STREAM_TYPE_VIDEO_H264:
        codec_type = CODEC_TYPE_VIDEO;
        codec_id = CODEC_ID_H264;
        break;
Nico Sabbi's avatar
Nico Sabbi committed
949 950 951 952
    case STREAM_TYPE_VIDEO_VC1:
        codec_type = CODEC_TYPE_VIDEO;
        codec_id = CODEC_ID_VC1;
        break;
953 954 955 956
    case STREAM_TYPE_VIDEO_DIRAC:
        codec_type = CODEC_TYPE_VIDEO;
        codec_id = CODEC_ID_DIRAC;
        break;
957 958 959 960 961 962 963 964 965
    case STREAM_TYPE_AUDIO_AAC:
        codec_type = CODEC_TYPE_AUDIO;
        codec_id = CODEC_ID_AAC;
        break;
    case STREAM_TYPE_AUDIO_AC3:
        codec_type = CODEC_TYPE_AUDIO;
        codec_id = CODEC_ID_AC3;
        break;
    case STREAM_TYPE_AUDIO_DTS:
966
    case STREAM_TYPE_AUDIO_HDMV_DTS:
967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982
        codec_type = CODEC_TYPE_AUDIO;
        codec_id = CODEC_ID_DTS;
        break;
    case STREAM_TYPE_SUBTITLE_DVB:
        codec_type = CODEC_TYPE_SUBTITLE;
        codec_id = CODEC_ID_DVB_SUBTITLE;
        break;
    default:
        if (code >= 0x1c0 && code <= 0x1df) {
            codec_type = CODEC_TYPE_AUDIO;
            codec_id = CODEC_ID_MP2;
        } else if (code == 0x1bd) {
            codec_type = CODEC_TYPE_AUDIO;
            codec_id = CODEC_ID_AC3;
        } else {
            codec_type = CODEC_TYPE_VIDEO;
983
            codec_id = CODEC_ID_PROBE;
984 985 986 987 988 989 990
        }
        break;
    }
    st = av_new_stream(pes->stream, pes->pid);
    if (st) {
        av_set_pts_info(st, 33, 1, 90000);
        st->priv_data = pes;
991 992
        st->codec->codec_type = codec_type;
        st->codec->codec_id = codec_id;
993
        st->need_parsing = AVSTREAM_PARSE_FULL;
994 995 996 997 998 999
        pes->st = st;
    }
    return st;
}


1000
static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid, int stream_type)
1001 1002 1003 1004 1005 1006 1007
{
    MpegTSFilter *tss;
    PESContext *pes;

    /* if no pid found, then add a pid context */
    pes = av_mallocz(sizeof(PESContext));
    if (!pes)
1008
        return 0;
1009 1010
    pes->ts = ts;
    pes->stream = ts->stream;
1011
    pes->pid = pid;
1012
    pes->pcr_pid = pcr_pid;
1013
    pes->stream_type = stream_type;
1014 1015 1016
    tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes);
    if (!tss) {
        av_free(pes);
1017
        return 0;
1018
    }
1019
    return pes;
1020 1021
}

1022
/* handle one TS packet */
1023
static void handle_packet(MpegTSContext *ts, const uint8_t *packet)
1024
{
1025
    AVFormatContext *s = ts->stream;
1026 1027 1028
    MpegTSFilter *tss;
    int len, pid, cc, cc_ok, afc, is_start;
    const uint8_t *p, *p_end;
1029
    int64_t pos;
1030

1031
    pid = AV_RB16(packet + 1) & 0x1fff;
1032 1033
    if(pid && discard_pid(ts, pid))
        return;
1034 1035 1036
    is_start = packet[1] & 0x40;
    tss = ts->pids[pid];
    if (ts->auto_guess && tss == NULL && is_start) {
1037
        add_pes_stream(ts, pid, -1, 0);
1038 1039 1040 1041 1042 1043 1044 1045 1046
        tss = ts->pids[pid];
    }
    if (!tss)
        return;

    /* continuity check (currently not used) */
    cc = (packet[3] & 0xf);
    cc_ok = (tss->last_cc < 0) || ((((tss->last_cc + 1) & 0x0f) == cc));
    tss->last_cc = cc;
1047

1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
    /* skip adaptation field */
    afc = (packet[3] >> 4) & 3;
    p = packet + 4;
    if (afc == 0) /* reserved value */
        return;
    if (afc == 2) /* adaptation field only */
        return;
    if (afc == 3) {
        /* skip adapation field */
        p += p[0] + 1;
    }
    /* if past the end of packet, ignore */
    p_end = packet + TS_PACKET_SIZE;
    if (p >= p_end)
        return;
1063

1064 1065
    pos = url_ftell(ts->stream->pb);
    ts->pos47= pos % ts->raw_packet_size;
1066

1067 1068 1069 1070 1071 1072 1073
    if (tss->type == MPEGTS_SECTION) {
        if (is_start) {
            /* pointer field present */
            len = *p++;
            if (p + len > p_end)
                return;
            if (len && cc_ok) {
1074
                /* write remaining section bytes */
1075
                write_section_data(s, tss,
1076
                                   p, len, 0);
1077 1078 1079
                /* check whether filter has been closed */
                if (!ts->pids[pid])
                    return;
1080 1081 1082
            }
            p += len;
            if (p < p_end) {
1083
                write_section_data(s, tss,
1084 1085 1086 1087
                                   p, p_end - p, 1);
            }
        } else {
            if (cc_ok) {
1088
                write_section_data(s, tss,
1089
                                   p, p_end - p, 0);
1090
            }
1091 1092
        }
    } else {
1093
        // Note: The position here points actually behind the current packet.
1094
        tss->u.pes_filter.pes_cb(tss,
1095
                                 p, p_end - p, is_start, pos - ts->raw_packet_size);
1096 1097 1098
    }
}

1099 1100
/* XXX: try to find a better synchro over several packets (use
   get_packet_size() ?) */
1101
static int mpegts_resync(ByteIOContext *pb)
1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
{
    int c, i;

    for(i = 0;i < MAX_RESYNC_SIZE; i++) {
        c = url_fgetc(pb);
        if (c < 0)
            return -1;
        if (c == 0x47) {
            url_fseek(pb, -1, SEEK_CUR);
            return 0;
        }
    }
    /* no sync found */
    return -1;
}

1118 1119
/* return -1 if error or EOF. Return 0 if OK. */
static int read_packet(ByteIOContext *pb, uint8_t *buf, int raw_packet_size)
1120
{
1121 1122 1123 1124 1125
    int skip, len;

    for(;;) {
        len = get_buffer(pb, buf, TS_PACKET_SIZE);
        if (len != TS_PACKET_SIZE)
1126
            return AVERROR(EIO);
1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147
        /* check paquet sync byte */
        if (buf[0] != 0x47) {
            /* find a new packet start */
            url_fseek(pb, -TS_PACKET_SIZE, SEEK_CUR);
            if (mpegts_resync(pb) < 0)
                return AVERROR_INVALIDDATA;
            else
                continue;
        } else {
            skip = raw_packet_size - TS_PACKET_SIZE;
            if (skip > 0)
                url_fskip(pb, skip);
            break;
        }
    }
    return 0;
}

static int handle_packets(MpegTSContext *ts, int nb_packets)
{
    AVFormatContext *s = ts->stream;
1148
    ByteIOContext *pb = s->pb;
1149 1150
    uint8_t packet[TS_PACKET_SIZE];
    int packet_num, ret;
1151 1152 1153

    ts->stop_parse = 0;
    packet_num = 0;
1154
    for(;;) {
1155
        if (ts->stop_parse>0)
1156 1157 1158 1159
            break;
        packet_num++;
        if (nb_packets != 0 && packet_num >= nb_packets)
            break;
1160 1161 1162 1163
        ret = read_packet(pb, packet, ts->raw_packet_size);
        if (ret != 0)
            return ret;
        handle_packet(ts, packet);
1164 1165 1166
    }
    return 0;
}
1167

1168 1169
static int mpegts_probe(AVProbeData *p)
{
1170
#if 1
1171
    const int size= p->buf_size;
1172
    int score, fec_score, dvhs_score;
1173
    int check_count= size / TS_FEC_PACKET_SIZE;
1174
#define CHECK_COUNT 10
1175

1176
    if (check_count < CHECK_COUNT)
1177
        return -1;
1178

1179 1180 1181
    score     = analyze(p->buf, TS_PACKET_SIZE     *check_count, TS_PACKET_SIZE     , NULL)*CHECK_COUNT/check_count;
    dvhs_score= analyze(p->buf, TS_DVHS_PACKET_SIZE*check_count, TS_DVHS_PACKET_SIZE, NULL)*CHECK_COUNT/check_count;
    fec_score = analyze(p->buf, TS_FEC_PACKET_SIZE *check_count, TS_FEC_PACKET_SIZE , NULL)*CHECK_COUNT/check_count;
1182
//    av_log(NULL, AV_LOG_DEBUG, "score: %d, dvhs_score: %d, fec_score: %d \n", score, dvhs_score, fec_score);
1183

1184
// we need a clear definition for the returned score otherwise things will become messy sooner or later
1185 1186
    if     (score > fec_score && score > dvhs_score && score > 6) return AVPROBE_SCORE_MAX + score     - CHECK_COUNT;
    else if(dvhs_score > score && dvhs_score > fec_score && dvhs_score > 6) return AVPROBE_SCORE_MAX + dvhs_score  - CHECK_COUNT;
1187 1188
    else if(                 fec_score > 6) return AVPROBE_SCORE_MAX + fec_score - CHECK_COUNT;
    else                                    return -1;
1189 1190 1191 1192 1193 1194 1195
#else
    /* only use the extension for safer guess */
    if (match_ext(p->filename, "ts"))
        return AVPROBE_SCORE_MAX;
    else
        return 0;
#endif
1196 1197
}

Diego Biurrun's avatar
Diego Biurrun committed
1198
/* return the 90kHz PCR and the extension for the 27MHz PCR. return
1199
   (-1) if not available */
1200
static int parse_pcr(int64_t *ppcr_high, int *ppcr_low,
1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220
                     const uint8_t *packet)
{
    int afc, len, flags;
    const uint8_t *p;
    unsigned int v;

    afc = (packet[3] >> 4) & 3;
    if (afc <= 1)
        return -1;
    p = packet + 4;
    len = p[0];
    p++;
    if (len == 0)
        return -1;
    flags = *p++;
    len--;
    if (!(flags & 0x10))
        return -1;
    if (len < 6)
        return -1;
1221
    v = AV_RB32(p);
1222 1223 1224 1225 1226
    *ppcr_high = ((int64_t)v << 1) | (p[4] >> 7);
    *ppcr_low = ((p[4] & 1) << 8) | p[5];
    return 0;
}

1227 1228 1229 1230
static int mpegts_read_header(AVFormatContext *s,
                              AVFormatParameters *ap)
{
    MpegTSContext *ts = s->priv_data;
1231
    ByteIOContext *pb = s->pb;
1232
    uint8_t buf[5*1024];
Michael Niedermayer's avatar
Michael Niedermayer committed
1233
    int len;
1234
    int64_t pos;
1235

1236 1237
    if (ap) {
        ts->mpeg2ts_compute_pcr = ap->mpeg2ts_compute_pcr;
1238 1239 1240 1241
        if(ap->mpeg2ts_raw){
            av_log(s, AV_LOG_ERROR, "use mpegtsraw_demuxer!\n");
            return -1;
        }
1242 1243
    }

1244 1245 1246 1247 1248 1249 1250 1251
    /* read the first 1024 bytes to get packet size */
    pos = url_ftell(pb);
    len = get_buffer(pb, buf, sizeof(buf));
    if (len != sizeof(buf))
        goto fail;
    ts->raw_packet_size = get_packet_size(buf, sizeof(buf));
    if (ts->raw_packet_size <= 0)
        goto fail;
1252
    ts->stream = s;
1253 1254
    ts->auto_guess = 0;

1255
    if (s->iformat == &mpegts_demuxer) {
1256
        /* normal demux */
1257

Benoit Fouet's avatar
Benoit Fouet committed
1258 1259
        /* first do a scaning to get all the services */
        url_fseek(pb, pos, SEEK_SET);
1260 1261

        mpegts_open_section_filter(ts, SDT_PID, sdt_cb, ts, 1);
1262

1263
        mpegts_open_section_filter(ts, PAT_PID, pat_cb, ts, 1);
1264

Michael Niedermayer's avatar
Michael Niedermayer committed
1265
        handle_packets(ts, s->probesize);
Benoit Fouet's avatar
Benoit Fouet committed
1266
        /* if could not find service, enable auto_guess */
1267

Benoit Fouet's avatar
Benoit Fouet committed
1268
        ts->auto_guess = 1;
1269

1270 1271
        dprintf(ts->stream, "tuning done\n");

1272 1273 1274 1275 1276 1277 1278
        s->ctx_flags |= AVFMTCTX_NOHEADER;
    } else {
        AVStream *st;
        int pcr_pid, pid, nb_packets, nb_pcrs, ret, pcr_l;
        int64_t pcrs[2], pcr_h;
        int packet_count[2];
        uint8_t packet[TS_PACKET_SIZE];
1279

1280
        /* only read packets */
1281

1282 1283 1284
        st = av_new_stream(s, 0);
        if (!st)
            goto fail;
1285
        av_set_pts_info(st, 60, 1, 27000000);
1286 1287
        st->codec->codec_type = CODEC_TYPE_DATA;
        st->codec->codec_id = CODEC_ID_MPEG2TS;
1288

1289 1290 1291 1292 1293
        /* we iterate until we find two PCRs to estimate the bitrate */
        pcr_pid = -1;
        nb_pcrs = 0;
        nb_packets = 0;
        for(;;) {
1294
            ret = read_packet(s->pb, packet, ts->raw_packet_size);
1295 1296
            if (ret < 0)
                return -1;
1297
            pid = AV_RB16(packet + 1) & 0x1fff;
1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308
            if ((pcr_pid == -1 || pcr_pid == pid) &&
                parse_pcr(&pcr_h, &pcr_l, packet) == 0) {
                pcr_pid = pid;
                packet_count[nb_pcrs] = nb_packets;
                pcrs[nb_pcrs] = pcr_h * 300 + pcr_l;
                nb_pcrs++;
                if (nb_pcrs >= 2)
                    break;
            }
            nb_packets++;
        }
1309

1310 1311 1312 1313 1314
        /* NOTE1: the bitrate is computed without the FEC */
        /* NOTE2: it is only the bitrate of the start of the stream */
        ts->pcr_incr = (pcrs[1] - pcrs[0]) / (packet_count[1] - packet_count[0]);
        ts->cur_pcr = pcrs[0] - ts->pcr_incr * packet_count[0];
        s->bit_rate = (TS_PACKET_SIZE * 8) * 27e6 / ts->pcr_incr;
1315
        st->codec->bit_rate = s->bit_rate;
1316
        st->start_time = ts->cur_pcr;
1317
#if 0
1318
        av_log(ts->stream, AV_LOG_DEBUG, "start=%0.3f pcr=%0.3f incr=%d\n",
1319
               st->start_time / 1000000.0, pcrs[0] / 27e6, ts->pcr_incr);
1320
#endif
1321
    }
1322 1323

    url_fseek(pb, pos, SEEK_SET);
1324
    return 0;
1325 1326 1327 1328
 fail:
    return -1;
}

1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340
#define MAX_PACKET_READAHEAD ((128 * 1024) / 188)

static int mpegts_raw_read_packet(AVFormatContext *s,
                                  AVPacket *pkt)
{
    MpegTSContext *ts = s->priv_data;
    int ret, i;
    int64_t pcr_h, next_pcr_h, pos;
    int pcr_l, next_pcr_l;
    uint8_t pcr_buf[12];

    if (av_new_packet(pkt, TS_PACKET_SIZE) < 0)
1341
        return AVERROR(ENOMEM);
1342 1343
    pkt->pos= url_ftell(s->pb);
    ret = read_packet(s->pb, pkt->data, ts->raw_packet_size);
1344 1345 1346 1347 1348 1349 1350 1351
    if (ret < 0) {
        av_free_packet(pkt);
        return ret;
    }
    if (ts->mpeg2ts_compute_pcr) {
        /* compute exact PCR for each packet */
        if (parse_pcr(&pcr_h, &pcr_l, pkt->data) == 0) {
            /* we read the next PCR (XXX: optimize it by using a bigger buffer */
1352
            pos = url_ftell(s->pb);
1353
            for(i = 0; i < MAX_PACKET_READAHEAD; i++) {
1354 1355
                url_fseek(s->pb, pos + i * ts->raw_packet_size, SEEK_SET);
                get_buffer(s->pb, pcr_buf, 12);
1356 1357
                if (parse_pcr(&next_pcr_h, &next_pcr_l, pcr_buf) == 0) {
                    /* XXX: not precise enough */
1358
                    ts->pcr_incr = ((next_pcr_h - pcr_h) * 300 + (next_pcr_l - pcr_l)) /
1359 1360 1361 1362
                        (i + 1);
                    break;
                }
            }
1363
            url_fseek(s->pb, pos, SEEK_SET);
1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374
            /* no next PCR found: we use previous increment */
            ts->cur_pcr = pcr_h * 300 + pcr_l;
        }
        pkt->pts = ts->cur_pcr;
        pkt->duration = ts->pcr_incr;
        ts->cur_pcr += ts->pcr_incr;
    }
    pkt->stream_index = 0;
    return 0;
}

1375 1376 1377 1378
static int mpegts_read_packet(AVFormatContext *s,
                              AVPacket *pkt)
{
    MpegTSContext *ts = s->priv_data;
1379

1380 1381
    ts->pkt = pkt;
    return handle_packets(ts, 0);
1382 1383 1384 1385 1386 1387
}

static int mpegts_read_close(AVFormatContext *s)
{
    MpegTSContext *ts = s->priv_data;
    int i;
Michael Niedermayer's avatar
Michael Niedermayer committed
1388 1389 1390

    clear_programs(ts);

1391
    for(i=0;i<NB_PID_MAX;i++)
1392
        if (ts->pids[i]) mpegts_close_filter(ts, ts->pids[i]);
1393

1394 1395 1396
    return 0;
}

1397
static int64_t mpegts_get_pcr(AVFormatContext *s, int stream_index,
1398
                              int64_t *ppos, int64_t pos_limit)
Fabrice Bellard's avatar
Fabrice Bellard committed
1399 1400 1401 1402
{
    MpegTSContext *ts = s->priv_data;
    int64_t pos, timestamp;
    uint8_t buf[TS_PACKET_SIZE];
1403
    int pcr_l, pcr_pid = ((PESContext*)s->streams[stream_index]->priv_data)->pcr_pid;
1404
    const int find_next= 1;
1405
    pos = ((*ppos  + ts->raw_packet_size - 1 - ts->pos47) / ts->raw_packet_size) * ts->raw_packet_size + ts->pos47;
Fabrice Bellard's avatar
Fabrice Bellard committed
1406 1407
    if (find_next) {
        for(;;) {
1408 1409
            url_fseek(s->pb, pos, SEEK_SET);
            if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
Fabrice Bellard's avatar
Fabrice Bellard committed
1410
                return AV_NOPTS_VALUE;
1411
            if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
Fabrice Bellard's avatar
Fabrice Bellard committed
1412 1413 1414 1415 1416 1417 1418 1419 1420 1421
                parse_pcr(&timestamp, &pcr_l, buf) == 0) {
                break;
            }
            pos += ts->raw_packet_size;
        }
    } else {
        for(;;) {
            pos -= ts->raw_packet_size;
            if (pos < 0)
                return AV_NOPTS_VALUE;
1422 1423
            url_fseek(s->pb, pos, SEEK_SET);
            if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
Fabrice Bellard's avatar
Fabrice Bellard committed
1424
                return AV_NOPTS_VALUE;
1425
            if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
Fabrice Bellard's avatar
Fabrice Bellard committed
1426 1427 1428 1429 1430 1431 1432
                parse_pcr(&timestamp, &pcr_l, buf) == 0) {
                break;
            }
        }
    }
    *ppos = pos;

1433
    return timestamp;
Fabrice Bellard's avatar
Fabrice Bellard committed
1434 1435
}

1436
static int read_seek(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1437 1438 1439 1440
    MpegTSContext *ts = s->priv_data;
    uint8_t buf[TS_PACKET_SIZE];
    int64_t pos;

1441
    if(av_seek_frame_binary(s, stream_index, target_ts, flags) < 0)
1442 1443
        return -1;

1444
    pos= url_ftell(s->pb);
1445 1446

    for(;;) {
1447 1448
        url_fseek(s->pb, pos, SEEK_SET);
        if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
1449
            return -1;
1450
//        pid = AV_RB16(buf + 1) & 0x1fff;
1451 1452
        if(buf[1] & 0x40) break;
        pos += ts->raw_packet_size;
1453
    }
1454
    url_fseek(s->pb, pos, SEEK_SET);
1455 1456 1457 1458

    return 0;
}

1459 1460 1461 1462 1463 1464
/**************************************************************/
/* parsing functions - called from other demuxers such as RTP */

MpegTSContext *mpegts_parse_open(AVFormatContext *s)
{
    MpegTSContext *ts;
1465

1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486
    ts = av_mallocz(sizeof(MpegTSContext));
    if (!ts)
        return NULL;
    /* no stream case, currently used by RTP */
    ts->raw_packet_size = TS_PACKET_SIZE;
    ts->stream = s;
    ts->auto_guess = 1;
    return ts;
}

/* return the consumed length if a packet was output, or -1 if no
   packet is output */
int mpegts_parse_packet(MpegTSContext *ts, AVPacket *pkt,
                        const uint8_t *buf, int len)
{
    int len1;

    len1 = len;
    ts->pkt = pkt;
    ts->stop_parse = 0;
    for(;;) {
1487
        if (ts->stop_parse>0)
1488 1489 1490 1491
            break;
        if (len < TS_PACKET_SIZE)
            return -1;
        if (buf[0] != 0x47) {
1492
            buf++;
1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511
            len--;
        } else {
            handle_packet(ts, buf);
            buf += TS_PACKET_SIZE;
            len -= TS_PACKET_SIZE;
        }
    }
    return len1 - len;
}

void mpegts_parse_close(MpegTSContext *ts)
{
    int i;

    for(i=0;i<NB_PID_MAX;i++)
        av_free(ts->pids[i]);
    av_free(ts);
}

1512
AVInputFormat mpegts_demuxer = {
1513
    "mpegts",
1514
    NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
1515 1516 1517 1518 1519
    sizeof(MpegTSContext),
    mpegts_probe,
    mpegts_read_header,
    mpegts_read_packet,
    mpegts_read_close,
1520
    read_seek,
1521
    mpegts_get_pcr,
1522
    .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
1523
};
1524 1525 1526

AVInputFormat mpegtsraw_demuxer = {
    "mpegtsraw",
1527
    NULL_IF_CONFIG_SMALL("MPEG-2 raw transport stream format"),
1528
    sizeof(MpegTSContext),
1529
    NULL,
1530 1531 1532 1533 1534
    mpegts_read_header,
    mpegts_raw_read_packet,
    mpegts_read_close,
    read_seek,
    mpegts_get_pcr,
1535
    .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
1536
};