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