remove defines
[ffmpeg.git] / libavformat / mpegts.c
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 static AVStream* new_pes_av_stream(PESContext *pes, uint32_t code, uint32_t prog_reg_desc, uint32_t reg_desc);
45
46 enum MpegTSFilterType {
47     MPEGTS_PES,
48     MPEGTS_SECTION,
49 };
50
51 typedef struct MpegTSFilter MpegTSFilter;
52
53 typedef int PESCallback(MpegTSFilter *f, const uint8_t *buf, int len, int is_start, int64_t pos);
54
55 typedef struct MpegTSPESFilter {
56     PESCallback *pes_cb;
57     void *opaque;
58 } MpegTSPESFilter;
59
60 typedef void SectionCallback(MpegTSFilter *f, const uint8_t *buf, int len);
61
62 typedef void SetServiceCallback(void *opaque, int ret);
63
64 typedef struct MpegTSSectionFilter {
65     int section_index;
66     int section_h_size;
67     uint8_t *section_buf;
68     unsigned int check_crc:1;
69     unsigned int end_of_section_reached:1;
70     SectionCallback *section_cb;
71     void *opaque;
72 } MpegTSSectionFilter;
73
74 struct MpegTSFilter {
75     int pid;
76     int last_cc; /* last cc code (-1 if first packet) */
77     enum MpegTSFilterType type;
78     union {
79         MpegTSPESFilter pes_filter;
80         MpegTSSectionFilter section_filter;
81     } u;
82 };
83
84 #define MAX_PIDS_PER_PROGRAM 64
85 struct Program {
86     unsigned int id; //program id/service id
87     unsigned int nb_pids;
88     unsigned int pids[MAX_PIDS_PER_PROGRAM];
89 };
90
91 struct MpegTSContext {
92     /* user data */
93     AVFormatContext *stream;
94     /** raw packet size, including FEC if present            */
95     int raw_packet_size;
96
97     int pos47;
98
99     /** if true, all pids are analyzed to find streams       */
100     int auto_guess;
101
102     /** compute exact PCR for each transport stream packet   */
103     int mpeg2ts_compute_pcr;
104
105     int64_t cur_pcr;    /**< used to estimate the exact PCR  */
106     int pcr_incr;       /**< used to estimate the exact PCR  */
107
108     /* data needed to handle file based ts */
109     /** stop parsing loop                                    */
110     int stop_parse;
111     /** packet containing Audio/Video data                   */
112     AVPacket *pkt;
113     /** to detect seek                                       */
114     int64_t last_pos;
115
116     /******************************************/
117     /* private mpegts data */
118     /* scan context */
119     /** structure to keep track of Program->pids mapping     */
120     unsigned int nb_prg;
121     struct Program *prg;
122
123
124     /** filters for various streams specified by PMT + for the PAT and PMT */
125     MpegTSFilter *pids[NB_PID_MAX];
126 };
127
128 /* TS stream handling */
129
130 enum MpegTSState {
131     MPEGTS_HEADER = 0,
132     MPEGTS_PESHEADER_FILL,
133     MPEGTS_PAYLOAD,
134     MPEGTS_SKIP,
135 };
136
137 /* enough for PES header + length */
138 #define PES_START_SIZE 9
139 #define MAX_PES_HEADER_SIZE (9 + 255)
140
141 struct PESContext {
142     int pid;
143     int pcr_pid; /**< if -1 then all packets containing PCR are considered */
144     int stream_type;
145     MpegTSContext *ts;
146     AVFormatContext *stream;
147     AVStream *st;
148     enum MpegTSState state;
149     /* used to get the format */
150     int data_index;
151     int total_size;
152     int pes_header_size;
153     int64_t pts, dts;
154     int64_t ts_packet_pos; /**< position of first TS packet of this PES packet */
155     uint8_t header[MAX_PES_HEADER_SIZE];
156     uint8_t *buffer;
157 };
158
159 extern AVInputFormat mpegts_demuxer;
160
161 static void clear_program(MpegTSContext *ts, unsigned int programid)
162 {
163     int i;
164
165     for(i=0; i<ts->nb_prg; i++)
166         if(ts->prg[i].id == programid)
167             ts->prg[i].nb_pids = 0;
168 }
169
170 static void clear_programs(MpegTSContext *ts)
171 {
172     av_freep(&ts->prg);
173     ts->nb_prg=0;
174 }
175
176 static void add_pat_entry(MpegTSContext *ts, unsigned int programid)
177 {
178     struct Program *p;
179     void *tmp = av_realloc(ts->prg, (ts->nb_prg+1)*sizeof(struct Program));
180     if(!tmp)
181         return;
182     ts->prg = tmp;
183     p = &ts->prg[ts->nb_prg];
184     p->id = programid;
185     p->nb_pids = 0;
186     ts->nb_prg++;
187 }
188
189 static void add_pid_to_pmt(MpegTSContext *ts, unsigned int programid, unsigned int pid)
190 {
191     int i;
192     struct Program *p = NULL;
193     for(i=0; i<ts->nb_prg; i++) {
194         if(ts->prg[i].id == programid) {
195             p = &ts->prg[i];
196             break;
197         }
198     }
199     if(!p)
200         return;
201
202     if(p->nb_pids >= MAX_PIDS_PER_PROGRAM)
203         return;
204     p->pids[p->nb_pids++] = pid;
205 }
206
207 /**
208  * \brief discard_pid() decides if the pid is to be discarded according
209  *                      to caller's programs selection
210  * \param ts    : - TS context
211  * \param pid   : - pid
212  * \return 1 if the pid is only comprised in programs that have .discard=AVDISCARD_ALL
213  *         0 otherwise
214  */
215 static int discard_pid(MpegTSContext *ts, unsigned int pid)
216 {
217     int i, j, k;
218     int used = 0, discarded = 0;
219     struct Program *p;
220     for(i=0; i<ts->nb_prg; i++) {
221         p = &ts->prg[i];
222         for(j=0; j<p->nb_pids; j++) {
223             if(p->pids[j] != pid)
224                 continue;
225             //is program with id p->id set to be discarded?
226             for(k=0; k<ts->stream->nb_programs; k++) {
227                 if(ts->stream->programs[k]->id == p->id) {
228                     if(ts->stream->programs[k]->discard == AVDISCARD_ALL)
229                         discarded++;
230                     else
231                         used++;
232                 }
233             }
234         }
235     }
236
237     return !used && discarded;
238 }
239
240 /**
241  *  Assembles PES packets out of TS packets, and then calls the "section_cb"
242  *  function when they are complete.
243  */
244 static void write_section_data(AVFormatContext *s, MpegTSFilter *tss1,
245                                const uint8_t *buf, int buf_size, int is_start)
246 {
247     MpegTSSectionFilter *tss = &tss1->u.section_filter;
248     int len;
249
250     if (is_start) {
251         memcpy(tss->section_buf, buf, buf_size);
252         tss->section_index = buf_size;
253         tss->section_h_size = -1;
254         tss->end_of_section_reached = 0;
255     } else {
256         if (tss->end_of_section_reached)
257             return;
258         len = 4096 - tss->section_index;
259         if (buf_size < len)
260             len = buf_size;
261         memcpy(tss->section_buf + tss->section_index, buf, len);
262         tss->section_index += len;
263     }
264
265     /* compute section length if possible */
266     if (tss->section_h_size == -1 && tss->section_index >= 3) {
267         len = (AV_RB16(tss->section_buf + 1) & 0xfff) + 3;
268         if (len > 4096)
269             return;
270         tss->section_h_size = len;
271     }
272
273     if (tss->section_h_size != -1 && tss->section_index >= tss->section_h_size) {
274         tss->end_of_section_reached = 1;
275         if (!tss->check_crc ||
276             av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1,
277                    tss->section_buf, tss->section_h_size) == 0)
278             tss->section_cb(tss1, tss->section_buf, tss->section_h_size);
279     }
280 }
281
282 static MpegTSFilter *mpegts_open_section_filter(MpegTSContext *ts, unsigned int pid,
283                                          SectionCallback *section_cb, void *opaque,
284                                          int check_crc)
285
286 {
287     MpegTSFilter *filter;
288     MpegTSSectionFilter *sec;
289
290     dprintf(ts->stream, "Filter: pid=0x%x\n", pid);
291
292     if (pid >= NB_PID_MAX || ts->pids[pid])
293         return NULL;
294     filter = av_mallocz(sizeof(MpegTSFilter));
295     if (!filter)
296         return NULL;
297     ts->pids[pid] = filter;
298     filter->type = MPEGTS_SECTION;
299     filter->pid = pid;
300     filter->last_cc = -1;
301     sec = &filter->u.section_filter;
302     sec->section_cb = section_cb;
303     sec->opaque = opaque;
304     sec->section_buf = av_malloc(MAX_SECTION_SIZE);
305     sec->check_crc = check_crc;
306     if (!sec->section_buf) {
307         av_free(filter);
308         return NULL;
309     }
310     return filter;
311 }
312
313 static MpegTSFilter *mpegts_open_pes_filter(MpegTSContext *ts, unsigned int pid,
314                                      PESCallback *pes_cb,
315                                      void *opaque)
316 {
317     MpegTSFilter *filter;
318     MpegTSPESFilter *pes;
319
320     if (pid >= NB_PID_MAX || ts->pids[pid])
321         return NULL;
322     filter = av_mallocz(sizeof(MpegTSFilter));
323     if (!filter)
324         return NULL;
325     ts->pids[pid] = filter;
326     filter->type = MPEGTS_PES;
327     filter->pid = pid;
328     filter->last_cc = -1;
329     pes = &filter->u.pes_filter;
330     pes->pes_cb = pes_cb;
331     pes->opaque = opaque;
332     return filter;
333 }
334
335 static void mpegts_close_filter(MpegTSContext *ts, MpegTSFilter *filter)
336 {
337     int pid;
338
339     pid = filter->pid;
340     if (filter->type == MPEGTS_SECTION)
341         av_freep(&filter->u.section_filter.section_buf);
342     else if (filter->type == MPEGTS_PES) {
343         PESContext *pes = filter->u.pes_filter.opaque;
344         av_freep(&pes->buffer);
345         /* referenced private data will be freed later in
346          * av_close_input_stream */
347         if (!((PESContext *)filter->u.pes_filter.opaque)->st) {
348             av_freep(&filter->u.pes_filter.opaque);
349         }
350     }
351
352     av_free(filter);
353     ts->pids[pid] = NULL;
354 }
355
356 static int analyze(const uint8_t *buf, int size, int packet_size, int *index){
357     int stat[packet_size];
358     int i;
359     int x=0;
360     int best_score=0;
361
362     memset(stat, 0, packet_size*sizeof(int));
363
364     for(x=i=0; i<size-3; i++){
365         if(buf[i] == 0x47 && !(buf[i+1] & 0x80) && (buf[i+3] & 0x30)){
366             stat[x]++;
367             if(stat[x] > best_score){
368                 best_score= stat[x];
369                 if(index) *index= x;
370             }
371         }
372
373         x++;
374         if(x == packet_size) x= 0;
375     }
376
377     return best_score;
378 }
379
380 /* autodetect fec presence. Must have at least 1024 bytes  */
381 static int get_packet_size(const uint8_t *buf, int size)
382 {
383     int score, fec_score, dvhs_score;
384
385     if (size < (TS_FEC_PACKET_SIZE * 5 + 1))
386         return -1;
387
388     score    = analyze(buf, size, TS_PACKET_SIZE, NULL);
389     dvhs_score    = analyze(buf, size, TS_DVHS_PACKET_SIZE, NULL);
390     fec_score= analyze(buf, size, TS_FEC_PACKET_SIZE, NULL);
391 //    av_log(NULL, AV_LOG_DEBUG, "score: %d, dvhs_score: %d, fec_score: %d \n", score, dvhs_score, fec_score);
392
393     if     (score > fec_score && score > dvhs_score) return TS_PACKET_SIZE;
394     else if(dvhs_score > score && dvhs_score > fec_score) return TS_DVHS_PACKET_SIZE;
395     else if(score < fec_score && dvhs_score < fec_score) return TS_FEC_PACKET_SIZE;
396     else                       return -1;
397 }
398
399 typedef struct SectionHeader {
400     uint8_t tid;
401     uint16_t id;
402     uint8_t version;
403     uint8_t sec_num;
404     uint8_t last_sec_num;
405 } SectionHeader;
406
407 static inline int get8(const uint8_t **pp, const uint8_t *p_end)
408 {
409     const uint8_t *p;
410     int c;
411
412     p = *pp;
413     if (p >= p_end)
414         return -1;
415     c = *p++;
416     *pp = p;
417     return c;
418 }
419
420 static inline int get16(const uint8_t **pp, const uint8_t *p_end)
421 {
422     const uint8_t *p;
423     int c;
424
425     p = *pp;
426     if ((p + 1) >= p_end)
427         return -1;
428     c = AV_RB16(p);
429     p += 2;
430     *pp = p;
431     return c;
432 }
433
434 /* read and allocate a DVB string preceeded by its length */
435 static char *getstr8(const uint8_t **pp, const uint8_t *p_end)
436 {
437     int len;
438     const uint8_t *p;
439     char *str;
440
441     p = *pp;
442     len = get8(&p, p_end);
443     if (len < 0)
444         return NULL;
445     if ((p + len) > p_end)
446         return NULL;
447     str = av_malloc(len + 1);
448     if (!str)
449         return NULL;
450     memcpy(str, p, len);
451     str[len] = '\0';
452     p += len;
453     *pp = p;
454     return str;
455 }
456
457 static int parse_section_header(SectionHeader *h,
458                                 const uint8_t **pp, const uint8_t *p_end)
459 {
460     int val;
461
462     val = get8(pp, p_end);
463     if (val < 0)
464         return -1;
465     h->tid = val;
466     *pp += 2;
467     val = get16(pp, p_end);
468     if (val < 0)
469         return -1;
470     h->id = val;
471     val = get8(pp, p_end);
472     if (val < 0)
473         return -1;
474     h->version = (val >> 1) & 0x1f;
475     val = get8(pp, p_end);
476     if (val < 0)
477         return -1;
478     h->sec_num = val;
479     val = get8(pp, p_end);
480     if (val < 0)
481         return -1;
482     h->last_sec_num = val;
483     return 0;
484 }
485
486
487 static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
488 {
489     MpegTSContext *ts = filter->u.section_filter.opaque;
490     SectionHeader h1, *h = &h1;
491     PESContext *pes;
492     AVStream *st;
493     const uint8_t *p, *p_end, *desc_list_end, *desc_end;
494     int program_info_length, pcr_pid, pid, stream_type;
495     int desc_list_len, desc_len, desc_tag;
496     int comp_page = 0, anc_page = 0; /* initialize to kill warnings */
497     char language[4] = {0}; /* initialize to kill warnings */
498     uint32_t prog_reg_desc = 0; /* registration descriptor */
499     uint32_t reg_desc = 0; /* registration descriptor */
500
501 #ifdef DEBUG
502     dprintf(ts->stream, "PMT: len %i\n", section_len);
503     av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
504 #endif
505
506     p_end = section + section_len - 4;
507     p = section;
508     if (parse_section_header(h, &p, p_end) < 0)
509         return;
510
511     dprintf(ts->stream, "sid=0x%x sec_num=%d/%d\n",
512            h->id, h->sec_num, h->last_sec_num);
513
514     if (h->tid != PMT_TID)
515         return;
516
517     clear_program(ts, h->id);
518     pcr_pid = get16(&p, p_end) & 0x1fff;
519     if (pcr_pid < 0)
520         return;
521     add_pid_to_pmt(ts, h->id, pcr_pid);
522
523     dprintf(ts->stream, "pcr_pid=0x%x\n", pcr_pid);
524
525     program_info_length = get16(&p, p_end) & 0xfff;
526     if (program_info_length < 0)
527         return;
528     while(program_info_length >= 2) {
529         uint8_t tag, len;
530         tag = get8(&p, p_end);
531         len = get8(&p, p_end);
532         if(len > program_info_length - 2)
533             //something else is broken, exit the program_descriptors_loop
534             break;
535         program_info_length -= len + 2;
536         if(tag == 0x05 && len >= 4) { // registration descriptor
537             prog_reg_desc = bytestream_get_le32(&p);
538             len -= 4;
539         }
540         p += len;
541     }
542     p += program_info_length;
543     if (p >= p_end)
544         return;
545     for(;;) {
546         reg_desc = 0;
547         language[0] = 0;
548         st = 0;
549         stream_type = get8(&p, p_end);
550         if (stream_type < 0)
551             break;
552         pid = get16(&p, p_end) & 0x1fff;
553         if (pid < 0)
554             break;
555         desc_list_len = get16(&p, p_end) & 0xfff;
556         if (desc_list_len < 0)
557             break;
558         desc_list_end = p + desc_list_len;
559         if (desc_list_end > p_end)
560             break;
561         for(;;) {
562             desc_tag = get8(&p, desc_list_end);
563             if (desc_tag < 0)
564                 break;
565             if (stream_type == STREAM_TYPE_PRIVATE_DATA) {
566                 if((desc_tag == 0x6A) || (desc_tag == 0x7A)) {
567                     /*assume DVB AC-3 Audio*/
568                     stream_type = STREAM_TYPE_AUDIO_AC3;
569                 } else if(desc_tag == 0x7B) {
570                     /* DVB DTS audio */
571                     stream_type = STREAM_TYPE_AUDIO_DTS;
572                 }
573             }
574             desc_len = get8(&p, desc_list_end);
575             if (desc_len < 0)
576                 break;
577             desc_end = p + desc_len;
578             if (desc_end > desc_list_end)
579                 break;
580
581             dprintf(ts->stream, "tag: 0x%02x len=%d\n",
582                    desc_tag, desc_len);
583
584             switch(desc_tag) {
585             case 0x59: /* subtitling descriptor */
586                 if (stream_type == STREAM_TYPE_PRIVATE_DATA)
587                     stream_type = 0x100; // demuxer internal
588
589                 language[0] = get8(&p, desc_end);
590                 language[1] = get8(&p, desc_end);
591                 language[2] = get8(&p, desc_end);
592                 language[3] = 0;
593                 get8(&p, desc_end);
594                 comp_page = get16(&p, desc_end);
595                 anc_page = get16(&p, desc_end);
596
597                 break;
598             case 0x0a: /* ISO 639 language descriptor */
599                 language[0] = get8(&p, desc_end);
600                 language[1] = get8(&p, desc_end);
601                 language[2] = get8(&p, desc_end);
602                 language[3] = 0;
603                 break;
604             case 0x05: /* registration descriptor */
605                 reg_desc = bytestream_get_le32(&p);
606                 break;
607             default:
608                 break;
609             }
610             p = desc_end;
611         }
612         p = desc_list_end;
613
614         dprintf(ts->stream, "stream_type=%x pid=0x%x\n",
615                stream_type, pid);
616
617         /* now create ffmpeg stream */
618         if (ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES) {
619             pes= ts->pids[pid]->u.pes_filter.opaque;
620             st= pes->st;
621         } else {
622             if (ts->pids[pid]) mpegts_close_filter(ts, ts->pids[pid]); //wrongly added sdt filter probably
623             pes = add_pes_stream(ts, pid, pcr_pid, stream_type);
624             if (pes)
625                 st = new_pes_av_stream(pes, 0, prog_reg_desc, reg_desc);
626         }
627
628         add_pid_to_pmt(ts, h->id, pid);
629
630         if(st) {
631             av_program_add_stream_index(ts->stream, h->id, st->index);
632
633             if (language[0] != 0)
634                 av_metadata_set(&st->metadata, "language", language);
635
636             if (stream_type == 0x100)
637                 st->codec->sub_id = (anc_page << 16) | comp_page;
638         }
639     }
640     /* all parameters are there */
641     ts->stop_parse++;
642     mpegts_close_filter(ts, filter);
643 }
644
645 static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
646 {
647     MpegTSContext *ts = filter->u.section_filter.opaque;
648     SectionHeader h1, *h = &h1;
649     const uint8_t *p, *p_end;
650     int sid, pmt_pid;
651
652 #ifdef DEBUG
653     dprintf(ts->stream, "PAT:\n");
654     av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
655 #endif
656     p_end = section + section_len - 4;
657     p = section;
658     if (parse_section_header(h, &p, p_end) < 0)
659         return;
660     if (h->tid != PAT_TID)
661         return;
662
663     clear_programs(ts);
664     for(;;) {
665         sid = get16(&p, p_end);
666         if (sid < 0)
667             break;
668         pmt_pid = get16(&p, p_end) & 0x1fff;
669         if (pmt_pid < 0)
670             break;
671
672         dprintf(ts->stream, "sid=0x%x pid=0x%x\n", sid, pmt_pid);
673
674         if (sid == 0x0000) {
675             /* NIT info */
676         } else {
677             av_new_program(ts->stream, sid);
678             ts->stop_parse--;
679             mpegts_open_section_filter(ts, pmt_pid, pmt_cb, ts, 1);
680             add_pat_entry(ts, sid);
681             add_pid_to_pmt(ts, sid, 0); //add pat pid to program
682             add_pid_to_pmt(ts, sid, pmt_pid);
683         }
684     }
685     /* not found */
686     ts->stop_parse++;
687
688     mpegts_close_filter(ts, filter);
689 }
690
691 static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
692 {
693     MpegTSContext *ts = filter->u.section_filter.opaque;
694     SectionHeader h1, *h = &h1;
695     const uint8_t *p, *p_end, *desc_list_end, *desc_end;
696     int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type;
697     char *name, *provider_name;
698
699 #ifdef DEBUG
700     dprintf(ts->stream, "SDT:\n");
701     av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
702 #endif
703
704     p_end = section + section_len - 4;
705     p = section;
706     if (parse_section_header(h, &p, p_end) < 0)
707         return;
708     if (h->tid != SDT_TID)
709         return;
710     onid = get16(&p, p_end);
711     if (onid < 0)
712         return;
713     val = get8(&p, p_end);
714     if (val < 0)
715         return;
716     for(;;) {
717         sid = get16(&p, p_end);
718         if (sid < 0)
719             break;
720         val = get8(&p, p_end);
721         if (val < 0)
722             break;
723         desc_list_len = get16(&p, p_end) & 0xfff;
724         if (desc_list_len < 0)
725             break;
726         desc_list_end = p + desc_list_len;
727         if (desc_list_end > p_end)
728             break;
729         for(;;) {
730             desc_tag = get8(&p, desc_list_end);
731             if (desc_tag < 0)
732                 break;
733             desc_len = get8(&p, desc_list_end);
734             desc_end = p + desc_len;
735             if (desc_end > desc_list_end)
736                 break;
737
738             dprintf(ts->stream, "tag: 0x%02x len=%d\n",
739                    desc_tag, desc_len);
740
741             switch(desc_tag) {
742             case 0x48:
743                 service_type = get8(&p, p_end);
744                 if (service_type < 0)
745                     break;
746                 provider_name = getstr8(&p, p_end);
747                 if (!provider_name)
748                     break;
749                 name = getstr8(&p, p_end);
750                 if (name) {
751                     AVProgram *program = av_new_program(ts->stream, sid);
752                     if(program) {
753                         av_metadata_set(&program->metadata, "name", name);
754                         av_metadata_set(&program->metadata, "provider_name", provider_name);
755                     }
756                 }
757                 av_free(name);
758                 av_free(provider_name);
759                 break;
760             default:
761                 break;
762             }
763             p = desc_end;
764         }
765         p = desc_list_end;
766     }
767 }
768
769 static int64_t get_pts(const uint8_t *p)
770 {
771     int64_t pts = (int64_t)((p[0] >> 1) & 0x07) << 30;
772     pts |= (AV_RB16(p + 1) >> 1) << 15;
773     pts |=  AV_RB16(p + 3) >> 1;
774     return pts;
775 }
776
777 static void new_pes_packet(PESContext *pes, AVPacket *pkt)
778 {
779     av_init_packet(pkt);
780
781     pkt->destruct = av_destruct_packet;
782     pkt->data = pes->buffer;
783     pkt->size = pes->data_index;
784     memset(pkt->data+pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
785
786     pkt->stream_index = pes->st->index;
787     pkt->pts = pes->pts;
788     pkt->dts = pes->dts;
789     /* store position of first TS packet of this PES packet */
790     pkt->pos = pes->ts_packet_pos;
791
792     /* reset pts values */
793     pes->pts = AV_NOPTS_VALUE;
794     pes->dts = AV_NOPTS_VALUE;
795     pes->buffer = NULL;
796     pes->data_index = 0;
797 }
798
799 /* return non zero if a packet could be constructed */
800 static int mpegts_push_data(MpegTSFilter *filter,
801                             const uint8_t *buf, int buf_size, int is_start,
802                             int64_t pos)
803 {
804     PESContext *pes = filter->u.pes_filter.opaque;
805     MpegTSContext *ts = pes->ts;
806     const uint8_t *p;
807     int len, code;
808
809     if(!ts->pkt)
810         return 0;
811
812     if (is_start) {
813         if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
814             new_pes_packet(pes, ts->pkt);
815             ts->stop_parse = 1;
816         }
817         pes->state = MPEGTS_HEADER;
818         pes->data_index = 0;
819         pes->ts_packet_pos = pos;
820     }
821     p = buf;
822     while (buf_size > 0) {
823         switch(pes->state) {
824         case MPEGTS_HEADER:
825             len = PES_START_SIZE - pes->data_index;
826             if (len > buf_size)
827                 len = buf_size;
828             memcpy(pes->header + pes->data_index, p, len);
829             pes->data_index += len;
830             p += len;
831             buf_size -= len;
832             if (pes->data_index == PES_START_SIZE) {
833                 /* we got all the PES or section header. We can now
834                    decide */
835 #if 0
836                 av_hex_dump_log(pes->stream, AV_LOG_DEBUG, pes->header, pes->data_index);
837 #endif
838                 if (pes->header[0] == 0x00 && pes->header[1] == 0x00 &&
839                     pes->header[2] == 0x01) {
840                     /* it must be an mpeg2 PES stream */
841                     code = pes->header[3] | 0x100;
842                     if (!pes->st || pes->st->discard == AVDISCARD_ALL ||
843                         !((code >= 0x1c0 && code <= 0x1df) ||
844                           (code >= 0x1e0 && code <= 0x1ef) ||
845                           (code == 0x1bd) || (code == 0x1fd)))
846                         goto skip;
847                     pes->state = MPEGTS_PESHEADER_FILL;
848                     pes->total_size = AV_RB16(pes->header + 4);
849                     /* NOTE: a zero total size means the PES size is
850                        unbounded */
851                     pes->pes_header_size = pes->header[8] + 9;
852                 } else {
853                     /* otherwise, it should be a table */
854                     /* skip packet */
855                 skip:
856                     pes->state = MPEGTS_SKIP;
857                     continue;
858                 }
859             }
860             break;
861             /**********************************************/
862             /* PES packing parsing */
863         case MPEGTS_PESHEADER_FILL:
864             len = pes->pes_header_size - pes->data_index;
865             if (len < 0)
866                 return -1;
867             if (len > buf_size)
868                 len = buf_size;
869             memcpy(pes->header + pes->data_index, p, len);
870             pes->data_index += len;
871             p += len;
872             buf_size -= len;
873             if (pes->data_index == pes->pes_header_size) {
874                 const uint8_t *r;
875                 unsigned int flags;
876
877                 flags = pes->header[7];
878                 r = pes->header + 9;
879                 pes->pts = AV_NOPTS_VALUE;
880                 pes->dts = AV_NOPTS_VALUE;
881                 if ((flags & 0xc0) == 0x80) {
882                     pes->dts = pes->pts = get_pts(r);
883                     r += 5;
884                 } else if ((flags & 0xc0) == 0xc0) {
885                     pes->pts = get_pts(r);
886                     r += 5;
887                     pes->dts = get_pts(r);
888                     r += 5;
889                 }
890
891                 if (pes->total_size > pes->data_index - 6)
892                     pes->total_size -= pes->data_index - 6;
893                 else
894                     pes->total_size = MAX_PES_PAYLOAD;
895                 /* allocate pes buffer */
896                 pes->buffer = av_malloc(pes->total_size+FF_INPUT_BUFFER_PADDING_SIZE);
897                 if (!pes->buffer)
898                     return AVERROR(ENOMEM);
899
900                 /* we got the full header. We parse it and get the payload */
901                 pes->state = MPEGTS_PAYLOAD;
902                 pes->data_index = 0;
903             }
904             break;
905         case MPEGTS_PAYLOAD:
906             if (buf_size > 0) {
907                 if (pes->data_index+buf_size > pes->total_size) {
908                     new_pes_packet(pes, ts->pkt);
909                     pes->total_size = MAX_PES_PAYLOAD;
910                     pes->buffer = av_malloc(pes->total_size+FF_INPUT_BUFFER_PADDING_SIZE);
911                     if (!pes->buffer)
912                         return AVERROR(ENOMEM);
913                     ts->stop_parse = 1;
914                 }
915                 memcpy(pes->buffer+pes->data_index, p, buf_size);
916                 pes->data_index += buf_size;
917             }
918             buf_size = 0;
919             break;
920         case MPEGTS_SKIP:
921             buf_size = 0;
922             break;
923         }
924     }
925
926     return 0;
927 }
928
929 typedef struct {
930     uint32_t stream_type;
931     enum CodecType codec_type;
932     enum CodecID codec_id;
933 } StreamType;
934
935 static const StreamType ISO_types[] = {
936     { 0x01, CODEC_TYPE_VIDEO, CODEC_ID_MPEG2VIDEO },
937     { 0x02, CODEC_TYPE_VIDEO, CODEC_ID_MPEG2VIDEO },
938     { 0x03, CODEC_TYPE_AUDIO,        CODEC_ID_MP3 },
939     { 0x04, CODEC_TYPE_AUDIO,        CODEC_ID_MP3 },
940     { 0x0f, CODEC_TYPE_AUDIO,        CODEC_ID_AAC },
941     { 0x10, CODEC_TYPE_VIDEO,      CODEC_ID_MPEG4 },
942     { 0x1b, CODEC_TYPE_VIDEO,       CODEC_ID_H264 },
943     { 0xd1, CODEC_TYPE_VIDEO,      CODEC_ID_DIRAC },
944     { 0xea, CODEC_TYPE_VIDEO,        CODEC_ID_VC1 },
945     { 0 },
946 };
947
948 static const StreamType HDMV_types[] = {
949     { 0x81, CODEC_TYPE_AUDIO, CODEC_ID_AC3 },
950     { 0x82, CODEC_TYPE_AUDIO, CODEC_ID_DTS },
951     { 0 },
952 };
953
954 /* ATSC ? */
955 static const StreamType MISC_types[] = {
956     { 0x81, CODEC_TYPE_AUDIO,   CODEC_ID_AC3 },
957     { 0x8a, CODEC_TYPE_AUDIO,   CODEC_ID_DTS },
958     {0x100, CODEC_TYPE_SUBTITLE, CODEC_ID_DVB_SUBTITLE }, // demuxer internal
959     { 0 },
960 };
961
962 static const StreamType REGD_types[] = {
963     { MKTAG('d','r','a','c'), CODEC_TYPE_VIDEO, CODEC_ID_DIRAC },
964     { MKTAG('A','C','-','3'), CODEC_TYPE_AUDIO,   CODEC_ID_AC3 },
965     { 0 },
966 };
967
968 static void mpegts_find_stream_type(AVStream *st,
969                                     uint32_t stream_type, const StreamType *types)
970 {
971     for (; types->stream_type; types++) {
972         if (stream_type == types->stream_type) {
973             st->codec->codec_type = types->codec_type;
974             st->codec->codec_id   = types->codec_id;
975             return;
976         }
977     }
978 }
979
980 static AVStream *new_pes_av_stream(PESContext *pes, uint32_t code,
981                                    uint32_t prog_reg_desc, uint32_t reg_desc)
982 {
983     AVStream *st = av_new_stream(pes->stream, pes->pid);
984
985     if (!st)
986         return NULL;
987
988     av_set_pts_info(st, 33, 1, 90000);
989     st->priv_data = pes;
990     st->codec->codec_type = CODEC_TYPE_DATA;
991     st->codec->codec_id   = CODEC_ID_PROBE;
992     st->need_parsing = AVSTREAM_PARSE_FULL;
993     pes->st = st;
994
995     dprintf(pes->stream, "stream_type=%x prog_reg_desc=%.4s reg_desc=%.4s\n",
996             pes->stream_type, (char*)&prog_reg_desc, (char*)&reg_desc);
997
998     if (pes->stream_type == 0x06) { // private data carrying pes data
999         mpegts_find_stream_type(st, reg_desc, REGD_types);
1000     } else {
1001         mpegts_find_stream_type(st, pes->stream_type, ISO_types);
1002         if (prog_reg_desc == AV_RL32("HDMV") &&
1003             st->codec->codec_id == CODEC_ID_PROBE)
1004             mpegts_find_stream_type(st, pes->stream_type, HDMV_types);
1005         if (st->codec->codec_id == CODEC_ID_PROBE)
1006             mpegts_find_stream_type(st, pes->stream_type, MISC_types);
1007     }
1008
1009     return st;
1010 }
1011
1012
1013 static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid, int stream_type)
1014 {
1015     MpegTSFilter *tss;
1016     PESContext *pes;
1017
1018     /* if no pid found, then add a pid context */
1019     pes = av_mallocz(sizeof(PESContext));
1020     if (!pes)
1021         return 0;
1022     pes->ts = ts;
1023     pes->stream = ts->stream;
1024     pes->pid = pid;
1025     pes->pcr_pid = pcr_pid;
1026     pes->stream_type = stream_type;
1027     tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes);
1028     if (!tss) {
1029         av_free(pes);
1030         return 0;
1031     }
1032     return pes;
1033 }
1034
1035 /* handle one TS packet */
1036 static int handle_packet(MpegTSContext *ts, const uint8_t *packet)
1037 {
1038     AVFormatContext *s = ts->stream;
1039     MpegTSFilter *tss;
1040     int len, pid, cc, cc_ok, afc, is_start;
1041     const uint8_t *p, *p_end;
1042     int64_t pos;
1043
1044     pid = AV_RB16(packet + 1) & 0x1fff;
1045     if(pid && discard_pid(ts, pid))
1046         return 0;
1047     is_start = packet[1] & 0x40;
1048     tss = ts->pids[pid];
1049     if (ts->auto_guess && tss == NULL && is_start) {
1050         add_pes_stream(ts, pid, -1, 0);
1051         tss = ts->pids[pid];
1052     }
1053     if (!tss)
1054         return 0;
1055
1056     /* continuity check (currently not used) */
1057     cc = (packet[3] & 0xf);
1058     cc_ok = (tss->last_cc < 0) || ((((tss->last_cc + 1) & 0x0f) == cc));
1059     tss->last_cc = cc;
1060
1061     /* skip adaptation field */
1062     afc = (packet[3] >> 4) & 3;
1063     p = packet + 4;
1064     if (afc == 0) /* reserved value */
1065         return 0;
1066     if (afc == 2) /* adaptation field only */
1067         return 0;
1068     if (afc == 3) {
1069         /* skip adapation field */
1070         p += p[0] + 1;
1071     }
1072     /* if past the end of packet, ignore */
1073     p_end = packet + TS_PACKET_SIZE;
1074     if (p >= p_end)
1075         return 0;
1076
1077     pos = url_ftell(ts->stream->pb);
1078     ts->pos47= pos % ts->raw_packet_size;
1079
1080     if (tss->type == MPEGTS_SECTION) {
1081         if (is_start) {
1082             /* pointer field present */
1083             len = *p++;
1084             if (p + len > p_end)
1085                 return 0;
1086             if (len && cc_ok) {
1087                 /* write remaining section bytes */
1088                 write_section_data(s, tss,
1089                                    p, len, 0);
1090                 /* check whether filter has been closed */
1091                 if (!ts->pids[pid])
1092                     return 0;
1093             }
1094             p += len;
1095             if (p < p_end) {
1096                 write_section_data(s, tss,
1097                                    p, p_end - p, 1);
1098             }
1099         } else {
1100             if (cc_ok) {
1101                 write_section_data(s, tss,
1102                                    p, p_end - p, 0);
1103             }
1104         }
1105     } else {
1106         int ret;
1107         // Note: The position here points actually behind the current packet.
1108         if ((ret = tss->u.pes_filter.pes_cb(tss, p, p_end - p, is_start,
1109                                             pos - ts->raw_packet_size)) < 0)
1110             return ret;
1111     }
1112
1113     return 0;
1114 }
1115
1116 /* XXX: try to find a better synchro over several packets (use
1117    get_packet_size() ?) */
1118 static int mpegts_resync(ByteIOContext *pb)
1119 {
1120     int c, i;
1121
1122     for(i = 0;i < MAX_RESYNC_SIZE; i++) {
1123         c = url_fgetc(pb);
1124         if (c < 0)
1125             return -1;
1126         if (c == 0x47) {
1127             url_fseek(pb, -1, SEEK_CUR);
1128             return 0;
1129         }
1130     }
1131     /* no sync found */
1132     return -1;
1133 }
1134
1135 /* return -1 if error or EOF. Return 0 if OK. */
1136 static int read_packet(ByteIOContext *pb, uint8_t *buf, int raw_packet_size)
1137 {
1138     int skip, len;
1139
1140     for(;;) {
1141         len = get_buffer(pb, buf, TS_PACKET_SIZE);
1142         if (len != TS_PACKET_SIZE)
1143             return AVERROR(EIO);
1144         /* check paquet sync byte */
1145         if (buf[0] != 0x47) {
1146             /* find a new packet start */
1147             url_fseek(pb, -TS_PACKET_SIZE, SEEK_CUR);
1148             if (mpegts_resync(pb) < 0)
1149                 return AVERROR_INVALIDDATA;
1150             else
1151                 continue;
1152         } else {
1153             skip = raw_packet_size - TS_PACKET_SIZE;
1154             if (skip > 0)
1155                 url_fskip(pb, skip);
1156             break;
1157         }
1158     }
1159     return 0;
1160 }
1161
1162 static int handle_packets(MpegTSContext *ts, int nb_packets)
1163 {
1164     AVFormatContext *s = ts->stream;
1165     ByteIOContext *pb = s->pb;
1166     uint8_t packet[TS_PACKET_SIZE];
1167     int packet_num, ret;
1168
1169     ts->stop_parse = 0;
1170     packet_num = 0;
1171     for(;;) {
1172         if (ts->stop_parse>0)
1173             break;
1174         packet_num++;
1175         if (nb_packets != 0 && packet_num >= nb_packets)
1176             break;
1177         ret = read_packet(pb, packet, ts->raw_packet_size);
1178         if (ret != 0)
1179             return ret;
1180         ret = handle_packet(ts, packet);
1181         if (ret != 0)
1182             return ret;
1183     }
1184     return 0;
1185 }
1186
1187 static int mpegts_probe(AVProbeData *p)
1188 {
1189 #if 1
1190     const int size= p->buf_size;
1191     int score, fec_score, dvhs_score;
1192     int check_count= size / TS_FEC_PACKET_SIZE;
1193 #define CHECK_COUNT 10
1194
1195     if (check_count < CHECK_COUNT)
1196         return -1;
1197
1198     score     = analyze(p->buf, TS_PACKET_SIZE     *check_count, TS_PACKET_SIZE     , NULL)*CHECK_COUNT/check_count;
1199     dvhs_score= analyze(p->buf, TS_DVHS_PACKET_SIZE*check_count, TS_DVHS_PACKET_SIZE, NULL)*CHECK_COUNT/check_count;
1200     fec_score = analyze(p->buf, TS_FEC_PACKET_SIZE *check_count, TS_FEC_PACKET_SIZE , NULL)*CHECK_COUNT/check_count;
1201 //    av_log(NULL, AV_LOG_DEBUG, "score: %d, dvhs_score: %d, fec_score: %d \n", score, dvhs_score, fec_score);
1202
1203 // we need a clear definition for the returned score otherwise things will become messy sooner or later
1204     if     (score > fec_score && score > dvhs_score && score > 6) return AVPROBE_SCORE_MAX + score     - CHECK_COUNT;
1205     else if(dvhs_score > score && dvhs_score > fec_score && dvhs_score > 6) return AVPROBE_SCORE_MAX + dvhs_score  - CHECK_COUNT;
1206     else if(                 fec_score > 6) return AVPROBE_SCORE_MAX + fec_score - CHECK_COUNT;
1207     else                                    return -1;
1208 #else
1209     /* only use the extension for safer guess */
1210     if (match_ext(p->filename, "ts"))
1211         return AVPROBE_SCORE_MAX;
1212     else
1213         return 0;
1214 #endif
1215 }
1216
1217 /* return the 90kHz PCR and the extension for the 27MHz PCR. return
1218    (-1) if not available */
1219 static int parse_pcr(int64_t *ppcr_high, int *ppcr_low,
1220                      const uint8_t *packet)
1221 {
1222     int afc, len, flags;
1223     const uint8_t *p;
1224     unsigned int v;
1225
1226     afc = (packet[3] >> 4) & 3;
1227     if (afc <= 1)
1228         return -1;
1229     p = packet + 4;
1230     len = p[0];
1231     p++;
1232     if (len == 0)
1233         return -1;
1234     flags = *p++;
1235     len--;
1236     if (!(flags & 0x10))
1237         return -1;
1238     if (len < 6)
1239         return -1;
1240     v = AV_RB32(p);
1241     *ppcr_high = ((int64_t)v << 1) | (p[4] >> 7);
1242     *ppcr_low = ((p[4] & 1) << 8) | p[5];
1243     return 0;
1244 }
1245
1246 static int mpegts_read_header(AVFormatContext *s,
1247                               AVFormatParameters *ap)
1248 {
1249     MpegTSContext *ts = s->priv_data;
1250     ByteIOContext *pb = s->pb;
1251     uint8_t buf[5*1024];
1252     int len;
1253     int64_t pos;
1254
1255     if (ap) {
1256         ts->mpeg2ts_compute_pcr = ap->mpeg2ts_compute_pcr;
1257         if(ap->mpeg2ts_raw){
1258             av_log(s, AV_LOG_ERROR, "use mpegtsraw_demuxer!\n");
1259             return -1;
1260         }
1261     }
1262
1263     /* read the first 1024 bytes to get packet size */
1264     pos = url_ftell(pb);
1265     len = get_buffer(pb, buf, sizeof(buf));
1266     if (len != sizeof(buf))
1267         goto fail;
1268     ts->raw_packet_size = get_packet_size(buf, sizeof(buf));
1269     if (ts->raw_packet_size <= 0)
1270         goto fail;
1271     ts->stream = s;
1272     ts->auto_guess = 0;
1273
1274     if (s->iformat == &mpegts_demuxer) {
1275         /* normal demux */
1276
1277         /* first do a scaning to get all the services */
1278         url_fseek(pb, pos, SEEK_SET);
1279
1280         mpegts_open_section_filter(ts, SDT_PID, sdt_cb, ts, 1);
1281
1282         mpegts_open_section_filter(ts, PAT_PID, pat_cb, ts, 1);
1283
1284         handle_packets(ts, s->probesize);
1285         /* if could not find service, enable auto_guess */
1286
1287         ts->auto_guess = 1;
1288
1289         dprintf(ts->stream, "tuning done\n");
1290
1291         s->ctx_flags |= AVFMTCTX_NOHEADER;
1292     } else {
1293         AVStream *st;
1294         int pcr_pid, pid, nb_packets, nb_pcrs, ret, pcr_l;
1295         int64_t pcrs[2], pcr_h;
1296         int packet_count[2];
1297         uint8_t packet[TS_PACKET_SIZE];
1298
1299         /* only read packets */
1300
1301         st = av_new_stream(s, 0);
1302         if (!st)
1303             goto fail;
1304         av_set_pts_info(st, 60, 1, 27000000);
1305         st->codec->codec_type = CODEC_TYPE_DATA;
1306         st->codec->codec_id = CODEC_ID_MPEG2TS;
1307
1308         /* we iterate until we find two PCRs to estimate the bitrate */
1309         pcr_pid = -1;
1310         nb_pcrs = 0;
1311         nb_packets = 0;
1312         for(;;) {
1313             ret = read_packet(s->pb, packet, ts->raw_packet_size);
1314             if (ret < 0)
1315                 return -1;
1316             pid = AV_RB16(packet + 1) & 0x1fff;
1317             if ((pcr_pid == -1 || pcr_pid == pid) &&
1318                 parse_pcr(&pcr_h, &pcr_l, packet) == 0) {
1319                 pcr_pid = pid;
1320                 packet_count[nb_pcrs] = nb_packets;
1321                 pcrs[nb_pcrs] = pcr_h * 300 + pcr_l;
1322                 nb_pcrs++;
1323                 if (nb_pcrs >= 2)
1324                     break;
1325             }
1326             nb_packets++;
1327         }
1328
1329         /* NOTE1: the bitrate is computed without the FEC */
1330         /* NOTE2: it is only the bitrate of the start of the stream */
1331         ts->pcr_incr = (pcrs[1] - pcrs[0]) / (packet_count[1] - packet_count[0]);
1332         ts->cur_pcr = pcrs[0] - ts->pcr_incr * packet_count[0];
1333         s->bit_rate = (TS_PACKET_SIZE * 8) * 27e6 / ts->pcr_incr;
1334         st->codec->bit_rate = s->bit_rate;
1335         st->start_time = ts->cur_pcr;
1336 #if 0
1337         av_log(ts->stream, AV_LOG_DEBUG, "start=%0.3f pcr=%0.3f incr=%d\n",
1338                st->start_time / 1000000.0, pcrs[0] / 27e6, ts->pcr_incr);
1339 #endif
1340     }
1341
1342     url_fseek(pb, pos, SEEK_SET);
1343     return 0;
1344  fail:
1345     return -1;
1346 }
1347
1348 #define MAX_PACKET_READAHEAD ((128 * 1024) / 188)
1349
1350 static int mpegts_raw_read_packet(AVFormatContext *s,
1351                                   AVPacket *pkt)
1352 {
1353     MpegTSContext *ts = s->priv_data;
1354     int ret, i;
1355     int64_t pcr_h, next_pcr_h, pos;
1356     int pcr_l, next_pcr_l;
1357     uint8_t pcr_buf[12];
1358
1359     if (av_new_packet(pkt, TS_PACKET_SIZE) < 0)
1360         return AVERROR(ENOMEM);
1361     pkt->pos= url_ftell(s->pb);
1362     ret = read_packet(s->pb, pkt->data, ts->raw_packet_size);
1363     if (ret < 0) {
1364         av_free_packet(pkt);
1365         return ret;
1366     }
1367     if (ts->mpeg2ts_compute_pcr) {
1368         /* compute exact PCR for each packet */
1369         if (parse_pcr(&pcr_h, &pcr_l, pkt->data) == 0) {
1370             /* we read the next PCR (XXX: optimize it by using a bigger buffer */
1371             pos = url_ftell(s->pb);
1372             for(i = 0; i < MAX_PACKET_READAHEAD; i++) {
1373                 url_fseek(s->pb, pos + i * ts->raw_packet_size, SEEK_SET);
1374                 get_buffer(s->pb, pcr_buf, 12);
1375                 if (parse_pcr(&next_pcr_h, &next_pcr_l, pcr_buf) == 0) {
1376                     /* XXX: not precise enough */
1377                     ts->pcr_incr = ((next_pcr_h - pcr_h) * 300 + (next_pcr_l - pcr_l)) /
1378                         (i + 1);
1379                     break;
1380                 }
1381             }
1382             url_fseek(s->pb, pos, SEEK_SET);
1383             /* no next PCR found: we use previous increment */
1384             ts->cur_pcr = pcr_h * 300 + pcr_l;
1385         }
1386         pkt->pts = ts->cur_pcr;
1387         pkt->duration = ts->pcr_incr;
1388         ts->cur_pcr += ts->pcr_incr;
1389     }
1390     pkt->stream_index = 0;
1391     return 0;
1392 }
1393
1394 static int mpegts_read_packet(AVFormatContext *s,
1395                               AVPacket *pkt)
1396 {
1397     MpegTSContext *ts = s->priv_data;
1398     int ret, i;
1399
1400     if (url_ftell(s->pb) != ts->last_pos) {
1401         /* seek detected, flush pes buffer */
1402         for (i = 0; i < NB_PID_MAX; i++) {
1403             if (ts->pids[i] && ts->pids[i]->type == MPEGTS_PES) {
1404                 PESContext *pes = ts->pids[i]->u.pes_filter.opaque;
1405                 av_freep(&pes->buffer);
1406                 pes->data_index = 0;
1407                 pes->state = MPEGTS_SKIP; /* skip until pes header */
1408             }
1409         }
1410     }
1411
1412     ts->pkt = pkt;
1413     ret = handle_packets(ts, 0);
1414     if (ret < 0) {
1415         /* flush pes data left */
1416         for (i = 0; i < NB_PID_MAX; i++) {
1417             if (ts->pids[i] && ts->pids[i]->type == MPEGTS_PES) {
1418                 PESContext *pes = ts->pids[i]->u.pes_filter.opaque;
1419                 if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
1420                     new_pes_packet(pes, pkt);
1421                     ret = 0;
1422                     break;
1423                 }
1424             }
1425         }
1426     }
1427
1428     ts->last_pos = url_ftell(s->pb);
1429
1430     return ret;
1431 }
1432
1433 static int mpegts_read_close(AVFormatContext *s)
1434 {
1435     MpegTSContext *ts = s->priv_data;
1436     int i;
1437
1438     clear_programs(ts);
1439
1440     for(i=0;i<NB_PID_MAX;i++)
1441         if (ts->pids[i]) mpegts_close_filter(ts, ts->pids[i]);
1442
1443     return 0;
1444 }
1445
1446 static int64_t mpegts_get_pcr(AVFormatContext *s, int stream_index,
1447                               int64_t *ppos, int64_t pos_limit)
1448 {
1449     MpegTSContext *ts = s->priv_data;
1450     int64_t pos, timestamp;
1451     uint8_t buf[TS_PACKET_SIZE];
1452     int pcr_l, pcr_pid = ((PESContext*)s->streams[stream_index]->priv_data)->pcr_pid;
1453     const int find_next= 1;
1454     pos = ((*ppos  + ts->raw_packet_size - 1 - ts->pos47) / ts->raw_packet_size) * ts->raw_packet_size + ts->pos47;
1455     if (find_next) {
1456         for(;;) {
1457             url_fseek(s->pb, pos, SEEK_SET);
1458             if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
1459                 return AV_NOPTS_VALUE;
1460             if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
1461                 parse_pcr(&timestamp, &pcr_l, buf) == 0) {
1462                 break;
1463             }
1464             pos += ts->raw_packet_size;
1465         }
1466     } else {
1467         for(;;) {
1468             pos -= ts->raw_packet_size;
1469             if (pos < 0)
1470                 return AV_NOPTS_VALUE;
1471             url_fseek(s->pb, pos, SEEK_SET);
1472             if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
1473                 return AV_NOPTS_VALUE;
1474             if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
1475                 parse_pcr(&timestamp, &pcr_l, buf) == 0) {
1476                 break;
1477             }
1478         }
1479     }
1480     *ppos = pos;
1481
1482     return timestamp;
1483 }
1484
1485 static int read_seek(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1486     MpegTSContext *ts = s->priv_data;
1487     uint8_t buf[TS_PACKET_SIZE];
1488     int64_t pos;
1489
1490     if(av_seek_frame_binary(s, stream_index, target_ts, flags) < 0)
1491         return -1;
1492
1493     pos= url_ftell(s->pb);
1494
1495     for(;;) {
1496         url_fseek(s->pb, pos, SEEK_SET);
1497         if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
1498             return -1;
1499 //        pid = AV_RB16(buf + 1) & 0x1fff;
1500         if(buf[1] & 0x40) break;
1501         pos += ts->raw_packet_size;
1502     }
1503     url_fseek(s->pb, pos, SEEK_SET);
1504
1505     return 0;
1506 }
1507
1508 /**************************************************************/
1509 /* parsing functions - called from other demuxers such as RTP */
1510
1511 MpegTSContext *mpegts_parse_open(AVFormatContext *s)
1512 {
1513     MpegTSContext *ts;
1514
1515     ts = av_mallocz(sizeof(MpegTSContext));
1516     if (!ts)
1517         return NULL;
1518     /* no stream case, currently used by RTP */
1519     ts->raw_packet_size = TS_PACKET_SIZE;
1520     ts->stream = s;
1521     ts->auto_guess = 1;
1522     return ts;
1523 }
1524
1525 /* return the consumed length if a packet was output, or -1 if no
1526    packet is output */
1527 int mpegts_parse_packet(MpegTSContext *ts, AVPacket *pkt,
1528                         const uint8_t *buf, int len)
1529 {
1530     int len1;
1531
1532     len1 = len;
1533     ts->pkt = pkt;
1534     ts->stop_parse = 0;
1535     for(;;) {
1536         if (ts->stop_parse>0)
1537             break;
1538         if (len < TS_PACKET_SIZE)
1539             return -1;
1540         if (buf[0] != 0x47) {
1541             buf++;
1542             len--;
1543         } else {
1544             handle_packet(ts, buf);
1545             buf += TS_PACKET_SIZE;
1546             len -= TS_PACKET_SIZE;
1547         }
1548     }
1549     return len1 - len;
1550 }
1551
1552 void mpegts_parse_close(MpegTSContext *ts)
1553 {
1554     int i;
1555
1556     for(i=0;i<NB_PID_MAX;i++)
1557         av_free(ts->pids[i]);
1558     av_free(ts);
1559 }
1560
1561 AVInputFormat mpegts_demuxer = {
1562     "mpegts",
1563     NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
1564     sizeof(MpegTSContext),
1565     mpegts_probe,
1566     mpegts_read_header,
1567     mpegts_read_packet,
1568     mpegts_read_close,
1569     read_seek,
1570     mpegts_get_pcr,
1571     .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
1572 };
1573
1574 AVInputFormat mpegtsraw_demuxer = {
1575     "mpegtsraw",
1576     NULL_IF_CONFIG_SMALL("MPEG-2 raw transport stream format"),
1577     sizeof(MpegTSContext),
1578     NULL,
1579     mpegts_read_header,
1580     mpegts_raw_read_packet,
1581     mpegts_read_close,
1582     read_seek,
1583     mpegts_get_pcr,
1584     .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
1585 };