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