Statistics
| Branch: | Revision:

ffmpeg / libavformat / mpegts.c @ d23612ef

History | View | Annotate | Download (47.4 KB)

1
/*
2
 * MPEG2 transport stream (aka DVB) demuxer
3
 * Copyright (c) 2002-2003 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
//#define DEBUG
23
//#define DEBUG_SEEK
24

    
25
#include "libavutil/crc.h"
26
#include "libavutil/intreadwrite.h"
27
#include "libavcodec/bytestream.h"
28
#include "avformat.h"
29
#include "mpegts.h"
30
#include "internal.h"
31

    
32
/* 1.0 second at 24Mbit/s */
33
#define MAX_SCAN_PACKETS 32000
34

    
35
/* maximum size in which we look for synchronisation if
36
   synchronisation is lost */
37
#define MAX_RESYNC_SIZE 4096
38

    
39
#define MAX_PES_PAYLOAD 200*1024
40

    
41
typedef struct PESContext PESContext;
42

    
43
static PESContext* add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid, int stream_type);
44

    
45
enum MpegTSFilterType {
46
    MPEGTS_PES,
47
    MPEGTS_SECTION,
48
};
49

    
50
typedef struct MpegTSFilter MpegTSFilter;
51

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

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

    
59
typedef void SectionCallback(MpegTSFilter *f, const uint8_t *buf, int len);
60

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

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

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

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

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

    
96
    int pos47;
97

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

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

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

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

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

    
122

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

    
127
/* TS stream handling */
128

    
129
enum MpegTSState {
130
    MPEGTS_HEADER = 0,
131
    MPEGTS_PESHEADER,
132
    MPEGTS_PESHEADER_FILL,
133
    MPEGTS_PAYLOAD,
134
    MPEGTS_SKIP,
135
};
136

    
137
/* enough for PES header + length */
138
#define PES_START_SIZE  6
139
#define PES_HEADER_SIZE 9
140
#define MAX_PES_HEADER_SIZE (9 + 255)
141

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

    
160
extern AVInputFormat mpegts_demuxer;
161

    
162
static void clear_program(MpegTSContext *ts, unsigned int programid)
163
{
164
    int i;
165

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

    
171
static void clear_programs(MpegTSContext *ts)
172
{
173
    av_freep(&ts->prg);
174
    ts->nb_prg=0;
175
}
176

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

    
190
static void add_pid_to_pmt(MpegTSContext *ts, unsigned int programid, unsigned int pid)
191
{
192
    int i;
193
    struct Program *p = NULL;
194
    for(i=0; i<ts->nb_prg; i++) {
195
        if(ts->prg[i].id == programid) {
196
            p = &ts->prg[i];
197
            break;
198
        }
199
    }
200
    if(!p)
201
        return;
202

    
203
    if(p->nb_pids >= MAX_PIDS_PER_PROGRAM)
204
        return;
205
    p->pids[p->nb_pids++] = pid;
206
}
207

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

    
238
    return !used && discarded;
239
}
240

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

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

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

    
274
    if (tss->section_h_size != -1 && tss->section_index >= tss->section_h_size) {
275
        tss->end_of_section_reached = 1;
276
        if (!tss->check_crc ||
277
            av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1,
278
                   tss->section_buf, tss->section_h_size) == 0)
279
            tss->section_cb(tss1, tss->section_buf, tss->section_h_size);
280
    }
281
}
282

    
283
static MpegTSFilter *mpegts_open_section_filter(MpegTSContext *ts, unsigned int pid,
284
                                         SectionCallback *section_cb, void *opaque,
285
                                         int check_crc)
286

    
287
{
288
    MpegTSFilter *filter;
289
    MpegTSSectionFilter *sec;
290

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

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

    
314
static MpegTSFilter *mpegts_open_pes_filter(MpegTSContext *ts, unsigned int pid,
315
                                     PESCallback *pes_cb,
316
                                     void *opaque)
317
{
318
    MpegTSFilter *filter;
319
    MpegTSPESFilter *pes;
320

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

    
336
static void mpegts_close_filter(MpegTSContext *ts, MpegTSFilter *filter)
337
{
338
    int pid;
339

    
340
    pid = filter->pid;
341
    if (filter->type == MPEGTS_SECTION)
342
        av_freep(&filter->u.section_filter.section_buf);
343
    else if (filter->type == MPEGTS_PES) {
344
        PESContext *pes = filter->u.pes_filter.opaque;
345
        av_freep(&pes->buffer);
346
        /* referenced private data will be freed later in
347
         * av_close_input_stream */
348
        if (!((PESContext *)filter->u.pes_filter.opaque)->st) {
349
            av_freep(&filter->u.pes_filter.opaque);
350
        }
351
    }
352

    
353
    av_free(filter);
354
    ts->pids[pid] = NULL;
355
}
356

    
357
static int analyze(const uint8_t *buf, int size, int packet_size, int *index){
358
    int stat[packet_size];
359
    int i;
360
    int x=0;
361
    int best_score=0;
362

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

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

    
374
        x++;
375
        if(x == packet_size) x= 0;
376
    }
377

    
378
    return best_score;
379
}
380

    
381
/* autodetect fec presence. Must have at least 1024 bytes  */
382
static int get_packet_size(const uint8_t *buf, int size)
383
{
384
    int score, fec_score, dvhs_score;
385

    
386
    if (size < (TS_FEC_PACKET_SIZE * 5 + 1))
387
        return -1;
388

    
389
    score    = analyze(buf, size, TS_PACKET_SIZE, NULL);
390
    dvhs_score    = analyze(buf, size, TS_DVHS_PACKET_SIZE, NULL);
391
    fec_score= analyze(buf, size, TS_FEC_PACKET_SIZE, NULL);
392
//    av_log(NULL, AV_LOG_DEBUG, "score: %d, dvhs_score: %d, fec_score: %d \n", score, dvhs_score, fec_score);
393

    
394
    if     (score > fec_score && score > dvhs_score) return TS_PACKET_SIZE;
395
    else if(dvhs_score > score && dvhs_score > fec_score) return TS_DVHS_PACKET_SIZE;
396
    else if(score < fec_score && dvhs_score < fec_score) return TS_FEC_PACKET_SIZE;
397
    else                       return -1;
398
}
399

    
400
typedef struct SectionHeader {
401
    uint8_t tid;
402
    uint16_t id;
403
    uint8_t version;
404
    uint8_t sec_num;
405
    uint8_t last_sec_num;
406
} SectionHeader;
407

    
408
static inline int get8(const uint8_t **pp, const uint8_t *p_end)
409
{
410
    const uint8_t *p;
411
    int c;
412

    
413
    p = *pp;
414
    if (p >= p_end)
415
        return -1;
416
    c = *p++;
417
    *pp = p;
418
    return c;
419
}
420

    
421
static inline int get16(const uint8_t **pp, const uint8_t *p_end)
422
{
423
    const uint8_t *p;
424
    int c;
425

    
426
    p = *pp;
427
    if ((p + 1) >= p_end)
428
        return -1;
429
    c = AV_RB16(p);
430
    p += 2;
431
    *pp = p;
432
    return c;
433
}
434

    
435
/* read and allocate a DVB string preceeded by its length */
436
static char *getstr8(const uint8_t **pp, const uint8_t *p_end)
437
{
438
    int len;
439
    const uint8_t *p;
440
    char *str;
441

    
442
    p = *pp;
443
    len = get8(&p, p_end);
444
    if (len < 0)
445
        return NULL;
446
    if ((p + len) > p_end)
447
        return NULL;
448
    str = av_malloc(len + 1);
449
    if (!str)
450
        return NULL;
451
    memcpy(str, p, len);
452
    str[len] = '\0';
453
    p += len;
454
    *pp = p;
455
    return str;
456
}
457

    
458
static int parse_section_header(SectionHeader *h,
459
                                const uint8_t **pp, const uint8_t *p_end)
460
{
461
    int val;
462

    
463
    val = get8(pp, p_end);
464
    if (val < 0)
465
        return -1;
466
    h->tid = val;
467
    *pp += 2;
468
    val = get16(pp, p_end);
469
    if (val < 0)
470
        return -1;
471
    h->id = val;
472
    val = get8(pp, p_end);
473
    if (val < 0)
474
        return -1;
475
    h->version = (val >> 1) & 0x1f;
476
    val = get8(pp, p_end);
477
    if (val < 0)
478
        return -1;
479
    h->sec_num = val;
480
    val = get8(pp, p_end);
481
    if (val < 0)
482
        return -1;
483
    h->last_sec_num = val;
484
    return 0;
485
}
486

    
487
typedef struct {
488
    uint32_t stream_type;
489
    enum CodecType codec_type;
490
    enum CodecID codec_id;
491
} StreamType;
492

    
493
static const StreamType ISO_types[] = {
494
    { 0x01, CODEC_TYPE_VIDEO, CODEC_ID_MPEG2VIDEO },
495
    { 0x02, CODEC_TYPE_VIDEO, CODEC_ID_MPEG2VIDEO },
496
    { 0x03, CODEC_TYPE_AUDIO,        CODEC_ID_MP3 },
497
    { 0x04, CODEC_TYPE_AUDIO,        CODEC_ID_MP3 },
498
    { 0x0f, CODEC_TYPE_AUDIO,        CODEC_ID_AAC },
499
    { 0x10, CODEC_TYPE_VIDEO,      CODEC_ID_MPEG4 },
500
    { 0x1b, CODEC_TYPE_VIDEO,       CODEC_ID_H264 },
501
    { 0xd1, CODEC_TYPE_VIDEO,      CODEC_ID_DIRAC },
502
    { 0xea, CODEC_TYPE_VIDEO,        CODEC_ID_VC1 },
503
    { 0 },
504
};
505

    
506
static const StreamType HDMV_types[] = {
507
    { 0x81, CODEC_TYPE_AUDIO, CODEC_ID_AC3 },
508
    { 0x82, CODEC_TYPE_AUDIO, CODEC_ID_DTS },
509
    { 0 },
510
};
511

    
512
/* ATSC ? */
513
static const StreamType MISC_types[] = {
514
    { 0x81, CODEC_TYPE_AUDIO,   CODEC_ID_AC3 },
515
    { 0x8a, CODEC_TYPE_AUDIO,   CODEC_ID_DTS },
516
    { 0 },
517
};
518

    
519
static const StreamType REGD_types[] = {
520
    { MKTAG('d','r','a','c'), CODEC_TYPE_VIDEO, CODEC_ID_DIRAC },
521
    { MKTAG('A','C','-','3'), CODEC_TYPE_AUDIO,   CODEC_ID_AC3 },
522
    { 0 },
523
};
524

    
525
/* descriptor present */
526
static const StreamType DESC_types[] = {
527
    { 0x6a, CODEC_TYPE_AUDIO,             CODEC_ID_AC3 }, /* AC-3 descriptor */
528
    { 0x7a, CODEC_TYPE_AUDIO,            CODEC_ID_EAC3 }, /* E-AC-3 descriptor */
529
    { 0x7b, CODEC_TYPE_AUDIO,             CODEC_ID_DTS },
530
    { 0x59, CODEC_TYPE_SUBTITLE, CODEC_ID_DVB_SUBTITLE }, /* subtitling descriptor */
531
    { 0 },
532
};
533

    
534
static void mpegts_find_stream_type(AVStream *st,
535
                                    uint32_t stream_type, const StreamType *types)
536
{
537
    for (; types->stream_type; types++) {
538
        if (stream_type == types->stream_type) {
539
            st->codec->codec_type = types->codec_type;
540
            st->codec->codec_id   = types->codec_id;
541
            return;
542
        }
543
    }
544
}
545

    
546
static AVStream *new_pes_av_stream(PESContext *pes, uint32_t prog_reg_desc, uint32_t code)
547
{
548
    AVStream *st = av_new_stream(pes->stream, pes->pid);
549

    
550
    if (!st)
551
        return NULL;
552

    
553
    av_set_pts_info(st, 33, 1, 90000);
554
    st->priv_data = pes;
555
    st->codec->codec_type = CODEC_TYPE_DATA;
556
    st->codec->codec_id   = CODEC_ID_NONE;
557
    st->need_parsing = AVSTREAM_PARSE_FULL;
558
    pes->st = st;
559

    
560
    dprintf(pes->stream, "stream_type=%x pid=%x prog_reg_desc=%.4s\n",
561
            pes->stream_type, pes->pid, (char*)&prog_reg_desc);
562

    
563
    st->codec->codec_tag = pes->stream_type;
564

    
565
    mpegts_find_stream_type(st, pes->stream_type, ISO_types);
566
    if (prog_reg_desc == AV_RL32("HDMV") &&
567
        st->codec->codec_id == CODEC_ID_NONE)
568
        mpegts_find_stream_type(st, pes->stream_type, HDMV_types);
569
    if (st->codec->codec_id == CODEC_ID_NONE)
570
        mpegts_find_stream_type(st, pes->stream_type, MISC_types);
571

    
572
    /* stream was not present in PMT, guess based on PES start code */
573
    if (st->codec->codec_id == CODEC_ID_NONE) {
574
        if (code >= 0x1c0 && code <= 0x1df) {
575
            st->codec->codec_type = CODEC_TYPE_AUDIO;
576
            st->codec->codec_id = CODEC_ID_MP2;
577
        } else if (code == 0x1bd) {
578
            st->codec->codec_type = CODEC_TYPE_AUDIO;
579
            st->codec->codec_id = CODEC_ID_AC3;
580
        }
581
    }
582

    
583
    return st;
584
}
585

    
586
static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
587
{
588
    MpegTSContext *ts = filter->u.section_filter.opaque;
589
    SectionHeader h1, *h = &h1;
590
    PESContext *pes;
591
    AVStream *st;
592
    const uint8_t *p, *p_end, *desc_list_end, *desc_end;
593
    int program_info_length, pcr_pid, pid, stream_type;
594
    int desc_list_len, desc_len, desc_tag;
595
    int comp_page, anc_page;
596
    char language[4];
597
    uint32_t prog_reg_desc = 0; /* registration descriptor */
598

    
599
#ifdef DEBUG
600
    dprintf(ts->stream, "PMT: len %i\n", section_len);
601
    av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
602
#endif
603

    
604
    p_end = section + section_len - 4;
605
    p = section;
606
    if (parse_section_header(h, &p, p_end) < 0)
607
        return;
608

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

    
612
    if (h->tid != PMT_TID)
613
        return;
614

    
615
    clear_program(ts, h->id);
616
    pcr_pid = get16(&p, p_end) & 0x1fff;
617
    if (pcr_pid < 0)
618
        return;
619
    add_pid_to_pmt(ts, h->id, pcr_pid);
620

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

    
623
    program_info_length = get16(&p, p_end) & 0xfff;
624
    if (program_info_length < 0)
625
        return;
626
    while(program_info_length >= 2) {
627
        uint8_t tag, len;
628
        tag = get8(&p, p_end);
629
        len = get8(&p, p_end);
630
        if(len > program_info_length - 2)
631
            //something else is broken, exit the program_descriptors_loop
632
            break;
633
        program_info_length -= len + 2;
634
        if(tag == 0x05 && len >= 4) { // registration descriptor
635
            prog_reg_desc = bytestream_get_le32(&p);
636
            len -= 4;
637
        }
638
        p += len;
639
    }
640
    p += program_info_length;
641
    if (p >= p_end)
642
        return;
643
    for(;;) {
644
        st = 0;
645
        stream_type = get8(&p, p_end);
646
        if (stream_type < 0)
647
            break;
648
        pid = get16(&p, p_end) & 0x1fff;
649
        if (pid < 0)
650
            break;
651

    
652
        /* now create ffmpeg stream */
653
        if (ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES) {
654
            pes = ts->pids[pid]->u.pes_filter.opaque;
655
            st = pes->st;
656
        } else {
657
            if (ts->pids[pid]) mpegts_close_filter(ts, ts->pids[pid]); //wrongly added sdt filter probably
658
            pes = add_pes_stream(ts, pid, pcr_pid, stream_type);
659
            if (pes)
660
                st = new_pes_av_stream(pes, prog_reg_desc, 0);
661
        }
662

    
663
        if (!st)
664
            return;
665

    
666
        add_pid_to_pmt(ts, h->id, pid);
667

    
668
        av_program_add_stream_index(ts->stream, h->id, st->index);
669

    
670
        desc_list_len = get16(&p, p_end) & 0xfff;
671
        if (desc_list_len < 0)
672
            break;
673
        desc_list_end = p + desc_list_len;
674
        if (desc_list_end > p_end)
675
            break;
676
        for(;;) {
677
            desc_tag = get8(&p, desc_list_end);
678
            if (desc_tag < 0)
679
                break;
680
            desc_len = get8(&p, desc_list_end);
681
            if (desc_len < 0)
682
                break;
683
            desc_end = p + desc_len;
684
            if (desc_end > desc_list_end)
685
                break;
686

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

    
690
            if (st->codec->codec_id == CODEC_ID_NONE &&
691
                stream_type == STREAM_TYPE_PRIVATE_DATA)
692
                mpegts_find_stream_type(st, desc_tag, DESC_types);
693

    
694
            switch(desc_tag) {
695
            case 0x59: /* subtitling descriptor */
696
                language[0] = get8(&p, desc_end);
697
                language[1] = get8(&p, desc_end);
698
                language[2] = get8(&p, desc_end);
699
                language[3] = 0;
700
                get8(&p, desc_end);
701
                comp_page = get16(&p, desc_end);
702
                anc_page = get16(&p, desc_end);
703
                st->codec->sub_id = (anc_page << 16) | comp_page;
704
                av_metadata_set(&st->metadata, "language", language);
705
                break;
706
            case 0x0a: /* ISO 639 language descriptor */
707
                language[0] = get8(&p, desc_end);
708
                language[1] = get8(&p, desc_end);
709
                language[2] = get8(&p, desc_end);
710
                language[3] = 0;
711
                av_metadata_set(&st->metadata, "language", language);
712
                break;
713
            case 0x05: /* registration descriptor */
714
                st->codec->codec_tag = bytestream_get_le32(&p);
715
                dprintf(ts->stream, "reg_desc=%.4s\n", (char*)&st->codec->codec_tag);
716
                if (st->codec->codec_id == CODEC_ID_NONE &&
717
                    stream_type == STREAM_TYPE_PRIVATE_DATA)
718
                    mpegts_find_stream_type(st, st->codec->codec_tag, REGD_types);
719
                break;
720
            default:
721
                break;
722
            }
723
            p = desc_end;
724
        }
725
        p = desc_list_end;
726
    }
727
    /* all parameters are there */
728
    ts->stop_parse++;
729
    mpegts_close_filter(ts, filter);
730
}
731

    
732
static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
733
{
734
    MpegTSContext *ts = filter->u.section_filter.opaque;
735
    SectionHeader h1, *h = &h1;
736
    const uint8_t *p, *p_end;
737
    int sid, pmt_pid;
738

    
739
#ifdef DEBUG
740
    dprintf(ts->stream, "PAT:\n");
741
    av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
742
#endif
743
    p_end = section + section_len - 4;
744
    p = section;
745
    if (parse_section_header(h, &p, p_end) < 0)
746
        return;
747
    if (h->tid != PAT_TID)
748
        return;
749

    
750
    clear_programs(ts);
751
    for(;;) {
752
        sid = get16(&p, p_end);
753
        if (sid < 0)
754
            break;
755
        pmt_pid = get16(&p, p_end) & 0x1fff;
756
        if (pmt_pid < 0)
757
            break;
758

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

    
761
        if (sid == 0x0000) {
762
            /* NIT info */
763
        } else {
764
            av_new_program(ts->stream, sid);
765
            ts->stop_parse--;
766
            mpegts_open_section_filter(ts, pmt_pid, pmt_cb, ts, 1);
767
            add_pat_entry(ts, sid);
768
            add_pid_to_pmt(ts, sid, 0); //add pat pid to program
769
            add_pid_to_pmt(ts, sid, pmt_pid);
770
        }
771
    }
772
    /* not found */
773
    ts->stop_parse++;
774

    
775
    mpegts_close_filter(ts, filter);
776
}
777

    
778
static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
779
{
780
    MpegTSContext *ts = filter->u.section_filter.opaque;
781
    SectionHeader h1, *h = &h1;
782
    const uint8_t *p, *p_end, *desc_list_end, *desc_end;
783
    int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type;
784
    char *name, *provider_name;
785

    
786
#ifdef DEBUG
787
    dprintf(ts->stream, "SDT:\n");
788
    av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
789
#endif
790

    
791
    p_end = section + section_len - 4;
792
    p = section;
793
    if (parse_section_header(h, &p, p_end) < 0)
794
        return;
795
    if (h->tid != SDT_TID)
796
        return;
797
    onid = get16(&p, p_end);
798
    if (onid < 0)
799
        return;
800
    val = get8(&p, p_end);
801
    if (val < 0)
802
        return;
803
    for(;;) {
804
        sid = get16(&p, p_end);
805
        if (sid < 0)
806
            break;
807
        val = get8(&p, p_end);
808
        if (val < 0)
809
            break;
810
        desc_list_len = get16(&p, p_end) & 0xfff;
811
        if (desc_list_len < 0)
812
            break;
813
        desc_list_end = p + desc_list_len;
814
        if (desc_list_end > p_end)
815
            break;
816
        for(;;) {
817
            desc_tag = get8(&p, desc_list_end);
818
            if (desc_tag < 0)
819
                break;
820
            desc_len = get8(&p, desc_list_end);
821
            desc_end = p + desc_len;
822
            if (desc_end > desc_list_end)
823
                break;
824

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

    
828
            switch(desc_tag) {
829
            case 0x48:
830
                service_type = get8(&p, p_end);
831
                if (service_type < 0)
832
                    break;
833
                provider_name = getstr8(&p, p_end);
834
                if (!provider_name)
835
                    break;
836
                name = getstr8(&p, p_end);
837
                if (name) {
838
                    AVProgram *program = av_new_program(ts->stream, sid);
839
                    if(program) {
840
                        av_metadata_set(&program->metadata, "name", name);
841
                        av_metadata_set(&program->metadata, "provider_name", provider_name);
842
                    }
843
                }
844
                av_free(name);
845
                av_free(provider_name);
846
                break;
847
            default:
848
                break;
849
            }
850
            p = desc_end;
851
        }
852
        p = desc_list_end;
853
    }
854
}
855

    
856
static int64_t get_pts(const uint8_t *p)
857
{
858
    int64_t pts = (int64_t)((p[0] >> 1) & 0x07) << 30;
859
    pts |= (AV_RB16(p + 1) >> 1) << 15;
860
    pts |=  AV_RB16(p + 3) >> 1;
861
    return pts;
862
}
863

    
864
static void new_pes_packet(PESContext *pes, AVPacket *pkt)
865
{
866
    av_init_packet(pkt);
867

    
868
    pkt->destruct = av_destruct_packet;
869
    pkt->data = pes->buffer;
870
    pkt->size = pes->data_index;
871
    memset(pkt->data+pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
872

    
873
    pkt->stream_index = pes->st->index;
874
    pkt->pts = pes->pts;
875
    pkt->dts = pes->dts;
876
    /* store position of first TS packet of this PES packet */
877
    pkt->pos = pes->ts_packet_pos;
878

    
879
    /* reset pts values */
880
    pes->pts = AV_NOPTS_VALUE;
881
    pes->dts = AV_NOPTS_VALUE;
882
    pes->buffer = NULL;
883
    pes->data_index = 0;
884
}
885

    
886
/* return non zero if a packet could be constructed */
887
static int mpegts_push_data(MpegTSFilter *filter,
888
                            const uint8_t *buf, int buf_size, int is_start,
889
                            int64_t pos)
890
{
891
    PESContext *pes = filter->u.pes_filter.opaque;
892
    MpegTSContext *ts = pes->ts;
893
    const uint8_t *p;
894
    int len, code;
895

    
896
    if(!ts->pkt)
897
        return 0;
898

    
899
    if (is_start) {
900
        if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
901
            new_pes_packet(pes, ts->pkt);
902
            ts->stop_parse = 1;
903
        }
904
        pes->state = MPEGTS_HEADER;
905
        pes->data_index = 0;
906
        pes->ts_packet_pos = pos;
907
    }
908
    p = buf;
909
    while (buf_size > 0) {
910
        switch(pes->state) {
911
        case MPEGTS_HEADER:
912
            len = PES_START_SIZE - pes->data_index;
913
            if (len > buf_size)
914
                len = buf_size;
915
            memcpy(pes->header + pes->data_index, p, len);
916
            pes->data_index += len;
917
            p += len;
918
            buf_size -= len;
919
            if (pes->data_index == PES_START_SIZE) {
920
                /* we got all the PES or section header. We can now
921
                   decide */
922
#if 0
923
                av_hex_dump_log(pes->stream, AV_LOG_DEBUG, pes->header, pes->data_index);
924
#endif
925
                if (pes->header[0] == 0x00 && pes->header[1] == 0x00 &&
926
                    pes->header[2] == 0x01) {
927
                    /* it must be an mpeg2 PES stream */
928
                    code = pes->header[3] | 0x100;
929
                    dprintf(pes->stream, "pid=%x pes_code=%#x\n", pes->pid, code);
930

    
931
                    if ((!pes->st && pes->stream->nb_streams == MAX_STREAMS) ||
932
                        (pes->st && pes->st->discard == AVDISCARD_ALL) ||
933
                        code == 0x1be) /* padding_stream */
934
                        goto skip;
935

    
936
                    /* stream not present in PMT */
937
                    if (!pes->st)
938
                        pes->st = new_pes_av_stream(pes, 0, code);
939
                    if (!pes->st)
940
                        return AVERROR(ENOMEM);
941

    
942
                    pes->total_size = AV_RB16(pes->header + 4);
943
                    /* NOTE: a zero total size means the PES size is
944
                       unbounded */
945
                    if (!pes->total_size)
946
                        pes->total_size = MAX_PES_PAYLOAD;
947

    
948
                    /* allocate pes buffer */
949
                    pes->buffer = av_malloc(pes->total_size+FF_INPUT_BUFFER_PADDING_SIZE);
950
                    if (!pes->buffer)
951
                        return AVERROR(ENOMEM);
952

    
953
                    if (code != 0x1bc && code != 0x1bf && /* program_stream_map, private_stream_2 */
954
                        code != 0x1f0 && code != 0x1f1 && /* ECM, EMM */
955
                        code != 0x1ff && code != 0x1f2 && /* program_stream_directory, DSMCC_stream */
956
                        code != 0x1f8) {                  /* ITU-T Rec. H.222.1 type E stream */
957
                        pes->state = MPEGTS_PESHEADER;
958
                        if (pes->st->codec->codec_id == CODEC_ID_NONE) {
959
                            dprintf(pes->stream, "pid=%x stream_type=%x probing\n",
960
                                    pes->pid, pes->stream_type);
961
                            pes->st->codec->codec_id = CODEC_ID_PROBE;
962
                        }
963
                    } else {
964
                        pes->state = MPEGTS_PAYLOAD;
965
                        pes->data_index = 0;
966
                    }
967
                } else {
968
                    /* otherwise, it should be a table */
969
                    /* skip packet */
970
                skip:
971
                    pes->state = MPEGTS_SKIP;
972
                    continue;
973
                }
974
            }
975
            break;
976
            /**********************************************/
977
            /* PES packing parsing */
978
        case MPEGTS_PESHEADER:
979
            len = PES_HEADER_SIZE - pes->data_index;
980
            if (len < 0)
981
                return -1;
982
            if (len > buf_size)
983
                len = buf_size;
984
            memcpy(pes->header + pes->data_index, p, len);
985
            pes->data_index += len;
986
            p += len;
987
            buf_size -= len;
988
            if (pes->data_index == PES_HEADER_SIZE) {
989
                pes->pes_header_size = pes->header[8] + 9;
990
                pes->state = MPEGTS_PESHEADER_FILL;
991
            }
992
            break;
993
        case MPEGTS_PESHEADER_FILL:
994
            len = pes->pes_header_size - pes->data_index;
995
            if (len < 0)
996
                return -1;
997
            if (len > buf_size)
998
                len = buf_size;
999
            memcpy(pes->header + pes->data_index, p, len);
1000
            pes->data_index += len;
1001
            p += len;
1002
            buf_size -= len;
1003
            if (pes->data_index == pes->pes_header_size) {
1004
                const uint8_t *r;
1005
                unsigned int flags;
1006

    
1007
                flags = pes->header[7];
1008
                r = pes->header + 9;
1009
                pes->pts = AV_NOPTS_VALUE;
1010
                pes->dts = AV_NOPTS_VALUE;
1011
                if ((flags & 0xc0) == 0x80) {
1012
                    pes->dts = pes->pts = get_pts(r);
1013
                    r += 5;
1014
                } else if ((flags & 0xc0) == 0xc0) {
1015
                    pes->pts = get_pts(r);
1016
                    r += 5;
1017
                    pes->dts = get_pts(r);
1018
                    r += 5;
1019
                }
1020

    
1021
                /* we got the full header. We parse it and get the payload */
1022
                pes->state = MPEGTS_PAYLOAD;
1023
                pes->data_index = 0;
1024
            }
1025
            break;
1026
        case MPEGTS_PAYLOAD:
1027
            if (buf_size > 0) {
1028
                if (pes->data_index+buf_size > pes->total_size) {
1029
                    new_pes_packet(pes, ts->pkt);
1030
                    pes->total_size = MAX_PES_PAYLOAD;
1031
                    pes->buffer = av_malloc(pes->total_size+FF_INPUT_BUFFER_PADDING_SIZE);
1032
                    if (!pes->buffer)
1033
                        return AVERROR(ENOMEM);
1034
                    ts->stop_parse = 1;
1035
                }
1036
                memcpy(pes->buffer+pes->data_index, p, buf_size);
1037
                pes->data_index += buf_size;
1038
            }
1039
            buf_size = 0;
1040
            break;
1041
        case MPEGTS_SKIP:
1042
            buf_size = 0;
1043
            break;
1044
        }
1045
    }
1046

    
1047
    return 0;
1048
}
1049

    
1050
static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid, int stream_type)
1051
{
1052
    MpegTSFilter *tss;
1053
    PESContext *pes;
1054

    
1055
    /* if no pid found, then add a pid context */
1056
    pes = av_mallocz(sizeof(PESContext));
1057
    if (!pes)
1058
        return 0;
1059
    pes->ts = ts;
1060
    pes->stream = ts->stream;
1061
    pes->pid = pid;
1062
    pes->pcr_pid = pcr_pid;
1063
    pes->stream_type = stream_type;
1064
    pes->state = MPEGTS_SKIP;
1065
    tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes);
1066
    if (!tss) {
1067
        av_free(pes);
1068
        return 0;
1069
    }
1070
    return pes;
1071
}
1072

    
1073
/* handle one TS packet */
1074
static int handle_packet(MpegTSContext *ts, const uint8_t *packet)
1075
{
1076
    AVFormatContext *s = ts->stream;
1077
    MpegTSFilter *tss;
1078
    int len, pid, cc, cc_ok, afc, is_start;
1079
    const uint8_t *p, *p_end;
1080
    int64_t pos;
1081

    
1082
    pid = AV_RB16(packet + 1) & 0x1fff;
1083
    if(pid && discard_pid(ts, pid))
1084
        return 0;
1085
    is_start = packet[1] & 0x40;
1086
    tss = ts->pids[pid];
1087
    if (ts->auto_guess && tss == NULL && is_start) {
1088
        add_pes_stream(ts, pid, -1, 0);
1089
        tss = ts->pids[pid];
1090
    }
1091
    if (!tss)
1092
        return 0;
1093

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

    
1099
    /* skip adaptation field */
1100
    afc = (packet[3] >> 4) & 3;
1101
    p = packet + 4;
1102
    if (afc == 0) /* reserved value */
1103
        return 0;
1104
    if (afc == 2) /* adaptation field only */
1105
        return 0;
1106
    if (afc == 3) {
1107
        /* skip adapation field */
1108
        p += p[0] + 1;
1109
    }
1110
    /* if past the end of packet, ignore */
1111
    p_end = packet + TS_PACKET_SIZE;
1112
    if (p >= p_end)
1113
        return 0;
1114

    
1115
    pos = url_ftell(ts->stream->pb);
1116
    ts->pos47= pos % ts->raw_packet_size;
1117

    
1118
    if (tss->type == MPEGTS_SECTION) {
1119
        if (is_start) {
1120
            /* pointer field present */
1121
            len = *p++;
1122
            if (p + len > p_end)
1123
                return 0;
1124
            if (len && cc_ok) {
1125
                /* write remaining section bytes */
1126
                write_section_data(s, tss,
1127
                                   p, len, 0);
1128
                /* check whether filter has been closed */
1129
                if (!ts->pids[pid])
1130
                    return 0;
1131
            }
1132
            p += len;
1133
            if (p < p_end) {
1134
                write_section_data(s, tss,
1135
                                   p, p_end - p, 1);
1136
            }
1137
        } else {
1138
            if (cc_ok) {
1139
                write_section_data(s, tss,
1140
                                   p, p_end - p, 0);
1141
            }
1142
        }
1143
    } else {
1144
        int ret;
1145
        // Note: The position here points actually behind the current packet.
1146
        if ((ret = tss->u.pes_filter.pes_cb(tss, p, p_end - p, is_start,
1147
                                            pos - ts->raw_packet_size)) < 0)
1148
            return ret;
1149
    }
1150

    
1151
    return 0;
1152
}
1153

    
1154
/* XXX: try to find a better synchro over several packets (use
1155
   get_packet_size() ?) */
1156
static int mpegts_resync(ByteIOContext *pb)
1157
{
1158
    int c, i;
1159

    
1160
    for(i = 0;i < MAX_RESYNC_SIZE; i++) {
1161
        c = url_fgetc(pb);
1162
        if (c < 0)
1163
            return -1;
1164
        if (c == 0x47) {
1165
            url_fseek(pb, -1, SEEK_CUR);
1166
            return 0;
1167
        }
1168
    }
1169
    /* no sync found */
1170
    return -1;
1171
}
1172

    
1173
/* return -1 if error or EOF. Return 0 if OK. */
1174
static int read_packet(ByteIOContext *pb, uint8_t *buf, int raw_packet_size)
1175
{
1176
    int skip, len;
1177

    
1178
    for(;;) {
1179
        len = get_buffer(pb, buf, TS_PACKET_SIZE);
1180
        if (len != TS_PACKET_SIZE)
1181
            return AVERROR(EIO);
1182
        /* check paquet sync byte */
1183
        if (buf[0] != 0x47) {
1184
            /* find a new packet start */
1185
            url_fseek(pb, -TS_PACKET_SIZE, SEEK_CUR);
1186
            if (mpegts_resync(pb) < 0)
1187
                return AVERROR_INVALIDDATA;
1188
            else
1189
                continue;
1190
        } else {
1191
            skip = raw_packet_size - TS_PACKET_SIZE;
1192
            if (skip > 0)
1193
                url_fskip(pb, skip);
1194
            break;
1195
        }
1196
    }
1197
    return 0;
1198
}
1199

    
1200
static int handle_packets(MpegTSContext *ts, int nb_packets)
1201
{
1202
    AVFormatContext *s = ts->stream;
1203
    ByteIOContext *pb = s->pb;
1204
    uint8_t packet[TS_PACKET_SIZE];
1205
    int packet_num, ret;
1206

    
1207
    ts->stop_parse = 0;
1208
    packet_num = 0;
1209
    for(;;) {
1210
        if (ts->stop_parse>0)
1211
            break;
1212
        packet_num++;
1213
        if (nb_packets != 0 && packet_num >= nb_packets)
1214
            break;
1215
        ret = read_packet(pb, packet, ts->raw_packet_size);
1216
        if (ret != 0)
1217
            return ret;
1218
        ret = handle_packet(ts, packet);
1219
        if (ret != 0)
1220
            return ret;
1221
    }
1222
    return 0;
1223
}
1224

    
1225
static int mpegts_probe(AVProbeData *p)
1226
{
1227
#if 1
1228
    const int size= p->buf_size;
1229
    int score, fec_score, dvhs_score;
1230
    int check_count= size / TS_FEC_PACKET_SIZE;
1231
#define CHECK_COUNT 10
1232

    
1233
    if (check_count < CHECK_COUNT)
1234
        return -1;
1235

    
1236
    score     = analyze(p->buf, TS_PACKET_SIZE     *check_count, TS_PACKET_SIZE     , NULL)*CHECK_COUNT/check_count;
1237
    dvhs_score= analyze(p->buf, TS_DVHS_PACKET_SIZE*check_count, TS_DVHS_PACKET_SIZE, NULL)*CHECK_COUNT/check_count;
1238
    fec_score = analyze(p->buf, TS_FEC_PACKET_SIZE *check_count, TS_FEC_PACKET_SIZE , NULL)*CHECK_COUNT/check_count;
1239
//    av_log(NULL, AV_LOG_DEBUG, "score: %d, dvhs_score: %d, fec_score: %d \n", score, dvhs_score, fec_score);
1240

    
1241
// we need a clear definition for the returned score otherwise things will become messy sooner or later
1242
    if     (score > fec_score && score > dvhs_score && score > 6) return AVPROBE_SCORE_MAX + score     - CHECK_COUNT;
1243
    else if(dvhs_score > score && dvhs_score > fec_score && dvhs_score > 6) return AVPROBE_SCORE_MAX + dvhs_score  - CHECK_COUNT;
1244
    else if(                 fec_score > 6) return AVPROBE_SCORE_MAX + fec_score - CHECK_COUNT;
1245
    else                                    return -1;
1246
#else
1247
    /* only use the extension for safer guess */
1248
    if (match_ext(p->filename, "ts"))
1249
        return AVPROBE_SCORE_MAX;
1250
    else
1251
        return 0;
1252
#endif
1253
}
1254

    
1255
/* return the 90kHz PCR and the extension for the 27MHz PCR. return
1256
   (-1) if not available */
1257
static int parse_pcr(int64_t *ppcr_high, int *ppcr_low,
1258
                     const uint8_t *packet)
1259
{
1260
    int afc, len, flags;
1261
    const uint8_t *p;
1262
    unsigned int v;
1263

    
1264
    afc = (packet[3] >> 4) & 3;
1265
    if (afc <= 1)
1266
        return -1;
1267
    p = packet + 4;
1268
    len = p[0];
1269
    p++;
1270
    if (len == 0)
1271
        return -1;
1272
    flags = *p++;
1273
    len--;
1274
    if (!(flags & 0x10))
1275
        return -1;
1276
    if (len < 6)
1277
        return -1;
1278
    v = AV_RB32(p);
1279
    *ppcr_high = ((int64_t)v << 1) | (p[4] >> 7);
1280
    *ppcr_low = ((p[4] & 1) << 8) | p[5];
1281
    return 0;
1282
}
1283

    
1284
static int mpegts_read_header(AVFormatContext *s,
1285
                              AVFormatParameters *ap)
1286
{
1287
    MpegTSContext *ts = s->priv_data;
1288
    ByteIOContext *pb = s->pb;
1289
    uint8_t buf[5*1024];
1290
    int len;
1291
    int64_t pos;
1292

    
1293
    if (ap) {
1294
        ts->mpeg2ts_compute_pcr = ap->mpeg2ts_compute_pcr;
1295
        if(ap->mpeg2ts_raw){
1296
            av_log(s, AV_LOG_ERROR, "use mpegtsraw_demuxer!\n");
1297
            return -1;
1298
        }
1299
    }
1300

    
1301
    /* read the first 1024 bytes to get packet size */
1302
    pos = url_ftell(pb);
1303
    len = get_buffer(pb, buf, sizeof(buf));
1304
    if (len != sizeof(buf))
1305
        goto fail;
1306
    ts->raw_packet_size = get_packet_size(buf, sizeof(buf));
1307
    if (ts->raw_packet_size <= 0)
1308
        goto fail;
1309
    ts->stream = s;
1310
    ts->auto_guess = 0;
1311

    
1312
    if (s->iformat == &mpegts_demuxer) {
1313
        /* normal demux */
1314

    
1315
        /* first do a scaning to get all the services */
1316
        url_fseek(pb, pos, SEEK_SET);
1317

    
1318
        mpegts_open_section_filter(ts, SDT_PID, sdt_cb, ts, 1);
1319

    
1320
        mpegts_open_section_filter(ts, PAT_PID, pat_cb, ts, 1);
1321

    
1322
        handle_packets(ts, s->probesize);
1323
        /* if could not find service, enable auto_guess */
1324

    
1325
        ts->auto_guess = 1;
1326

    
1327
        dprintf(ts->stream, "tuning done\n");
1328

    
1329
        s->ctx_flags |= AVFMTCTX_NOHEADER;
1330
    } else {
1331
        AVStream *st;
1332
        int pcr_pid, pid, nb_packets, nb_pcrs, ret, pcr_l;
1333
        int64_t pcrs[2], pcr_h;
1334
        int packet_count[2];
1335
        uint8_t packet[TS_PACKET_SIZE];
1336

    
1337
        /* only read packets */
1338

    
1339
        st = av_new_stream(s, 0);
1340
        if (!st)
1341
            goto fail;
1342
        av_set_pts_info(st, 60, 1, 27000000);
1343
        st->codec->codec_type = CODEC_TYPE_DATA;
1344
        st->codec->codec_id = CODEC_ID_MPEG2TS;
1345

    
1346
        /* we iterate until we find two PCRs to estimate the bitrate */
1347
        pcr_pid = -1;
1348
        nb_pcrs = 0;
1349
        nb_packets = 0;
1350
        for(;;) {
1351
            ret = read_packet(s->pb, packet, ts->raw_packet_size);
1352
            if (ret < 0)
1353
                return -1;
1354
            pid = AV_RB16(packet + 1) & 0x1fff;
1355
            if ((pcr_pid == -1 || pcr_pid == pid) &&
1356
                parse_pcr(&pcr_h, &pcr_l, packet) == 0) {
1357
                pcr_pid = pid;
1358
                packet_count[nb_pcrs] = nb_packets;
1359
                pcrs[nb_pcrs] = pcr_h * 300 + pcr_l;
1360
                nb_pcrs++;
1361
                if (nb_pcrs >= 2)
1362
                    break;
1363
            }
1364
            nb_packets++;
1365
        }
1366

    
1367
        /* NOTE1: the bitrate is computed without the FEC */
1368
        /* NOTE2: it is only the bitrate of the start of the stream */
1369
        ts->pcr_incr = (pcrs[1] - pcrs[0]) / (packet_count[1] - packet_count[0]);
1370
        ts->cur_pcr = pcrs[0] - ts->pcr_incr * packet_count[0];
1371
        s->bit_rate = (TS_PACKET_SIZE * 8) * 27e6 / ts->pcr_incr;
1372
        st->codec->bit_rate = s->bit_rate;
1373
        st->start_time = ts->cur_pcr;
1374
#if 0
1375
        av_log(ts->stream, AV_LOG_DEBUG, "start=%0.3f pcr=%0.3f incr=%d\n",
1376
               st->start_time / 1000000.0, pcrs[0] / 27e6, ts->pcr_incr);
1377
#endif
1378
    }
1379

    
1380
    url_fseek(pb, pos, SEEK_SET);
1381
    return 0;
1382
 fail:
1383
    return -1;
1384
}
1385

    
1386
#define MAX_PACKET_READAHEAD ((128 * 1024) / 188)
1387

    
1388
static int mpegts_raw_read_packet(AVFormatContext *s,
1389
                                  AVPacket *pkt)
1390
{
1391
    MpegTSContext *ts = s->priv_data;
1392
    int ret, i;
1393
    int64_t pcr_h, next_pcr_h, pos;
1394
    int pcr_l, next_pcr_l;
1395
    uint8_t pcr_buf[12];
1396

    
1397
    if (av_new_packet(pkt, TS_PACKET_SIZE) < 0)
1398
        return AVERROR(ENOMEM);
1399
    pkt->pos= url_ftell(s->pb);
1400
    ret = read_packet(s->pb, pkt->data, ts->raw_packet_size);
1401
    if (ret < 0) {
1402
        av_free_packet(pkt);
1403
        return ret;
1404
    }
1405
    if (ts->mpeg2ts_compute_pcr) {
1406
        /* compute exact PCR for each packet */
1407
        if (parse_pcr(&pcr_h, &pcr_l, pkt->data) == 0) {
1408
            /* we read the next PCR (XXX: optimize it by using a bigger buffer */
1409
            pos = url_ftell(s->pb);
1410
            for(i = 0; i < MAX_PACKET_READAHEAD; i++) {
1411
                url_fseek(s->pb, pos + i * ts->raw_packet_size, SEEK_SET);
1412
                get_buffer(s->pb, pcr_buf, 12);
1413
                if (parse_pcr(&next_pcr_h, &next_pcr_l, pcr_buf) == 0) {
1414
                    /* XXX: not precise enough */
1415
                    ts->pcr_incr = ((next_pcr_h - pcr_h) * 300 + (next_pcr_l - pcr_l)) /
1416
                        (i + 1);
1417
                    break;
1418
                }
1419
            }
1420
            url_fseek(s->pb, pos, SEEK_SET);
1421
            /* no next PCR found: we use previous increment */
1422
            ts->cur_pcr = pcr_h * 300 + pcr_l;
1423
        }
1424
        pkt->pts = ts->cur_pcr;
1425
        pkt->duration = ts->pcr_incr;
1426
        ts->cur_pcr += ts->pcr_incr;
1427
    }
1428
    pkt->stream_index = 0;
1429
    return 0;
1430
}
1431

    
1432
static int mpegts_read_packet(AVFormatContext *s,
1433
                              AVPacket *pkt)
1434
{
1435
    MpegTSContext *ts = s->priv_data;
1436
    int ret, i;
1437

    
1438
    if (url_ftell(s->pb) != ts->last_pos) {
1439
        /* seek detected, flush pes buffer */
1440
        for (i = 0; i < NB_PID_MAX; i++) {
1441
            if (ts->pids[i] && ts->pids[i]->type == MPEGTS_PES) {
1442
                PESContext *pes = ts->pids[i]->u.pes_filter.opaque;
1443
                av_freep(&pes->buffer);
1444
                pes->data_index = 0;
1445
                pes->state = MPEGTS_SKIP; /* skip until pes header */
1446
            }
1447
        }
1448
    }
1449

    
1450
    ts->pkt = pkt;
1451
    ret = handle_packets(ts, 0);
1452
    if (ret < 0) {
1453
        /* flush pes data left */
1454
        for (i = 0; i < NB_PID_MAX; i++) {
1455
            if (ts->pids[i] && ts->pids[i]->type == MPEGTS_PES) {
1456
                PESContext *pes = ts->pids[i]->u.pes_filter.opaque;
1457
                if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
1458
                    new_pes_packet(pes, pkt);
1459
                    ret = 0;
1460
                    break;
1461
                }
1462
            }
1463
        }
1464
    }
1465

    
1466
    ts->last_pos = url_ftell(s->pb);
1467

    
1468
    return ret;
1469
}
1470

    
1471
static int mpegts_read_close(AVFormatContext *s)
1472
{
1473
    MpegTSContext *ts = s->priv_data;
1474
    int i;
1475

    
1476
    clear_programs(ts);
1477

    
1478
    for(i=0;i<NB_PID_MAX;i++)
1479
        if (ts->pids[i]) mpegts_close_filter(ts, ts->pids[i]);
1480

    
1481
    return 0;
1482
}
1483

    
1484
static int64_t mpegts_get_pcr(AVFormatContext *s, int stream_index,
1485
                              int64_t *ppos, int64_t pos_limit)
1486
{
1487
    MpegTSContext *ts = s->priv_data;
1488
    int64_t pos, timestamp;
1489
    uint8_t buf[TS_PACKET_SIZE];
1490
    int pcr_l, pcr_pid = ((PESContext*)s->streams[stream_index]->priv_data)->pcr_pid;
1491
    const int find_next= 1;
1492
    pos = ((*ppos  + ts->raw_packet_size - 1 - ts->pos47) / ts->raw_packet_size) * ts->raw_packet_size + ts->pos47;
1493
    if (find_next) {
1494
        for(;;) {
1495
            url_fseek(s->pb, pos, SEEK_SET);
1496
            if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
1497
                return AV_NOPTS_VALUE;
1498
            if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
1499
                parse_pcr(&timestamp, &pcr_l, buf) == 0) {
1500
                break;
1501
            }
1502
            pos += ts->raw_packet_size;
1503
        }
1504
    } else {
1505
        for(;;) {
1506
            pos -= ts->raw_packet_size;
1507
            if (pos < 0)
1508
                return AV_NOPTS_VALUE;
1509
            url_fseek(s->pb, pos, SEEK_SET);
1510
            if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
1511
                return AV_NOPTS_VALUE;
1512
            if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
1513
                parse_pcr(&timestamp, &pcr_l, buf) == 0) {
1514
                break;
1515
            }
1516
        }
1517
    }
1518
    *ppos = pos;
1519

    
1520
    return timestamp;
1521
}
1522

    
1523
static int read_seek(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1524
    MpegTSContext *ts = s->priv_data;
1525
    uint8_t buf[TS_PACKET_SIZE];
1526
    int64_t pos;
1527

    
1528
    if(av_seek_frame_binary(s, stream_index, target_ts, flags) < 0)
1529
        return -1;
1530

    
1531
    pos= url_ftell(s->pb);
1532

    
1533
    for(;;) {
1534
        url_fseek(s->pb, pos, SEEK_SET);
1535
        if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
1536
            return -1;
1537
//        pid = AV_RB16(buf + 1) & 0x1fff;
1538
        if(buf[1] & 0x40) break;
1539
        pos += ts->raw_packet_size;
1540
    }
1541
    url_fseek(s->pb, pos, SEEK_SET);
1542

    
1543
    return 0;
1544
}
1545

    
1546
/**************************************************************/
1547
/* parsing functions - called from other demuxers such as RTP */
1548

    
1549
MpegTSContext *mpegts_parse_open(AVFormatContext *s)
1550
{
1551
    MpegTSContext *ts;
1552

    
1553
    ts = av_mallocz(sizeof(MpegTSContext));
1554
    if (!ts)
1555
        return NULL;
1556
    /* no stream case, currently used by RTP */
1557
    ts->raw_packet_size = TS_PACKET_SIZE;
1558
    ts->stream = s;
1559
    ts->auto_guess = 1;
1560
    return ts;
1561
}
1562

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

    
1570
    len1 = len;
1571
    ts->pkt = pkt;
1572
    ts->stop_parse = 0;
1573
    for(;;) {
1574
        if (ts->stop_parse>0)
1575
            break;
1576
        if (len < TS_PACKET_SIZE)
1577
            return -1;
1578
        if (buf[0] != 0x47) {
1579
            buf++;
1580
            len--;
1581
        } else {
1582
            handle_packet(ts, buf);
1583
            buf += TS_PACKET_SIZE;
1584
            len -= TS_PACKET_SIZE;
1585
        }
1586
    }
1587
    return len1 - len;
1588
}
1589

    
1590
void mpegts_parse_close(MpegTSContext *ts)
1591
{
1592
    int i;
1593

    
1594
    for(i=0;i<NB_PID_MAX;i++)
1595
        av_free(ts->pids[i]);
1596
    av_free(ts);
1597
}
1598

    
1599
AVInputFormat mpegts_demuxer = {
1600
    "mpegts",
1601
    NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
1602
    sizeof(MpegTSContext),
1603
    mpegts_probe,
1604
    mpegts_read_header,
1605
    mpegts_read_packet,
1606
    mpegts_read_close,
1607
    read_seek,
1608
    mpegts_get_pcr,
1609
    .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
1610
};
1611

    
1612
AVInputFormat mpegtsraw_demuxer = {
1613
    "mpegtsraw",
1614
    NULL_IF_CONFIG_SMALL("MPEG-2 raw transport stream format"),
1615
    sizeof(MpegTSContext),
1616
    NULL,
1617
    mpegts_read_header,
1618
    mpegts_raw_read_packet,
1619
    mpegts_read_close,
1620
    read_seek,
1621
    mpegts_get_pcr,
1622
    .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
1623
};