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