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