Statistics
| Branch: | Revision:

ffmpeg / libavformat / mpegts.c @ 8537591a

History | View | Annotate | Download (45.2 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
#include "libavutil/crc.h"
23
#include "libavutil/intreadwrite.h"
24
#include "avformat.h"
25
#include "mpegts.h"
26
#include "internal.h"
27

    
28
//#define DEBUG_SI
29
//#define DEBUG_SEEK
30

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

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

    
39
typedef struct PESContext PESContext;
40

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

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

    
49
typedef struct MpegTSFilter MpegTSFilter;
50

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

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

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

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

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

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

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

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

    
95
    int pos47;
96

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

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

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

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

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

    
119

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

    
124
/* TS stream handling */
125

    
126
enum MpegTSState {
127
    MPEGTS_HEADER = 0,
128
    MPEGTS_PESHEADER_FILL,
129
    MPEGTS_PAYLOAD,
130
    MPEGTS_SKIP,
131
};
132

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

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

    
154
extern AVInputFormat mpegts_demuxer;
155

    
156
static void clear_program(MpegTSContext *ts, unsigned int programid)
157
{
158
    int i;
159

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

    
165
static void clear_programs(MpegTSContext *ts)
166
{
167
    av_freep(&ts->prg);
168
    ts->nb_prg=0;
169
}
170

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

    
184
static void add_pid_to_pmt(MpegTSContext *ts, unsigned int programid, unsigned int pid)
185
{
186
    int i;
187
    struct Program *p = NULL;
188
    for(i=0; i<ts->nb_prg; i++) {
189
        if(ts->prg[i].id == programid) {
190
            p = &ts->prg[i];
191
            break;
192
        }
193
    }
194
    if(!p)
195
        return;
196

    
197
    if(p->nb_pids >= MAX_PIDS_PER_PROGRAM)
198
        return;
199
    p->pids[p->nb_pids++] = pid;
200
}
201

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

    
232
    return !used && discarded;
233
}
234

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

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

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

    
268
    if (tss->section_h_size != -1 && tss->section_index >= tss->section_h_size) {
269
        tss->end_of_section_reached = 1;
270
        if (!tss->check_crc ||
271
            av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1,
272
                   tss->section_buf, tss->section_h_size) == 0)
273
            tss->section_cb(tss1, tss->section_buf, tss->section_h_size);
274
    }
275
}
276

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

    
281
{
282
    MpegTSFilter *filter;
283
    MpegTSSectionFilter *sec;
284

    
285
#ifdef DEBUG_SI
286
    av_log(ts->stream, AV_LOG_DEBUG, "Filter: pid=0x%x\n", pid);
287
#endif
288
    if (pid >= NB_PID_MAX || ts->pids[pid])
289
        return NULL;
290
    filter = av_mallocz(sizeof(MpegTSFilter));
291
    if (!filter)
292
        return NULL;
293
    ts->pids[pid] = filter;
294
    filter->type = MPEGTS_SECTION;
295
    filter->pid = pid;
296
    filter->last_cc = -1;
297
    sec = &filter->u.section_filter;
298
    sec->section_cb = section_cb;
299
    sec->opaque = opaque;
300
    sec->section_buf = av_malloc(MAX_SECTION_SIZE);
301
    sec->check_crc = check_crc;
302
    if (!sec->section_buf) {
303
        av_free(filter);
304
        return NULL;
305
    }
306
    return filter;
307
}
308

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

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

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

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

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

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

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

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

    
367
        x++;
368
        if(x == packet_size) x= 0;
369
    }
370

    
371
    return best_score;
372
}
373

    
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
    if (size < (TS_FEC_PACKET_SIZE * 5 + 1))
380
        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
    if     (score > fec_score && score > dvhs_score) return TS_PACKET_SIZE;
388
    else if(dvhs_score > score && dvhs_score > fec_score) return TS_DVHS_PACKET_SIZE;
389
    else if(score < fec_score && dvhs_score < fec_score) return TS_FEC_PACKET_SIZE;
390
    else                       return -1;
391
}
392

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

    
401
static inline int get8(const uint8_t **pp, const uint8_t *p_end)
402
{
403
    const uint8_t *p;
404
    int c;
405

    
406
    p = *pp;
407
    if (p >= p_end)
408
        return -1;
409
    c = *p++;
410
    *pp = p;
411
    return c;
412
}
413

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

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

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

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

    
451
static int parse_section_header(SectionHeader *h,
452
                                const uint8_t **pp, const uint8_t *p_end)
453
{
454
    int val;
455

    
456
    val = get8(pp, p_end);
457
    if (val < 0)
458
        return -1;
459
    h->tid = val;
460
    *pp += 2;
461
    val = get16(pp, p_end);
462
    if (val < 0)
463
        return -1;
464
    h->id = val;
465
    val = get8(pp, p_end);
466
    if (val < 0)
467
        return -1;
468
    h->version = (val >> 1) & 0x1f;
469
    val = get8(pp, p_end);
470
    if (val < 0)
471
        return -1;
472
    h->sec_num = val;
473
    val = get8(pp, p_end);
474
    if (val < 0)
475
        return -1;
476
    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
    PESContext *pes;
486
    AVStream *st;
487
    const uint8_t *p, *p_end, *desc_list_end, *desc_end;
488
    int program_info_length, pcr_pid, pid, stream_type;
489
    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

    
495
#ifdef DEBUG_SI
496
    av_log(ts->stream, AV_LOG_DEBUG, "PMT: len %i\n", section_len);
497
    av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
498
#endif
499
    p_end = section + section_len - 4;
500
    p = section;
501
    if (parse_section_header(h, &p, p_end) < 0)
502
        return;
503
#ifdef DEBUG_SI
504
    av_log(ts->stream, AV_LOG_DEBUG, "sid=0x%x sec_num=%d/%d\n",
505
           h->id, h->sec_num, h->last_sec_num);
506
#endif
507
    if (h->tid != PMT_TID)
508
        return;
509

    
510
    clear_program(ts, h->id);
511
    pcr_pid = get16(&p, p_end) & 0x1fff;
512
    if (pcr_pid < 0)
513
        return;
514
    add_pid_to_pmt(ts, h->id, pcr_pid);
515
#ifdef DEBUG_SI
516
    av_log(ts->stream, AV_LOG_DEBUG, "pcr_pid=0x%x\n", pcr_pid);
517
#endif
518
    program_info_length = get16(&p, p_end) & 0xfff;
519
    if (program_info_length < 0)
520
        return;
521
    while(program_info_length >= 2) {
522
        uint8_t tag, len;
523
        tag = get8(&p, p_end);
524
        len = get8(&p, p_end);
525
        if(len > program_info_length - 2)
526
            //something else is broken, exit the program_descriptors_loop
527
            break;
528
        program_info_length -= len + 2;
529
        if(tag == REGISTRATION_DESCRIPTOR && len >= 4) {
530
            uint8_t bytes[4];
531
            bytes[0] = get8(&p, p_end);
532
            bytes[1] = get8(&p, p_end);
533
            bytes[2] = get8(&p, p_end);
534
            bytes[3] = get8(&p, p_end);
535
            len -= 4;
536
            if(bytes[0] == 'H' && bytes[1] == 'D' &&
537
               bytes[2] == 'M' && bytes[3] == 'V')
538
                has_hdmv_descr = 1;
539
        }
540
        p += len;
541
    }
542
    p += program_info_length;
543
    if (p >= p_end)
544
        return;
545
    for(;;) {
546
        language[0] = 0;
547
        st = 0;
548
        stream_type = get8(&p, p_end);
549
        if (stream_type < 0)
550
            break;
551
        pid = get16(&p, p_end) & 0x1fff;
552
        if (pid < 0)
553
            break;
554
        desc_list_len = get16(&p, p_end) & 0xfff;
555
        if (desc_list_len < 0)
556
            break;
557
        desc_list_end = p + desc_list_len;
558
        if (desc_list_end > p_end)
559
            break;
560
        for(;;) {
561
            desc_tag = get8(&p, desc_list_end);
562
            if (desc_tag < 0)
563
                break;
564
            if (stream_type == STREAM_TYPE_PRIVATE_DATA) {
565
                if((desc_tag == 0x6A) || (desc_tag == 0x7A)) {
566
                    /*assume DVB AC-3 Audio*/
567
                    stream_type = STREAM_TYPE_AUDIO_AC3;
568
                } else if(desc_tag == 0x7B) {
569
                    /* DVB DTS audio */
570
                    stream_type = STREAM_TYPE_AUDIO_DTS;
571
                }
572
            }
573
            desc_len = get8(&p, desc_list_end);
574
            desc_end = p + desc_len;
575
            if (desc_end > desc_list_end)
576
                break;
577
#ifdef DEBUG_SI
578
            av_log(ts->stream, AV_LOG_DEBUG, "tag: 0x%02x len=%d\n",
579
                   desc_tag, desc_len);
580
#endif
581
            switch(desc_tag) {
582
            case DVB_SUBT_DESCID:
583
                if (stream_type == STREAM_TYPE_PRIVATE_DATA)
584
                    stream_type = STREAM_TYPE_SUBTITLE_DVB;
585

    
586
                language[0] = get8(&p, desc_end);
587
                language[1] = get8(&p, desc_end);
588
                language[2] = get8(&p, desc_end);
589
                language[3] = 0;
590
                get8(&p, desc_end);
591
                comp_page = get16(&p, desc_end);
592
                anc_page = get16(&p, desc_end);
593

    
594
                break;
595
            case 0x0a: /* ISO 639 language descriptor */
596
                language[0] = get8(&p, desc_end);
597
                language[1] = get8(&p, desc_end);
598
                language[2] = get8(&p, desc_end);
599
                language[3] = 0;
600
                break;
601
            case REGISTRATION_DESCRIPTOR: /*MPEG-2 Registration descriptor */
602
                {
603
                    uint8_t bytes[4];
604
                    bytes[0] = get8(&p, desc_end);
605
                    bytes[1] = get8(&p, desc_end);
606
                    bytes[2] = get8(&p, desc_end);
607
                    bytes[3] = get8(&p, desc_end);
608
                    if(bytes[0] == 'd' && bytes[1] == 'r' &&
609
                       bytes[2] == 'a' && bytes[3] == 'c')
610
                        has_dirac_descr = 1;
611
                    break;
612
                }
613
            default:
614
                break;
615
            }
616
            p = desc_end;
617
        }
618
        p = desc_list_end;
619

    
620
#ifdef DEBUG_SI
621
        av_log(ts->stream, AV_LOG_DEBUG, "stream_type=%d pid=0x%x\n",
622
               stream_type, pid);
623
#endif
624

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

    
661
        if (st) {
662
            if (language[0] != 0) {
663
                av_metadata_set(&st->metadata, "language", language);
664
            }
665

    
666
            if (stream_type == STREAM_TYPE_SUBTITLE_DVB) {
667
                st->codec->sub_id = (anc_page << 16) | comp_page;
668
            }
669
        }
670
    }
671
    /* all parameters are there */
672
    ts->stop_parse++;
673
    mpegts_close_filter(ts, filter);
674
}
675

    
676
static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
677
{
678
    MpegTSContext *ts = filter->u.section_filter.opaque;
679
    SectionHeader h1, *h = &h1;
680
    const uint8_t *p, *p_end;
681
    int sid, pmt_pid;
682

    
683
#ifdef DEBUG_SI
684
    av_log(ts->stream, AV_LOG_DEBUG, "PAT:\n");
685
    av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
686
#endif
687
    p_end = section + section_len - 4;
688
    p = section;
689
    if (parse_section_header(h, &p, p_end) < 0)
690
        return;
691
    if (h->tid != PAT_TID)
692
        return;
693

    
694
    clear_programs(ts);
695
    for(;;) {
696
        sid = get16(&p, p_end);
697
        if (sid < 0)
698
            break;
699
        pmt_pid = get16(&p, p_end) & 0x1fff;
700
        if (pmt_pid < 0)
701
            break;
702
#ifdef DEBUG_SI
703
        av_log(ts->stream, AV_LOG_DEBUG, "sid=0x%x pid=0x%x\n", sid, pmt_pid);
704
#endif
705
        if (sid == 0x0000) {
706
            /* NIT info */
707
        } else {
708
            av_new_program(ts->stream, sid);
709
            ts->stop_parse--;
710
            mpegts_open_section_filter(ts, pmt_pid, pmt_cb, ts, 1);
711
            add_pat_entry(ts, sid);
712
            add_pid_to_pmt(ts, sid, 0); //add pat pid to program
713
            add_pid_to_pmt(ts, sid, pmt_pid);
714
        }
715
    }
716
    /* not found */
717
    ts->stop_parse++;
718

    
719
    mpegts_close_filter(ts, filter);
720
}
721

    
722
static void mpegts_set_service(MpegTSContext *ts)
723
{
724
    mpegts_open_section_filter(ts, PAT_PID,
725
                                                pat_cb, ts, 1);
726
}
727

    
728
static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
729
{
730
    MpegTSContext *ts = filter->u.section_filter.opaque;
731
    SectionHeader h1, *h = &h1;
732
    const uint8_t *p, *p_end, *desc_list_end, *desc_end;
733
    int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type;
734
    char *name, *provider_name;
735

    
736
#ifdef DEBUG_SI
737
    av_log(ts->stream, AV_LOG_DEBUG, "SDT:\n");
738
    av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
739
#endif
740

    
741
    p_end = section + section_len - 4;
742
    p = section;
743
    if (parse_section_header(h, &p, p_end) < 0)
744
        return;
745
    if (h->tid != SDT_TID)
746
        return;
747
    onid = get16(&p, p_end);
748
    if (onid < 0)
749
        return;
750
    val = get8(&p, p_end);
751
    if (val < 0)
752
        return;
753
    for(;;) {
754
        sid = get16(&p, p_end);
755
        if (sid < 0)
756
            break;
757
        val = get8(&p, p_end);
758
        if (val < 0)
759
            break;
760
        desc_list_len = get16(&p, p_end) & 0xfff;
761
        if (desc_list_len < 0)
762
            break;
763
        desc_list_end = p + desc_list_len;
764
        if (desc_list_end > p_end)
765
            break;
766
        for(;;) {
767
            desc_tag = get8(&p, desc_list_end);
768
            if (desc_tag < 0)
769
                break;
770
            desc_len = get8(&p, desc_list_end);
771
            desc_end = p + desc_len;
772
            if (desc_end > desc_list_end)
773
                break;
774
#ifdef DEBUG_SI
775
            av_log(ts->stream, AV_LOG_DEBUG, "tag: 0x%02x len=%d\n",
776
                   desc_tag, desc_len);
777
#endif
778
            switch(desc_tag) {
779
            case 0x48:
780
                service_type = get8(&p, p_end);
781
                if (service_type < 0)
782
                    break;
783
                provider_name = getstr8(&p, p_end);
784
                if (!provider_name)
785
                    break;
786
                name = getstr8(&p, p_end);
787
                if (name) {
788
                    AVProgram *program = av_new_program(ts->stream, sid);
789
                    if(program) {
790
                        av_metadata_set(&program->metadata, "name", name);
791
                        av_metadata_set(&program->metadata, "provider_name", provider_name);
792
                    }
793
                }
794
                av_free(name);
795
                av_free(provider_name);
796
                break;
797
            default:
798
                break;
799
            }
800
            p = desc_end;
801
        }
802
        p = desc_list_end;
803
    }
804
}
805

    
806
/* scan services in a transport stream by looking at the SDT */
807
static void mpegts_scan_sdt(MpegTSContext *ts)
808
{
809
    mpegts_open_section_filter(ts, SDT_PID,
810
                                                sdt_cb, ts, 1);
811
}
812

    
813
static int64_t get_pts(const uint8_t *p)
814
{
815
    int64_t pts = (int64_t)((p[0] >> 1) & 0x07) << 30;
816
    pts |= (AV_RB16(p + 1) >> 1) << 15;
817
    pts |=  AV_RB16(p + 3) >> 1;
818
    return pts;
819
}
820

    
821
/* return non zero if a packet could be constructed */
822
static void mpegts_push_data(MpegTSFilter *filter,
823
                             const uint8_t *buf, int buf_size, int is_start,
824
                             int64_t pos)
825
{
826
    PESContext *pes = filter->u.pes_filter.opaque;
827
    MpegTSContext *ts = pes->ts;
828
    const uint8_t *p;
829
    int len, code;
830

    
831
    if(!ts->pkt)
832
        return;
833

    
834
    if (is_start) {
835
        pes->state = MPEGTS_HEADER;
836
        pes->data_index = 0;
837
        pes->ts_packet_pos = pos;
838
    }
839
    p = buf;
840
    while (buf_size > 0) {
841
        switch(pes->state) {
842
        case MPEGTS_HEADER:
843
            len = PES_START_SIZE - pes->data_index;
844
            if (len > buf_size)
845
                len = buf_size;
846
            memcpy(pes->header + pes->data_index, p, len);
847
            pes->data_index += len;
848
            p += len;
849
            buf_size -= len;
850
            if (pes->data_index == PES_START_SIZE) {
851
                /* we got all the PES or section header. We can now
852
                   decide */
853
#if 0
854
                av_hex_dump_log(pes->stream, AV_LOG_DEBUG, pes->header, pes->data_index);
855
#endif
856
                if (pes->header[0] == 0x00 && pes->header[1] == 0x00 &&
857
                    pes->header[2] == 0x01) {
858
                    /* it must be an mpeg2 PES stream */
859
                    code = pes->header[3] | 0x100;
860
                    if (!((code >= 0x1c0 && code <= 0x1df) ||
861
                          (code >= 0x1e0 && code <= 0x1ef) ||
862
                          (code == 0x1bd) || (code == 0x1fd)))
863
                        goto skip;
864
                    if (!pes->st) {
865
                        /* allocate stream */
866
                        new_pes_av_stream(pes, code);
867
                    }
868
                    pes->state = MPEGTS_PESHEADER_FILL;
869
                    pes->total_size = AV_RB16(pes->header + 4);
870
                    /* NOTE: a zero total size means the PES size is
871
                       unbounded */
872
                    if (pes->total_size)
873
                        pes->total_size += 6;
874
                    pes->pes_header_size = pes->header[8] + 9;
875
                } else {
876
                    /* otherwise, it should be a table */
877
                    /* skip packet */
878
                skip:
879
                    pes->state = MPEGTS_SKIP;
880
                    continue;
881
                }
882
            }
883
            break;
884
            /**********************************************/
885
            /* PES packing parsing */
886
        case MPEGTS_PESHEADER_FILL:
887
            len = pes->pes_header_size - pes->data_index;
888
            if (len > buf_size)
889
                len = buf_size;
890
            memcpy(pes->header + pes->data_index, p, len);
891
            pes->data_index += len;
892
            p += len;
893
            buf_size -= len;
894
            if (pes->data_index == pes->pes_header_size) {
895
                const uint8_t *r;
896
                unsigned int flags;
897

    
898
                flags = pes->header[7];
899
                r = pes->header + 9;
900
                pes->pts = AV_NOPTS_VALUE;
901
                pes->dts = AV_NOPTS_VALUE;
902
                if ((flags & 0xc0) == 0x80) {
903
                    pes->dts = pes->pts = get_pts(r);
904
                    r += 5;
905
                } else if ((flags & 0xc0) == 0xc0) {
906
                    pes->pts = get_pts(r);
907
                    r += 5;
908
                    pes->dts = get_pts(r);
909
                    r += 5;
910
                }
911
                /* we got the full header. We parse it and get the payload */
912
                pes->state = MPEGTS_PAYLOAD;
913
            }
914
            break;
915
        case MPEGTS_PAYLOAD:
916
            if (pes->total_size) {
917
                len = pes->total_size - pes->data_index;
918
                if (len > buf_size)
919
                    len = buf_size;
920
            } else {
921
                len = buf_size;
922
            }
923
            if (len > 0) {
924
                AVPacket *pkt = ts->pkt;
925
                if (pes->st && av_new_packet(pkt, len) == 0) {
926
                    memcpy(pkt->data, p, len);
927
                    pkt->stream_index = pes->st->index;
928
                    pkt->pts = pes->pts;
929
                    pkt->dts = pes->dts;
930
                    /* store position of first TS packet of this PES packet */
931
                    pkt->pos = pes->ts_packet_pos;
932
                    /* reset pts values */
933
                    pes->pts = AV_NOPTS_VALUE;
934
                    pes->dts = AV_NOPTS_VALUE;
935
                    ts->stop_parse = 1;
936
                    return;
937
                }
938
            }
939
            buf_size = 0;
940
            break;
941
        case MPEGTS_SKIP:
942
            buf_size = 0;
943
            break;
944
        }
945
    }
946
}
947

    
948
static AVStream* new_pes_av_stream(PESContext *pes, uint32_t code)
949
{
950
    AVStream *st;
951
    enum CodecID codec_id;
952
    enum CodecType codec_type;
953

    
954
    switch(pes->stream_type){
955
    case STREAM_TYPE_AUDIO_MPEG1:
956
    case STREAM_TYPE_AUDIO_MPEG2:
957
        codec_type = CODEC_TYPE_AUDIO;
958
        codec_id = CODEC_ID_MP3;
959
        break;
960
    case STREAM_TYPE_VIDEO_MPEG1:
961
    case STREAM_TYPE_VIDEO_MPEG2:
962
        codec_type = CODEC_TYPE_VIDEO;
963
        codec_id = CODEC_ID_MPEG2VIDEO;
964
        break;
965
    case STREAM_TYPE_VIDEO_MPEG4:
966
        codec_type = CODEC_TYPE_VIDEO;
967
        codec_id = CODEC_ID_MPEG4;
968
        break;
969
    case STREAM_TYPE_VIDEO_H264:
970
        codec_type = CODEC_TYPE_VIDEO;
971
        codec_id = CODEC_ID_H264;
972
        break;
973
    case STREAM_TYPE_VIDEO_VC1:
974
        codec_type = CODEC_TYPE_VIDEO;
975
        codec_id = CODEC_ID_VC1;
976
        break;
977
    case STREAM_TYPE_VIDEO_DIRAC:
978
        codec_type = CODEC_TYPE_VIDEO;
979
        codec_id = CODEC_ID_DIRAC;
980
        break;
981
    case STREAM_TYPE_AUDIO_AAC:
982
        codec_type = CODEC_TYPE_AUDIO;
983
        codec_id = CODEC_ID_AAC;
984
        break;
985
    case STREAM_TYPE_AUDIO_AC3:
986
        codec_type = CODEC_TYPE_AUDIO;
987
        codec_id = CODEC_ID_AC3;
988
        break;
989
    case STREAM_TYPE_AUDIO_DTS:
990
    case STREAM_TYPE_AUDIO_HDMV_DTS:
991
        codec_type = CODEC_TYPE_AUDIO;
992
        codec_id = CODEC_ID_DTS;
993
        break;
994
    case STREAM_TYPE_SUBTITLE_DVB:
995
        codec_type = CODEC_TYPE_SUBTITLE;
996
        codec_id = CODEC_ID_DVB_SUBTITLE;
997
        break;
998
    default:
999
        if (code >= 0x1c0 && code <= 0x1df) {
1000
            codec_type = CODEC_TYPE_AUDIO;
1001
            codec_id = CODEC_ID_MP2;
1002
        } else if (code == 0x1bd) {
1003
            codec_type = CODEC_TYPE_AUDIO;
1004
            codec_id = CODEC_ID_AC3;
1005
        } else {
1006
            codec_type = CODEC_TYPE_VIDEO;
1007
            codec_id = CODEC_ID_PROBE;
1008
        }
1009
        break;
1010
    }
1011
    st = av_new_stream(pes->stream, pes->pid);
1012
    if (st) {
1013
        av_set_pts_info(st, 33, 1, 90000);
1014
        st->priv_data = pes;
1015
        st->codec->codec_type = codec_type;
1016
        st->codec->codec_id = codec_id;
1017
        st->need_parsing = AVSTREAM_PARSE_FULL;
1018
        pes->st = st;
1019
    }
1020
    return st;
1021
}
1022

    
1023

    
1024
static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid, int stream_type)
1025
{
1026
    MpegTSFilter *tss;
1027
    PESContext *pes;
1028

    
1029
    /* if no pid found, then add a pid context */
1030
    pes = av_mallocz(sizeof(PESContext));
1031
    if (!pes)
1032
        return 0;
1033
    pes->ts = ts;
1034
    pes->stream = ts->stream;
1035
    pes->pid = pid;
1036
    pes->pcr_pid = pcr_pid;
1037
    pes->stream_type = stream_type;
1038
    tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes);
1039
    if (!tss) {
1040
        av_free(pes);
1041
        return 0;
1042
    }
1043
    return pes;
1044
}
1045

    
1046
/* handle one TS packet */
1047
static void handle_packet(MpegTSContext *ts, const uint8_t *packet)
1048
{
1049
    AVFormatContext *s = ts->stream;
1050
    MpegTSFilter *tss;
1051
    int len, pid, cc, cc_ok, afc, is_start;
1052
    const uint8_t *p, *p_end;
1053
    int64_t pos;
1054

    
1055
    pid = AV_RB16(packet + 1) & 0x1fff;
1056
    if(pid && discard_pid(ts, pid))
1057
        return;
1058
    is_start = packet[1] & 0x40;
1059
    tss = ts->pids[pid];
1060
    if (ts->auto_guess && tss == NULL && is_start) {
1061
        add_pes_stream(ts, pid, -1, 0);
1062
        tss = ts->pids[pid];
1063
    }
1064
    if (!tss)
1065
        return;
1066

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

    
1072
    /* skip adaptation field */
1073
    afc = (packet[3] >> 4) & 3;
1074
    p = packet + 4;
1075
    if (afc == 0) /* reserved value */
1076
        return;
1077
    if (afc == 2) /* adaptation field only */
1078
        return;
1079
    if (afc == 3) {
1080
        /* skip adapation field */
1081
        p += p[0] + 1;
1082
    }
1083
    /* if past the end of packet, ignore */
1084
    p_end = packet + TS_PACKET_SIZE;
1085
    if (p >= p_end)
1086
        return;
1087

    
1088
    pos = url_ftell(ts->stream->pb);
1089
    ts->pos47= pos % ts->raw_packet_size;
1090

    
1091
    if (tss->type == MPEGTS_SECTION) {
1092
        if (is_start) {
1093
            /* pointer field present */
1094
            len = *p++;
1095
            if (p + len > p_end)
1096
                return;
1097
            if (len && cc_ok) {
1098
                /* write remaining section bytes */
1099
                write_section_data(s, tss,
1100
                                   p, len, 0);
1101
                /* check whether filter has been closed */
1102
                if (!ts->pids[pid])
1103
                    return;
1104
            }
1105
            p += len;
1106
            if (p < p_end) {
1107
                write_section_data(s, tss,
1108
                                   p, p_end - p, 1);
1109
            }
1110
        } else {
1111
            if (cc_ok) {
1112
                write_section_data(s, tss,
1113
                                   p, p_end - p, 0);
1114
            }
1115
        }
1116
    } else {
1117
        // Note: The position here points actually behind the current packet.
1118
        tss->u.pes_filter.pes_cb(tss,
1119
                                 p, p_end - p, is_start, pos - ts->raw_packet_size);
1120
    }
1121
}
1122

    
1123
/* XXX: try to find a better synchro over several packets (use
1124
   get_packet_size() ?) */
1125
static int mpegts_resync(ByteIOContext *pb)
1126
{
1127
    int c, i;
1128

    
1129
    for(i = 0;i < MAX_RESYNC_SIZE; i++) {
1130
        c = url_fgetc(pb);
1131
        if (c < 0)
1132
            return -1;
1133
        if (c == 0x47) {
1134
            url_fseek(pb, -1, SEEK_CUR);
1135
            return 0;
1136
        }
1137
    }
1138
    /* no sync found */
1139
    return -1;
1140
}
1141

    
1142
/* return -1 if error or EOF. Return 0 if OK. */
1143
static int read_packet(ByteIOContext *pb, uint8_t *buf, int raw_packet_size)
1144
{
1145
    int skip, len;
1146

    
1147
    for(;;) {
1148
        len = get_buffer(pb, buf, TS_PACKET_SIZE);
1149
        if (len != TS_PACKET_SIZE)
1150
            return AVERROR(EIO);
1151
        /* check paquet sync byte */
1152
        if (buf[0] != 0x47) {
1153
            /* find a new packet start */
1154
            url_fseek(pb, -TS_PACKET_SIZE, SEEK_CUR);
1155
            if (mpegts_resync(pb) < 0)
1156
                return AVERROR_INVALIDDATA;
1157
            else
1158
                continue;
1159
        } else {
1160
            skip = raw_packet_size - TS_PACKET_SIZE;
1161
            if (skip > 0)
1162
                url_fskip(pb, skip);
1163
            break;
1164
        }
1165
    }
1166
    return 0;
1167
}
1168

    
1169
static int handle_packets(MpegTSContext *ts, int nb_packets)
1170
{
1171
    AVFormatContext *s = ts->stream;
1172
    ByteIOContext *pb = s->pb;
1173
    uint8_t packet[TS_PACKET_SIZE];
1174
    int packet_num, ret;
1175

    
1176
    ts->stop_parse = 0;
1177
    packet_num = 0;
1178
    for(;;) {
1179
        if (ts->stop_parse>0)
1180
            break;
1181
        packet_num++;
1182
        if (nb_packets != 0 && packet_num >= nb_packets)
1183
            break;
1184
        ret = read_packet(pb, packet, ts->raw_packet_size);
1185
        if (ret != 0)
1186
            return ret;
1187
        handle_packet(ts, packet);
1188
    }
1189
    return 0;
1190
}
1191

    
1192
static int mpegts_probe(AVProbeData *p)
1193
{
1194
#if 1
1195
    const int size= p->buf_size;
1196
    int score, fec_score, dvhs_score;
1197
    int check_count= size / TS_FEC_PACKET_SIZE;
1198
#define CHECK_COUNT 10
1199

    
1200
    if (check_count < CHECK_COUNT)
1201
        return -1;
1202

    
1203
    score     = analyze(p->buf, TS_PACKET_SIZE     *check_count, TS_PACKET_SIZE     , NULL)*CHECK_COUNT/check_count;
1204
    dvhs_score= analyze(p->buf, TS_DVHS_PACKET_SIZE*check_count, TS_DVHS_PACKET_SIZE, NULL)*CHECK_COUNT/check_count;
1205
    fec_score = analyze(p->buf, TS_FEC_PACKET_SIZE *check_count, TS_FEC_PACKET_SIZE , NULL)*CHECK_COUNT/check_count;
1206
//    av_log(NULL, AV_LOG_DEBUG, "score: %d, dvhs_score: %d, fec_score: %d \n", score, dvhs_score, fec_score);
1207

    
1208
// we need a clear definition for the returned score otherwise things will become messy sooner or later
1209
    if     (score > fec_score && score > dvhs_score && score > 6) return AVPROBE_SCORE_MAX + score     - CHECK_COUNT;
1210
    else if(dvhs_score > score && dvhs_score > fec_score && dvhs_score > 6) return AVPROBE_SCORE_MAX + dvhs_score  - CHECK_COUNT;
1211
    else if(                 fec_score > 6) return AVPROBE_SCORE_MAX + fec_score - CHECK_COUNT;
1212
    else                                    return -1;
1213
#else
1214
    /* only use the extension for safer guess */
1215
    if (match_ext(p->filename, "ts"))
1216
        return AVPROBE_SCORE_MAX;
1217
    else
1218
        return 0;
1219
#endif
1220
}
1221

    
1222
/* return the 90kHz PCR and the extension for the 27MHz PCR. return
1223
   (-1) if not available */
1224
static int parse_pcr(int64_t *ppcr_high, int *ppcr_low,
1225
                     const uint8_t *packet)
1226
{
1227
    int afc, len, flags;
1228
    const uint8_t *p;
1229
    unsigned int v;
1230

    
1231
    afc = (packet[3] >> 4) & 3;
1232
    if (afc <= 1)
1233
        return -1;
1234
    p = packet + 4;
1235
    len = p[0];
1236
    p++;
1237
    if (len == 0)
1238
        return -1;
1239
    flags = *p++;
1240
    len--;
1241
    if (!(flags & 0x10))
1242
        return -1;
1243
    if (len < 6)
1244
        return -1;
1245
    v = AV_RB32(p);
1246
    *ppcr_high = ((int64_t)v << 1) | (p[4] >> 7);
1247
    *ppcr_low = ((p[4] & 1) << 8) | p[5];
1248
    return 0;
1249
}
1250

    
1251
static int mpegts_read_header(AVFormatContext *s,
1252
                              AVFormatParameters *ap)
1253
{
1254
    MpegTSContext *ts = s->priv_data;
1255
    ByteIOContext *pb = s->pb;
1256
    uint8_t buf[5*1024];
1257
    int len;
1258
    int64_t pos;
1259

    
1260
    if (ap) {
1261
        ts->mpeg2ts_compute_pcr = ap->mpeg2ts_compute_pcr;
1262
        if(ap->mpeg2ts_raw){
1263
            av_log(s, AV_LOG_ERROR, "use mpegtsraw_demuxer!\n");
1264
            return -1;
1265
        }
1266
    }
1267

    
1268
    /* read the first 1024 bytes to get packet size */
1269
    pos = url_ftell(pb);
1270
    len = get_buffer(pb, buf, sizeof(buf));
1271
    if (len != sizeof(buf))
1272
        goto fail;
1273
    ts->raw_packet_size = get_packet_size(buf, sizeof(buf));
1274
    if (ts->raw_packet_size <= 0)
1275
        goto fail;
1276
    ts->stream = s;
1277
    ts->auto_guess = 0;
1278

    
1279
    if (s->iformat == &mpegts_demuxer) {
1280
        /* normal demux */
1281

    
1282
        /* first do a scaning to get all the services */
1283
        url_fseek(pb, pos, SEEK_SET);
1284
        mpegts_scan_sdt(ts);
1285

    
1286
        mpegts_set_service(ts);
1287

    
1288
        handle_packets(ts, s->probesize);
1289
        /* if could not find service, enable auto_guess */
1290

    
1291
        ts->auto_guess = 1;
1292

    
1293
#ifdef DEBUG_SI
1294
        av_log(ts->stream, AV_LOG_DEBUG, "tuning done\n");
1295
#endif
1296
        s->ctx_flags |= AVFMTCTX_NOHEADER;
1297
    } else {
1298
        AVStream *st;
1299
        int pcr_pid, pid, nb_packets, nb_pcrs, ret, pcr_l;
1300
        int64_t pcrs[2], pcr_h;
1301
        int packet_count[2];
1302
        uint8_t packet[TS_PACKET_SIZE];
1303

    
1304
        /* only read packets */
1305

    
1306
        st = av_new_stream(s, 0);
1307
        if (!st)
1308
            goto fail;
1309
        av_set_pts_info(st, 60, 1, 27000000);
1310
        st->codec->codec_type = CODEC_TYPE_DATA;
1311
        st->codec->codec_id = CODEC_ID_MPEG2TS;
1312

    
1313
        /* we iterate until we find two PCRs to estimate the bitrate */
1314
        pcr_pid = -1;
1315
        nb_pcrs = 0;
1316
        nb_packets = 0;
1317
        for(;;) {
1318
            ret = read_packet(s->pb, packet, ts->raw_packet_size);
1319
            if (ret < 0)
1320
                return -1;
1321
            pid = AV_RB16(packet + 1) & 0x1fff;
1322
            if ((pcr_pid == -1 || pcr_pid == pid) &&
1323
                parse_pcr(&pcr_h, &pcr_l, packet) == 0) {
1324
                pcr_pid = pid;
1325
                packet_count[nb_pcrs] = nb_packets;
1326
                pcrs[nb_pcrs] = pcr_h * 300 + pcr_l;
1327
                nb_pcrs++;
1328
                if (nb_pcrs >= 2)
1329
                    break;
1330
            }
1331
            nb_packets++;
1332
        }
1333

    
1334
        /* NOTE1: the bitrate is computed without the FEC */
1335
        /* NOTE2: it is only the bitrate of the start of the stream */
1336
        ts->pcr_incr = (pcrs[1] - pcrs[0]) / (packet_count[1] - packet_count[0]);
1337
        ts->cur_pcr = pcrs[0] - ts->pcr_incr * packet_count[0];
1338
        s->bit_rate = (TS_PACKET_SIZE * 8) * 27e6 / ts->pcr_incr;
1339
        st->codec->bit_rate = s->bit_rate;
1340
        st->start_time = ts->cur_pcr;
1341
#if 0
1342
        av_log(ts->stream, AV_LOG_DEBUG, "start=%0.3f pcr=%0.3f incr=%d\n",
1343
               st->start_time / 1000000.0, pcrs[0] / 27e6, ts->pcr_incr);
1344
#endif
1345
    }
1346

    
1347
    url_fseek(pb, pos, SEEK_SET);
1348
    return 0;
1349
 fail:
1350
    return -1;
1351
}
1352

    
1353
#define MAX_PACKET_READAHEAD ((128 * 1024) / 188)
1354

    
1355
static int mpegts_raw_read_packet(AVFormatContext *s,
1356
                                  AVPacket *pkt)
1357
{
1358
    MpegTSContext *ts = s->priv_data;
1359
    int ret, i;
1360
    int64_t pcr_h, next_pcr_h, pos;
1361
    int pcr_l, next_pcr_l;
1362
    uint8_t pcr_buf[12];
1363

    
1364
    if (av_new_packet(pkt, TS_PACKET_SIZE) < 0)
1365
        return AVERROR(ENOMEM);
1366
    pkt->pos= url_ftell(s->pb);
1367
    ret = read_packet(s->pb, pkt->data, ts->raw_packet_size);
1368
    if (ret < 0) {
1369
        av_free_packet(pkt);
1370
        return ret;
1371
    }
1372
    if (ts->mpeg2ts_compute_pcr) {
1373
        /* compute exact PCR for each packet */
1374
        if (parse_pcr(&pcr_h, &pcr_l, pkt->data) == 0) {
1375
            /* we read the next PCR (XXX: optimize it by using a bigger buffer */
1376
            pos = url_ftell(s->pb);
1377
            for(i = 0; i < MAX_PACKET_READAHEAD; i++) {
1378
                url_fseek(s->pb, pos + i * ts->raw_packet_size, SEEK_SET);
1379
                get_buffer(s->pb, pcr_buf, 12);
1380
                if (parse_pcr(&next_pcr_h, &next_pcr_l, pcr_buf) == 0) {
1381
                    /* XXX: not precise enough */
1382
                    ts->pcr_incr = ((next_pcr_h - pcr_h) * 300 + (next_pcr_l - pcr_l)) /
1383
                        (i + 1);
1384
                    break;
1385
                }
1386
            }
1387
            url_fseek(s->pb, pos, SEEK_SET);
1388
            /* no next PCR found: we use previous increment */
1389
            ts->cur_pcr = pcr_h * 300 + pcr_l;
1390
        }
1391
        pkt->pts = ts->cur_pcr;
1392
        pkt->duration = ts->pcr_incr;
1393
        ts->cur_pcr += ts->pcr_incr;
1394
    }
1395
    pkt->stream_index = 0;
1396
    return 0;
1397
}
1398

    
1399
static int mpegts_read_packet(AVFormatContext *s,
1400
                              AVPacket *pkt)
1401
{
1402
    MpegTSContext *ts = s->priv_data;
1403

    
1404
    ts->pkt = pkt;
1405
    return handle_packets(ts, 0);
1406
}
1407

    
1408
static int mpegts_read_close(AVFormatContext *s)
1409
{
1410
    MpegTSContext *ts = s->priv_data;
1411
    int i;
1412

    
1413
    clear_programs(ts);
1414

    
1415
    for(i=0;i<NB_PID_MAX;i++)
1416
        if (ts->pids[i]) mpegts_close_filter(ts, ts->pids[i]);
1417

    
1418
    return 0;
1419
}
1420

    
1421
static int64_t mpegts_get_pcr(AVFormatContext *s, int stream_index,
1422
                              int64_t *ppos, int64_t pos_limit)
1423
{
1424
    MpegTSContext *ts = s->priv_data;
1425
    int64_t pos, timestamp;
1426
    uint8_t buf[TS_PACKET_SIZE];
1427
    int pcr_l, pcr_pid = ((PESContext*)s->streams[stream_index]->priv_data)->pcr_pid;
1428
    const int find_next= 1;
1429
    pos = ((*ppos  + ts->raw_packet_size - 1 - ts->pos47) / ts->raw_packet_size) * ts->raw_packet_size + ts->pos47;
1430
    if (find_next) {
1431
        for(;;) {
1432
            url_fseek(s->pb, pos, SEEK_SET);
1433
            if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
1434
                return AV_NOPTS_VALUE;
1435
            if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
1436
                parse_pcr(&timestamp, &pcr_l, buf) == 0) {
1437
                break;
1438
            }
1439
            pos += ts->raw_packet_size;
1440
        }
1441
    } else {
1442
        for(;;) {
1443
            pos -= ts->raw_packet_size;
1444
            if (pos < 0)
1445
                return AV_NOPTS_VALUE;
1446
            url_fseek(s->pb, pos, SEEK_SET);
1447
            if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
1448
                return AV_NOPTS_VALUE;
1449
            if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
1450
                parse_pcr(&timestamp, &pcr_l, buf) == 0) {
1451
                break;
1452
            }
1453
        }
1454
    }
1455
    *ppos = pos;
1456

    
1457
    return timestamp;
1458
}
1459

    
1460
static int read_seek(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1461
    MpegTSContext *ts = s->priv_data;
1462
    uint8_t buf[TS_PACKET_SIZE];
1463
    int64_t pos;
1464

    
1465
    if(av_seek_frame_binary(s, stream_index, target_ts, flags) < 0)
1466
        return -1;
1467

    
1468
    pos= url_ftell(s->pb);
1469

    
1470
    for(;;) {
1471
        url_fseek(s->pb, pos, SEEK_SET);
1472
        if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
1473
            return -1;
1474
//        pid = AV_RB16(buf + 1) & 0x1fff;
1475
        if(buf[1] & 0x40) break;
1476
        pos += ts->raw_packet_size;
1477
    }
1478
    url_fseek(s->pb, pos, SEEK_SET);
1479

    
1480
    return 0;
1481
}
1482

    
1483
/**************************************************************/
1484
/* parsing functions - called from other demuxers such as RTP */
1485

    
1486
MpegTSContext *mpegts_parse_open(AVFormatContext *s)
1487
{
1488
    MpegTSContext *ts;
1489

    
1490
    ts = av_mallocz(sizeof(MpegTSContext));
1491
    if (!ts)
1492
        return NULL;
1493
    /* no stream case, currently used by RTP */
1494
    ts->raw_packet_size = TS_PACKET_SIZE;
1495
    ts->stream = s;
1496
    ts->auto_guess = 1;
1497
    return ts;
1498
}
1499

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

    
1507
    len1 = len;
1508
    ts->pkt = pkt;
1509
    ts->stop_parse = 0;
1510
    for(;;) {
1511
        if (ts->stop_parse>0)
1512
            break;
1513
        if (len < TS_PACKET_SIZE)
1514
            return -1;
1515
        if (buf[0] != 0x47) {
1516
            buf++;
1517
            len--;
1518
        } else {
1519
            handle_packet(ts, buf);
1520
            buf += TS_PACKET_SIZE;
1521
            len -= TS_PACKET_SIZE;
1522
        }
1523
    }
1524
    return len1 - len;
1525
}
1526

    
1527
void mpegts_parse_close(MpegTSContext *ts)
1528
{
1529
    int i;
1530

    
1531
    for(i=0;i<NB_PID_MAX;i++)
1532
        av_free(ts->pids[i]);
1533
    av_free(ts);
1534
}
1535

    
1536
AVInputFormat mpegts_demuxer = {
1537
    "mpegts",
1538
    NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
1539
    sizeof(MpegTSContext),
1540
    mpegts_probe,
1541
    mpegts_read_header,
1542
    mpegts_read_packet,
1543
    mpegts_read_close,
1544
    read_seek,
1545
    mpegts_get_pcr,
1546
    .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
1547
};
1548

    
1549
AVInputFormat mpegtsraw_demuxer = {
1550
    "mpegtsraw",
1551
    NULL_IF_CONFIG_SMALL("MPEG-2 raw transport stream format"),
1552
    sizeof(MpegTSContext),
1553
    NULL,
1554
    mpegts_read_header,
1555
    mpegts_raw_read_packet,
1556
    mpegts_read_close,
1557
    read_seek,
1558
    mpegts_get_pcr,
1559
    .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
1560
};