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