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