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