• Main Page
• Related Pages
• Modules
• Data Structures
• Files

• File List
• Globals

00001 /*
00002  * MPEG2 transport stream (aka DVB) demuxer
00003  * Copyright (c) 2002-2003 Fabrice Bellard
00004  *
00005  * This file is part of FFmpeg.
00006  *
00007  * FFmpeg is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * FFmpeg is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with FFmpeg; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020  */
00021 
00022 #include "libavutil/crc.h"
00023 #include "libavutil/intreadwrite.h"
00024 #include "avformat.h"
00025 #include "mpegts.h"
00026 #include "internal.h"
00027 
00028 //#define DEBUG_SI
00029 //#define DEBUG_SEEK
00030 
00031 /* 1.0 second at 24Mbit/s */
00032 #define MAX_SCAN_PACKETS 32000
00033 
00034 /* maximum size in which we look for synchronisation if
00035  synchronisation is lost */
00036 #define MAX_RESYNC_SIZE 4096
00037 #define REGISTRATION_DESCRIPTOR 5
00038 
00039 typedef struct PESContext PESContext;
00040 
00041 static PESContext* add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid, int stream_type);
00042 static AVStream* new_pes_av_stream(PESContext *pes, uint32_t code);
00043 
00044 enum MpegTSFilterType {
00045 MPEGTS_PES,
00046 MPEGTS_SECTION,
00047 };
00048 
00049 typedef struct MpegTSFilter MpegTSFilter;
00050 
00051 typedef void PESCallback(MpegTSFilter *f, const uint8_t *buf, int len, int is_start, int64_t pos);
00052 
00053 typedef struct MpegTSPESFilter {
00054 PESCallback *pes_cb;
00055 void *opaque;
00056 } MpegTSPESFilter;
00057 
00058 typedef void SectionCallback(MpegTSFilter *f, const uint8_t *buf, int len);
00059 
00060 typedef void SetServiceCallback(void *opaque, int ret);
00061 
00062 typedef struct MpegTSSectionFilter {
00063 int section_index;
00064 int section_h_size;
00065 uint8_t *section_buf;
00066 unsigned int check_crc:1;
00067 unsigned int end_of_section_reached:1;
00068 SectionCallback *section_cb;
00069 void *opaque;
00070 } MpegTSSectionFilter;
00071 
00072 struct MpegTSFilter {
00073 int pid;
00074 int last_cc; /* last cc code (-1 if first packet) */
00075 enum MpegTSFilterType type;
00076 union {
00077 MpegTSPESFilter pes_filter;
00078 MpegTSSectionFilter section_filter;
00079 } u;
00080 };
00081 
00082 #define MAX_PIDS_PER_PROGRAM 64
00083 struct Program {
00084 unsigned int id; //program id/service id
00085 unsigned int nb_pids;
00086 unsigned int pids[MAX_PIDS_PER_PROGRAM];
00087 };
00088 
00089 struct MpegTSContext {
00090 /* user data */
00091 AVFormatContext *stream;
00093 int raw_packet_size;
00094 
00095 int pos47;
00096 
00098 int auto_guess;
00099 
00101 int mpeg2ts_compute_pcr;
00102 
00103 int64_t cur_pcr; 
00104 int pcr_incr; 
00106 /* data needed to handle file based ts */
00108 int stop_parse;
00110 AVPacket *pkt;
00111 
00112 /******************************************/
00113 /* private mpegts data */
00114 /* scan context */
00116 unsigned int nb_prg;
00117 struct Program *prg;
00118 
00119 
00121 MpegTSFilter *pids[NB_PID_MAX];
00122 };
00123 
00124 /* TS stream handling */
00125 
00126 enum MpegTSState {
00127 MPEGTS_HEADER = 0,
00128 MPEGTS_PESHEADER_FILL,
00129 MPEGTS_PAYLOAD,
00130 MPEGTS_SKIP,
00131 };
00132 
00133 /* enough for PES header + length */
00134 #define PES_START_SIZE 9
00135 #define MAX_PES_HEADER_SIZE (9 + 255)
00136 
00137 struct PESContext {
00138 int pid;
00139 int pcr_pid; 
00140 int stream_type;
00141 MpegTSContext *ts;
00142 AVFormatContext *stream;
00143 AVStream *st;
00144 enum MpegTSState state;
00145 /* used to get the format */
00146 int data_index;
00147 int total_size;
00148 int pes_header_size;
00149 int64_t pts, dts;
00150 int64_t ts_packet_pos; 
00151 uint8_t header[MAX_PES_HEADER_SIZE];
00152 };
00153 
00154 extern AVInputFormat mpegts_demuxer;
00155 
00156 static void clear_program(MpegTSContext *ts, unsigned int programid)
00157 {
00158 int i;
00159 
00160 for(i=0; i<ts->nb_prg; i++)
00161 if(ts->prg[i].id == programid)
00162 ts->prg[i].nb_pids = 0;
00163 }
00164 
00165 static void clear_programs(MpegTSContext *ts)
00166 {
00167 av_freep(&ts->prg);
00168 ts->nb_prg=0;
00169 }
00170 
00171 static void add_pat_entry(MpegTSContext *ts, unsigned int programid)
00172 {
00173 struct Program *p;
00174 void *tmp = av_realloc(ts->prg, (ts->nb_prg+1)*sizeof(struct Program));
00175 if(!tmp)
00176 return;
00177 ts->prg = tmp;
00178 p = &ts->prg[ts->nb_prg];
00179 p->id = programid;
00180 p->nb_pids = 0;
00181 ts->nb_prg++;
00182 }
00183 
00184 static void add_pid_to_pmt(MpegTSContext *ts, unsigned int programid, unsigned int pid)
00185 {
00186 int i;
00187 struct Program *p = NULL;
00188 for(i=0; i<ts->nb_prg; i++) {
00189 if(ts->prg[i].id == programid) {
00190 p = &ts->prg[i];
00191 break;
00192 }
00193 }
00194 if(!p)
00195 return;
00196 
00197 if(p->nb_pids >= MAX_PIDS_PER_PROGRAM)
00198 return;
00199 p->pids[p->nb_pids++] = pid;
00200 }
00201 
00210 static int discard_pid(MpegTSContext *ts, unsigned int pid)
00211 {
00212 int i, j, k;
00213 int used = 0, discarded = 0;
00214 struct Program *p;
00215 for(i=0; i<ts->nb_prg; i++) {
00216 p = &ts->prg[i];
00217 for(j=0; j<p->nb_pids; j++) {
00218 if(p->pids[j] != pid)
00219 continue;
00220 //is program with id p->id set to be discarded?
00221 for(k=0; k<ts->stream->nb_programs; k++) {
00222 if(ts->stream->programs[k]->id == p->id) {
00223 if(ts->stream->programs[k]->discard == AVDISCARD_ALL)
00224 discarded++;
00225 else
00226 used++;
00227 }
00228 }
00229 }
00230 }
00231 
00232 return !used && discarded;
00233 }
00234 
00239 static void write_section_data(AVFormatContext *s, MpegTSFilter *tss1,
00240 const uint8_t *buf, int buf_size, int is_start)
00241 {
00242 MpegTSSectionFilter *tss = &tss1->u.section_filter;
00243 int len;
00244 
00245 if (is_start) {
00246 memcpy(tss->section_buf, buf, buf_size);
00247 tss->section_index = buf_size;
00248 tss->section_h_size = -1;
00249 tss->end_of_section_reached = 0;
00250 } else {
00251 if (tss->end_of_section_reached)
00252 return;
00253 len = 4096 - tss->section_index;
00254 if (buf_size < len)
00255 len = buf_size;
00256 memcpy(tss->section_buf + tss->section_index, buf, len);
00257 tss->section_index += len;
00258 }
00259 
00260 /* compute section length if possible */
00261 if (tss->section_h_size == -1 && tss->section_index >= 3) {
00262 len = (AV_RB16(tss->section_buf + 1) & 0xfff) + 3;
00263 if (len > 4096)
00264 return;
00265 tss->section_h_size = len;
00266 }
00267 
00268 if (tss->section_h_size != -1 && tss->section_index >= tss->section_h_size) {
00269 tss->end_of_section_reached = 1;
00270 if (!tss->check_crc ||
00271 av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1,
00272 tss->section_buf, tss->section_h_size) == 0)
00273 tss->section_cb(tss1, tss->section_buf, tss->section_h_size);
00274 }
00275 }
00276 
00277 static MpegTSFilter *mpegts_open_section_filter(MpegTSContext *ts, unsigned int pid,
00278 SectionCallback *section_cb, void *opaque,
00279 int check_crc)
00280 
00281 {
00282 MpegTSFilter *filter;
00283 MpegTSSectionFilter *sec;
00284 
00285 #ifdef DEBUG_SI
00286 av_log(ts->stream, AV_LOG_DEBUG, "Filter: pid=0x%x\n", pid);
00287 #endif
00288 if (pid >= NB_PID_MAX || ts->pids[pid])
00289 return NULL;
00290 filter = av_mallocz(sizeof(MpegTSFilter));
00291 if (!filter)
00292 return NULL;
00293 ts->pids[pid] = filter;
00294 filter->type = MPEGTS_SECTION;
00295 filter->pid = pid;
00296 filter->last_cc = -1;
00297 sec = &filter->u.section_filter;
00298 sec->section_cb = section_cb;
00299 sec->opaque = opaque;
00300 sec->section_buf = av_malloc(MAX_SECTION_SIZE);
00301 sec->check_crc = check_crc;
00302 if (!sec->section_buf) {
00303 av_free(filter);
00304 return NULL;
00305 }
00306 return filter;
00307 }
00308 
00309 static MpegTSFilter *mpegts_open_pes_filter(MpegTSContext *ts, unsigned int pid,
00310 PESCallback *pes_cb,
00311 void *opaque)
00312 {
00313 MpegTSFilter *filter;
00314 MpegTSPESFilter *pes;
00315 
00316 if (pid >= NB_PID_MAX || ts->pids[pid])
00317 return NULL;
00318 filter = av_mallocz(sizeof(MpegTSFilter));
00319 if (!filter)
00320 return NULL;
00321 ts->pids[pid] = filter;
00322 filter->type = MPEGTS_PES;
00323 filter->pid = pid;
00324 filter->last_cc = -1;
00325 pes = &filter->u.pes_filter;
00326 pes->pes_cb = pes_cb;
00327 pes->opaque = opaque;
00328 return filter;
00329 }
00330 
00331 static void mpegts_close_filter(MpegTSContext *ts, MpegTSFilter *filter)
00332 {
00333 int pid;
00334 
00335 pid = filter->pid;
00336 if (filter->type == MPEGTS_SECTION)
00337 av_freep(&filter->u.section_filter.section_buf);
00338 else if (filter->type == MPEGTS_PES) {
00339 /* referenced private data will be freed later in
00340  * av_close_input_stream */
00341 if (!((PESContext *)filter->u.pes_filter.opaque)->st) {
00342 av_freep(&filter->u.pes_filter.opaque);
00343 }
00344 }
00345 
00346 av_free(filter);
00347 ts->pids[pid] = NULL;
00348 }
00349 
00350 static int analyze(const uint8_t *buf, int size, int packet_size, int *index){
00351 int stat[packet_size];
00352 int i;
00353 int x=0;
00354 int best_score=0;
00355 
00356 memset(stat, 0, packet_size*sizeof(int));
00357 
00358 for(x=i=0; i<size-3; i++){
00359 if(buf[i] == 0x47 && !(buf[i+1] & 0x80) && (buf[i+3] & 0x30)){
00360 stat[x]++;
00361 if(stat[x] > best_score){
00362 best_score= stat[x];
00363 if(index) *index= x;
00364 }
00365 }
00366 
00367 x++;
00368 if(x == packet_size) x= 0;
00369 }
00370 
00371 return best_score;
00372 }
00373 
00374 /* autodetect fec presence. Must have at least 1024 bytes */
00375 static int get_packet_size(const uint8_t *buf, int size)
00376 {
00377 int score, fec_score, dvhs_score;
00378 
00379 if (size < (TS_FEC_PACKET_SIZE * 5 + 1))
00380 return -1;
00381 
00382 score = analyze(buf, size, TS_PACKET_SIZE, NULL);
00383 dvhs_score = analyze(buf, size, TS_DVHS_PACKET_SIZE, NULL);
00384 fec_score= analyze(buf, size, TS_FEC_PACKET_SIZE, NULL);
00385 // av_log(NULL, AV_LOG_DEBUG, "score: %d, dvhs_score: %d, fec_score: %d \n", score, dvhs_score, fec_score);
00386 
00387 if (score > fec_score && score > dvhs_score) return TS_PACKET_SIZE;
00388 else if(dvhs_score > score && dvhs_score > fec_score) return TS_DVHS_PACKET_SIZE;
00389 else if(score < fec_score && dvhs_score < fec_score) return TS_FEC_PACKET_SIZE;
00390 else return -1;
00391 }
00392 
00393 typedef struct SectionHeader {
00394 uint8_t tid;
00395 uint16_t id;
00396 uint8_t version;
00397 uint8_t sec_num;
00398 uint8_t last_sec_num;
00399 } SectionHeader;
00400 
00401 static inline int get8(const uint8_t **pp, const uint8_t *p_end)
00402 {
00403 const uint8_t *p;
00404 int c;
00405 
00406 p = *pp;
00407 if (p >= p_end)
00408 return -1;
00409 c = *p++;
00410 *pp = p;
00411 return c;
00412 }
00413 
00414 static inline int get16(const uint8_t **pp, const uint8_t *p_end)
00415 {
00416 const uint8_t *p;
00417 int c;
00418 
00419 p = *pp;
00420 if ((p + 1) >= p_end)
00421 return -1;
00422 c = AV_RB16(p);
00423 p += 2;
00424 *pp = p;
00425 return c;
00426 }
00427 
00428 /* read and allocate a DVB string preceeded by its length */
00429 static char *getstr8(const uint8_t **pp, const uint8_t *p_end)
00430 {
00431 int len;
00432 const uint8_t *p;
00433 char *str;
00434 
00435 p = *pp;
00436 len = get8(&p, p_end);
00437 if (len < 0)
00438 return NULL;
00439 if ((p + len) > p_end)
00440 return NULL;
00441 str = av_malloc(len + 1);
00442 if (!str)
00443 return NULL;
00444 memcpy(str, p, len);
00445 str[len] = '0円';
00446 p += len;
00447 *pp = p;
00448 return str;
00449 }
00450 
00451 static int parse_section_header(SectionHeader *h,
00452 const uint8_t **pp, const uint8_t *p_end)
00453 {
00454 int val;
00455 
00456 val = get8(pp, p_end);
00457 if (val < 0)
00458 return -1;
00459 h->tid = val;
00460 *pp += 2;
00461 val = get16(pp, p_end);
00462 if (val < 0)
00463 return -1;
00464 h->id = val;
00465 val = get8(pp, p_end);
00466 if (val < 0)
00467 return -1;
00468 h->version = (val >> 1) & 0x1f;
00469 val = get8(pp, p_end);
00470 if (val < 0)
00471 return -1;
00472 h->sec_num = val;
00473 val = get8(pp, p_end);
00474 if (val < 0)
00475 return -1;
00476 h->last_sec_num = val;
00477 return 0;
00478 }
00479 
00480 
00481 static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
00482 {
00483 MpegTSContext *ts = filter->u.section_filter.opaque;
00484 SectionHeader h1, *h = &h1;
00485 PESContext *pes;
00486 AVStream *st;
00487 const uint8_t *p, *p_end, *desc_list_end, *desc_end;
00488 int program_info_length, pcr_pid, pid, stream_type;
00489 int desc_list_len, desc_len, desc_tag;
00490 int comp_page = 0, anc_page = 0; /* initialize to kill warnings */
00491 char language[4] = {0}; /* initialize to kill warnings */
00492 int has_hdmv_descr = 0;
00493 int has_dirac_descr = 0;
00494 
00495 #ifdef DEBUG_SI
00496 av_log(ts->stream, AV_LOG_DEBUG, "PMT: len %i\n", section_len);
00497 av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
00498 #endif
00499 p_end = section + section_len - 4;
00500 p = section;
00501 if (parse_section_header(h, &p, p_end) < 0)
00502 return;
00503 #ifdef DEBUG_SI
00504 av_log(ts->stream, AV_LOG_DEBUG, "sid=0x%x sec_num=%d/%d\n",
00505 h->id, h->sec_num, h->last_sec_num);
00506 #endif
00507 if (h->tid != PMT_TID)
00508 return;
00509 
00510 clear_program(ts, h->id);
00511 pcr_pid = get16(&p, p_end) & 0x1fff;
00512 if (pcr_pid < 0)
00513 return;
00514 add_pid_to_pmt(ts, h->id, pcr_pid);
00515 #ifdef DEBUG_SI
00516 av_log(ts->stream, AV_LOG_DEBUG, "pcr_pid=0x%x\n", pcr_pid);
00517 #endif
00518 program_info_length = get16(&p, p_end) & 0xfff;
00519 if (program_info_length < 0)
00520 return;
00521 while(program_info_length >= 2) {
00522 uint8_t tag, len;
00523 tag = get8(&p, p_end);
00524 len = get8(&p, p_end);
00525 if(len > program_info_length - 2)
00526 //something else is broken, exit the program_descriptors_loop
00527 break;
00528 program_info_length -= len + 2;
00529 if(tag == REGISTRATION_DESCRIPTOR && len >= 4) {
00530 uint8_t bytes[4];
00531 bytes[0] = get8(&p, p_end);
00532 bytes[1] = get8(&p, p_end);
00533 bytes[2] = get8(&p, p_end);
00534 bytes[3] = get8(&p, p_end);
00535 len -= 4;
00536 if(bytes[0] == 'H' && bytes[1] == 'D' &&
00537 bytes[2] == 'M' && bytes[3] == 'V')
00538 has_hdmv_descr = 1;
00539 }
00540 p += len;
00541 }
00542 p += program_info_length;
00543 if (p >= p_end)
00544 return;
00545 for(;;) {
00546 language[0] = 0;
00547 st = 0;
00548 stream_type = get8(&p, p_end);
00549 if (stream_type < 0)
00550 break;
00551 pid = get16(&p, p_end) & 0x1fff;
00552 if (pid < 0)
00553 break;
00554 desc_list_len = get16(&p, p_end) & 0xfff;
00555 if (desc_list_len < 0)
00556 break;
00557 desc_list_end = p + desc_list_len;
00558 if (desc_list_end > p_end)
00559 break;
00560 for(;;) {
00561 desc_tag = get8(&p, desc_list_end);
00562 if (desc_tag < 0)
00563 break;
00564 if (stream_type == STREAM_TYPE_PRIVATE_DATA) {
00565 if((desc_tag == 0x6A) || (desc_tag == 0x7A)) {
00566 /*assume DVB AC-3 Audio*/
00567 stream_type = STREAM_TYPE_AUDIO_AC3;
00568 } else if(desc_tag == 0x7B) {
00569 /* DVB DTS audio */
00570 stream_type = STREAM_TYPE_AUDIO_DTS;
00571 }
00572 }
00573 desc_len = get8(&p, desc_list_end);
00574 desc_end = p + desc_len;
00575 if (desc_end > desc_list_end)
00576 break;
00577 #ifdef DEBUG_SI
00578 av_log(ts->stream, AV_LOG_DEBUG, "tag: 0x%02x len=%d\n",
00579 desc_tag, desc_len);
00580 #endif
00581 switch(desc_tag) {
00582 case DVB_SUBT_DESCID:
00583 if (stream_type == STREAM_TYPE_PRIVATE_DATA)
00584 stream_type = STREAM_TYPE_SUBTITLE_DVB;
00585 
00586 language[0] = get8(&p, desc_end);
00587 language[1] = get8(&p, desc_end);
00588 language[2] = get8(&p, desc_end);
00589 language[3] = 0;
00590 get8(&p, desc_end);
00591 comp_page = get16(&p, desc_end);
00592 anc_page = get16(&p, desc_end);
00593 
00594 break;
00595 case 0x0a: /* ISO 639 language descriptor */
00596 language[0] = get8(&p, desc_end);
00597 language[1] = get8(&p, desc_end);
00598 language[2] = get8(&p, desc_end);
00599 language[3] = 0;
00600 break;
00601 case REGISTRATION_DESCRIPTOR: /*MPEG-2 Registration descriptor */
00602 {
00603 uint8_t bytes[4];
00604 bytes[0] = get8(&p, desc_end);
00605 bytes[1] = get8(&p, desc_end);
00606 bytes[2] = get8(&p, desc_end);
00607 bytes[3] = get8(&p, desc_end);
00608 if(bytes[0] == 'd' && bytes[1] == 'r' &&
00609 bytes[2] == 'a' && bytes[3] == 'c')
00610 has_dirac_descr = 1;
00611 break;
00612 }
00613 default:
00614 break;
00615 }
00616 p = desc_end;
00617 }
00618 p = desc_list_end;
00619 
00620 #ifdef DEBUG_SI
00621 av_log(ts->stream, AV_LOG_DEBUG, "stream_type=%d pid=0x%x\n",
00622 stream_type, pid);
00623 #endif
00624 
00625 /* now create ffmpeg stream */
00626 switch(stream_type) {
00627 case STREAM_TYPE_AUDIO_MPEG1:
00628 case STREAM_TYPE_AUDIO_MPEG2:
00629 case STREAM_TYPE_VIDEO_MPEG1:
00630 case STREAM_TYPE_VIDEO_MPEG2:
00631 case STREAM_TYPE_VIDEO_MPEG4:
00632 case STREAM_TYPE_VIDEO_H264:
00633 case STREAM_TYPE_VIDEO_VC1:
00634 case STREAM_TYPE_VIDEO_DIRAC:
00635 case STREAM_TYPE_AUDIO_AAC:
00636 case STREAM_TYPE_AUDIO_AC3:
00637 case STREAM_TYPE_AUDIO_DTS:
00638 case STREAM_TYPE_AUDIO_HDMV_DTS:
00639 case STREAM_TYPE_SUBTITLE_DVB:
00640 if((stream_type == STREAM_TYPE_AUDIO_HDMV_DTS && !has_hdmv_descr)
00641 || (stream_type == STREAM_TYPE_VIDEO_DIRAC && !has_dirac_descr))
00642 break;
00643 if(ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES){
00644 pes= ts->pids[pid]->u.pes_filter.opaque;
00645 st= pes->st;
00646 }else{
00647 if (ts->pids[pid]) mpegts_close_filter(ts, ts->pids[pid]); //wrongly added sdt filter probably
00648 pes = add_pes_stream(ts, pid, pcr_pid, stream_type);
00649 if (pes)
00650 st = new_pes_av_stream(pes, 0);
00651 }
00652 add_pid_to_pmt(ts, h->id, pid);
00653 if(st)
00654 av_program_add_stream_index(ts->stream, h->id, st->index);
00655 break;
00656 default:
00657 /* we ignore the other streams */
00658 break;
00659 }
00660 
00661 if (st) {
00662 if (language[0] != 0) {
00663 av_metadata_set(&st->metadata, "language", language);
00664 }
00665 
00666 if (stream_type == STREAM_TYPE_SUBTITLE_DVB) {
00667 st->codec->sub_id = (anc_page << 16) | comp_page;
00668 }
00669 }
00670 }
00671 /* all parameters are there */
00672 ts->stop_parse++;
00673 mpegts_close_filter(ts, filter);
00674 }
00675 
00676 static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
00677 {
00678 MpegTSContext *ts = filter->u.section_filter.opaque;
00679 SectionHeader h1, *h = &h1;
00680 const uint8_t *p, *p_end;
00681 int sid, pmt_pid;
00682 
00683 #ifdef DEBUG_SI
00684 av_log(ts->stream, AV_LOG_DEBUG, "PAT:\n");
00685 av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
00686 #endif
00687 p_end = section + section_len - 4;
00688 p = section;
00689 if (parse_section_header(h, &p, p_end) < 0)
00690 return;
00691 if (h->tid != PAT_TID)
00692 return;
00693 
00694 clear_programs(ts);
00695 for(;;) {
00696 sid = get16(&p, p_end);
00697 if (sid < 0)
00698 break;
00699 pmt_pid = get16(&p, p_end) & 0x1fff;
00700 if (pmt_pid < 0)
00701 break;
00702 #ifdef DEBUG_SI
00703 av_log(ts->stream, AV_LOG_DEBUG, "sid=0x%x pid=0x%x\n", sid, pmt_pid);
00704 #endif
00705 if (sid == 0x0000) {
00706 /* NIT info */
00707 } else {
00708 av_new_program(ts->stream, sid);
00709 ts->stop_parse--;
00710 mpegts_open_section_filter(ts, pmt_pid, pmt_cb, ts, 1);
00711 add_pat_entry(ts, sid);
00712 add_pid_to_pmt(ts, sid, 0); //add pat pid to program
00713 add_pid_to_pmt(ts, sid, pmt_pid);
00714 }
00715 }
00716 /* not found */
00717 ts->stop_parse++;
00718 
00719 mpegts_close_filter(ts, filter);
00720 }
00721 
00722 static void mpegts_set_service(MpegTSContext *ts)
00723 {
00724 mpegts_open_section_filter(ts, PAT_PID,
00725 pat_cb, ts, 1);
00726 }
00727 
00728 static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
00729 {
00730 MpegTSContext *ts = filter->u.section_filter.opaque;
00731 SectionHeader h1, *h = &h1;
00732 const uint8_t *p, *p_end, *desc_list_end, *desc_end;
00733 int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type;
00734 char *name, *provider_name;
00735 
00736 #ifdef DEBUG_SI
00737 av_log(ts->stream, AV_LOG_DEBUG, "SDT:\n");
00738 av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
00739 #endif
00740 
00741 p_end = section + section_len - 4;
00742 p = section;
00743 if (parse_section_header(h, &p, p_end) < 0)
00744 return;
00745 if (h->tid != SDT_TID)
00746 return;
00747 onid = get16(&p, p_end);
00748 if (onid < 0)
00749 return;
00750 val = get8(&p, p_end);
00751 if (val < 0)
00752 return;
00753 for(;;) {
00754 sid = get16(&p, p_end);
00755 if (sid < 0)
00756 break;
00757 val = get8(&p, p_end);
00758 if (val < 0)
00759 break;
00760 desc_list_len = get16(&p, p_end) & 0xfff;
00761 if (desc_list_len < 0)
00762 break;
00763 desc_list_end = p + desc_list_len;
00764 if (desc_list_end > p_end)
00765 break;
00766 for(;;) {
00767 desc_tag = get8(&p, desc_list_end);
00768 if (desc_tag < 0)
00769 break;
00770 desc_len = get8(&p, desc_list_end);
00771 desc_end = p + desc_len;
00772 if (desc_end > desc_list_end)
00773 break;
00774 #ifdef DEBUG_SI
00775 av_log(ts->stream, AV_LOG_DEBUG, "tag: 0x%02x len=%d\n",
00776 desc_tag, desc_len);
00777 #endif
00778 switch(desc_tag) {
00779 case 0x48:
00780 service_type = get8(&p, p_end);
00781 if (service_type < 0)
00782 break;
00783 provider_name = getstr8(&p, p_end);
00784 if (!provider_name)
00785 break;
00786 name = getstr8(&p, p_end);
00787 if (name) {
00788 AVProgram *program = av_new_program(ts->stream, sid);
00789 if(program) {
00790 av_metadata_set(&program->metadata, "name", name);
00791 av_metadata_set(&program->metadata, "provider_name", provider_name);
00792 }
00793 }
00794 av_free(name);
00795 av_free(provider_name);
00796 break;
00797 default:
00798 break;
00799 }
00800 p = desc_end;
00801 }
00802 p = desc_list_end;
00803 }
00804 }
00805 
00806 /* scan services in a transport stream by looking at the SDT */
00807 static void mpegts_scan_sdt(MpegTSContext *ts)
00808 {
00809 mpegts_open_section_filter(ts, SDT_PID,
00810 sdt_cb, ts, 1);
00811 }
00812 
00813 static int64_t get_pts(const uint8_t *p)
00814 {
00815 int64_t pts = (int64_t)((p[0] >> 1) & 0x07) << 30;
00816 pts |= (AV_RB16(p + 1) >> 1) << 15;
00817 pts |= AV_RB16(p + 3) >> 1;
00818 return pts;
00819 }
00820 
00821 /* return non zero if a packet could be constructed */
00822 static void mpegts_push_data(MpegTSFilter *filter,
00823 const uint8_t *buf, int buf_size, int is_start,
00824 int64_t pos)
00825 {
00826 PESContext *pes = filter->u.pes_filter.opaque;
00827 MpegTSContext *ts = pes->ts;
00828 const uint8_t *p;
00829 int len, code;
00830 
00831 if(!ts->pkt)
00832 return;
00833 
00834 if (is_start) {
00835 pes->state = MPEGTS_HEADER;
00836 pes->data_index = 0;
00837 pes->ts_packet_pos = pos;
00838 }
00839 p = buf;
00840 while (buf_size > 0) {
00841 switch(pes->state) {
00842 case MPEGTS_HEADER:
00843 len = PES_START_SIZE - pes->data_index;
00844 if (len > buf_size)
00845 len = buf_size;
00846 memcpy(pes->header + pes->data_index, p, len);
00847 pes->data_index += len;
00848 p += len;
00849 buf_size -= len;
00850 if (pes->data_index == PES_START_SIZE) {
00851 /* we got all the PES or section header. We can now
00852  decide */
00853 #if 0
00854 av_hex_dump_log(pes->stream, AV_LOG_DEBUG, pes->header, pes->data_index);
00855 #endif
00856 if (pes->header[0] == 0x00 && pes->header[1] == 0x00 &&
00857 pes->header[2] == 0x01) {
00858 /* it must be an mpeg2 PES stream */
00859 code = pes->header[3] | 0x100;
00860 if (!((code >= 0x1c0 && code <= 0x1df) ||
00861 (code >= 0x1e0 && code <= 0x1ef) ||
00862 (code == 0x1bd) || (code == 0x1fd)))
00863 goto skip;
00864 if (!pes->st) {
00865 /* allocate stream */
00866 new_pes_av_stream(pes, code);
00867 }
00868 pes->state = MPEGTS_PESHEADER_FILL;
00869 pes->total_size = AV_RB16(pes->header + 4);
00870 /* NOTE: a zero total size means the PES size is
00871  unbounded */
00872 if (pes->total_size)
00873 pes->total_size += 6;
00874 pes->pes_header_size = pes->header[8] + 9;
00875 } else {
00876 /* otherwise, it should be a table */
00877 /* skip packet */
00878 skip:
00879 pes->state = MPEGTS_SKIP;
00880 continue;
00881 }
00882 }
00883 break;
00884 /**********************************************/
00885 /* PES packing parsing */
00886 case MPEGTS_PESHEADER_FILL:
00887 len = pes->pes_header_size - pes->data_index;
00888 if (len > buf_size)
00889 len = buf_size;
00890 memcpy(pes->header + pes->data_index, p, len);
00891 pes->data_index += len;
00892 p += len;
00893 buf_size -= len;
00894 if (pes->data_index == pes->pes_header_size) {
00895 const uint8_t *r;
00896 unsigned int flags;
00897 
00898 flags = pes->header[7];
00899 r = pes->header + 9;
00900 pes->pts = AV_NOPTS_VALUE;
00901 pes->dts = AV_NOPTS_VALUE;
00902 if ((flags & 0xc0) == 0x80) {
00903 pes->dts = pes->pts = get_pts(r);
00904 r += 5;
00905 } else if ((flags & 0xc0) == 0xc0) {
00906 pes->pts = get_pts(r);
00907 r += 5;
00908 pes->dts = get_pts(r);
00909 r += 5;
00910 }
00911 /* we got the full header. We parse it and get the payload */
00912 pes->state = MPEGTS_PAYLOAD;
00913 }
00914 break;
00915 case MPEGTS_PAYLOAD:
00916 if (pes->total_size) {
00917 len = pes->total_size - pes->data_index;
00918 if (len > buf_size)
00919 len = buf_size;
00920 } else {
00921 len = buf_size;
00922 }
00923 if (len > 0) {
00924 AVPacket *pkt = ts->pkt;
00925 if (pes->st && av_new_packet(pkt, len) == 0) {
00926 memcpy(pkt->data, p, len);
00927 pkt->stream_index = pes->st->index;
00928 pkt->pts = pes->pts;
00929 pkt->dts = pes->dts;
00930 /* store position of first TS packet of this PES packet */
00931 pkt->pos = pes->ts_packet_pos;
00932 /* reset pts values */
00933 pes->pts = AV_NOPTS_VALUE;
00934 pes->dts = AV_NOPTS_VALUE;
00935 ts->stop_parse = 1;
00936 return;
00937 }
00938 }
00939 buf_size = 0;
00940 break;
00941 case MPEGTS_SKIP:
00942 buf_size = 0;
00943 break;
00944 }
00945 }
00946 }
00947 
00948 static AVStream* new_pes_av_stream(PESContext *pes, uint32_t code)
00949 {
00950 AVStream *st;
00951 enum CodecID codec_id;
00952 enum CodecType codec_type;
00953 
00954 switch(pes->stream_type){
00955 case STREAM_TYPE_AUDIO_MPEG1:
00956 case STREAM_TYPE_AUDIO_MPEG2:
00957 codec_type = CODEC_TYPE_AUDIO;
00958 codec_id = CODEC_ID_MP3;
00959 break;
00960 case STREAM_TYPE_VIDEO_MPEG1:
00961 case STREAM_TYPE_VIDEO_MPEG2:
00962 codec_type = CODEC_TYPE_VIDEO;
00963 codec_id = CODEC_ID_MPEG2VIDEO;
00964 break;
00965 case STREAM_TYPE_VIDEO_MPEG4:
00966 codec_type = CODEC_TYPE_VIDEO;
00967 codec_id = CODEC_ID_MPEG4;
00968 break;
00969 case STREAM_TYPE_VIDEO_H264:
00970 codec_type = CODEC_TYPE_VIDEO;
00971 codec_id = CODEC_ID_H264;
00972 break;
00973 case STREAM_TYPE_VIDEO_VC1:
00974 codec_type = CODEC_TYPE_VIDEO;
00975 codec_id = CODEC_ID_VC1;
00976 break;
00977 case STREAM_TYPE_VIDEO_DIRAC:
00978 codec_type = CODEC_TYPE_VIDEO;
00979 codec_id = CODEC_ID_DIRAC;
00980 break;
00981 case STREAM_TYPE_AUDIO_AAC:
00982 codec_type = CODEC_TYPE_AUDIO;
00983 codec_id = CODEC_ID_AAC;
00984 break;
00985 case STREAM_TYPE_AUDIO_AC3:
00986 codec_type = CODEC_TYPE_AUDIO;
00987 codec_id = CODEC_ID_AC3;
00988 break;
00989 case STREAM_TYPE_AUDIO_DTS:
00990 case STREAM_TYPE_AUDIO_HDMV_DTS:
00991 codec_type = CODEC_TYPE_AUDIO;
00992 codec_id = CODEC_ID_DTS;
00993 break;
00994 case STREAM_TYPE_SUBTITLE_DVB:
00995 codec_type = CODEC_TYPE_SUBTITLE;
00996 codec_id = CODEC_ID_DVB_SUBTITLE;
00997 break;
00998 default:
00999 if (code >= 0x1c0 && code <= 0x1df) {
01000 codec_type = CODEC_TYPE_AUDIO;
01001 codec_id = CODEC_ID_MP2;
01002 } else if (code == 0x1bd) {
01003 codec_type = CODEC_TYPE_AUDIO;
01004 codec_id = CODEC_ID_AC3;
01005 } else {
01006 codec_type = CODEC_TYPE_VIDEO;
01007 codec_id = CODEC_ID_PROBE;
01008 }
01009 break;
01010 }
01011 st = av_new_stream(pes->stream, pes->pid);
01012 if (st) {
01013 av_set_pts_info(st, 33, 1, 90000);
01014 st->priv_data = pes;
01015 st->codec->codec_type = codec_type;
01016 st->codec->codec_id = codec_id;
01017 st->need_parsing = AVSTREAM_PARSE_FULL;
01018 pes->st = st;
01019 }
01020 return st;
01021 }
01022 
01023 
01024 static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid, int stream_type)
01025 {
01026 MpegTSFilter *tss;
01027 PESContext *pes;
01028 
01029 /* if no pid found, then add a pid context */
01030 pes = av_mallocz(sizeof(PESContext));
01031 if (!pes)
01032 return 0;
01033 pes->ts = ts;
01034 pes->stream = ts->stream;
01035 pes->pid = pid;
01036 pes->pcr_pid = pcr_pid;
01037 pes->stream_type = stream_type;
01038 tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes);
01039 if (!tss) {
01040 av_free(pes);
01041 return 0;
01042 }
01043 return pes;
01044 }
01045 
01046 /* handle one TS packet */
01047 static void handle_packet(MpegTSContext *ts, const uint8_t *packet)
01048 {
01049 AVFormatContext *s = ts->stream;
01050 MpegTSFilter *tss;
01051 int len, pid, cc, cc_ok, afc, is_start;
01052 const uint8_t *p, *p_end;
01053 int64_t pos;
01054 
01055 pid = AV_RB16(packet + 1) & 0x1fff;
01056 if(pid && discard_pid(ts, pid))
01057 return;
01058 is_start = packet[1] & 0x40;
01059 tss = ts->pids[pid];
01060 if (ts->auto_guess && tss == NULL && is_start) {
01061 add_pes_stream(ts, pid, -1, 0);
01062 tss = ts->pids[pid];
01063 }
01064 if (!tss)
01065 return;
01066 
01067 /* continuity check (currently not used) */
01068 cc = (packet[3] & 0xf);
01069 cc_ok = (tss->last_cc < 0) || ((((tss->last_cc + 1) & 0x0f) == cc));
01070 tss->last_cc = cc;
01071 
01072 /* skip adaptation field */
01073 afc = (packet[3] >> 4) & 3;
01074 p = packet + 4;
01075 if (afc == 0) /* reserved value */
01076 return;
01077 if (afc == 2) /* adaptation field only */
01078 return;
01079 if (afc == 3) {
01080 /* skip adapation field */
01081 p += p[0] + 1;
01082 }
01083 /* if past the end of packet, ignore */
01084 p_end = packet + TS_PACKET_SIZE;
01085 if (p >= p_end)
01086 return;
01087 
01088 pos = url_ftell(ts->stream->pb);
01089 ts->pos47= pos % ts->raw_packet_size;
01090 
01091 if (tss->type == MPEGTS_SECTION) {
01092 if (is_start) {
01093 /* pointer field present */
01094 len = *p++;
01095 if (p + len > p_end)
01096 return;
01097 if (len && cc_ok) {
01098 /* write remaining section bytes */
01099 write_section_data(s, tss,
01100 p, len, 0);
01101 /* check whether filter has been closed */
01102 if (!ts->pids[pid])
01103 return;
01104 }
01105 p += len;
01106 if (p < p_end) {
01107 write_section_data(s, tss,
01108 p, p_end - p, 1);
01109 }
01110 } else {
01111 if (cc_ok) {
01112 write_section_data(s, tss,
01113 p, p_end - p, 0);
01114 }
01115 }
01116 } else {
01117 // Note: The position here points actually behind the current packet.
01118 tss->u.pes_filter.pes_cb(tss,
01119 p, p_end - p, is_start, pos - ts->raw_packet_size);
01120 }
01121 }
01122 
01123 /* XXX: try to find a better synchro over several packets (use
01124  get_packet_size() ?) */
01125 static int mpegts_resync(ByteIOContext *pb)
01126 {
01127 int c, i;
01128 
01129 for(i = 0;i < MAX_RESYNC_SIZE; i++) {
01130 c = url_fgetc(pb);
01131 if (c < 0)
01132 return -1;
01133 if (c == 0x47) {
01134 url_fseek(pb, -1, SEEK_CUR);
01135 return 0;
01136 }
01137 }
01138 /* no sync found */
01139 return -1;
01140 }
01141 
01142 /* return -1 if error or EOF. Return 0 if OK. */
01143 static int read_packet(ByteIOContext *pb, uint8_t *buf, int raw_packet_size)
01144 {
01145 int skip, len;
01146 
01147 for(;;) {
01148 len = get_buffer(pb, buf, TS_PACKET_SIZE);
01149 if (len != TS_PACKET_SIZE)
01150 return AVERROR(EIO);
01151 /* check paquet sync byte */
01152 if (buf[0] != 0x47) {
01153 /* find a new packet start */
01154 url_fseek(pb, -TS_PACKET_SIZE, SEEK_CUR);
01155 if (mpegts_resync(pb) < 0)
01156 return AVERROR_INVALIDDATA;
01157 else
01158 continue;
01159 } else {
01160 skip = raw_packet_size - TS_PACKET_SIZE;
01161 if (skip > 0)
01162 url_fskip(pb, skip);
01163 break;
01164 }
01165 }
01166 return 0;
01167 }
01168 
01169 static int handle_packets(MpegTSContext *ts, int nb_packets)
01170 {
01171 AVFormatContext *s = ts->stream;
01172 ByteIOContext *pb = s->pb;
01173 uint8_t packet[TS_PACKET_SIZE];
01174 int packet_num, ret;
01175 
01176 ts->stop_parse = 0;
01177 packet_num = 0;
01178 for(;;) {
01179 if (ts->stop_parse>0)
01180 break;
01181 packet_num++;
01182 if (nb_packets != 0 && packet_num >= nb_packets)
01183 break;
01184 ret = read_packet(pb, packet, ts->raw_packet_size);
01185 if (ret != 0)
01186 return ret;
01187 handle_packet(ts, packet);
01188 }
01189 return 0;
01190 }
01191 
01192 static int mpegts_probe(AVProbeData *p)
01193 {
01194 #if 1
01195 const int size= p->buf_size;
01196 int score, fec_score, dvhs_score;
01197 int check_count= size / TS_FEC_PACKET_SIZE;
01198 #define CHECK_COUNT 10
01199 
01200 if (check_count < CHECK_COUNT)
01201 return -1;
01202 
01203 score = analyze(p->buf, TS_PACKET_SIZE *check_count, TS_PACKET_SIZE , NULL)*CHECK_COUNT/check_count;
01204 dvhs_score= analyze(p->buf, TS_DVHS_PACKET_SIZE*check_count, TS_DVHS_PACKET_SIZE, NULL)*CHECK_COUNT/check_count;
01205 fec_score = analyze(p->buf, TS_FEC_PACKET_SIZE *check_count, TS_FEC_PACKET_SIZE , NULL)*CHECK_COUNT/check_count;
01206 // av_log(NULL, AV_LOG_DEBUG, "score: %d, dvhs_score: %d, fec_score: %d \n", score, dvhs_score, fec_score);
01207 
01208 // we need a clear definition for the returned score otherwise things will become messy sooner or later
01209 if (score > fec_score && score > dvhs_score && score > 6) return AVPROBE_SCORE_MAX + score - CHECK_COUNT;
01210 else if(dvhs_score > score && dvhs_score > fec_score && dvhs_score > 6) return AVPROBE_SCORE_MAX + dvhs_score - CHECK_COUNT;
01211 else if( fec_score > 6) return AVPROBE_SCORE_MAX + fec_score - CHECK_COUNT;
01212 else return -1;
01213 #else
01214 /* only use the extension for safer guess */
01215 if (match_ext(p->filename, "ts"))
01216 return AVPROBE_SCORE_MAX;
01217 else
01218 return 0;
01219 #endif
01220 }
01221 
01222 /* return the 90kHz PCR and the extension for the 27MHz PCR. return
01223  (-1) if not available */
01224 static int parse_pcr(int64_t *ppcr_high, int *ppcr_low,
01225 const uint8_t *packet)
01226 {
01227 int afc, len, flags;
01228 const uint8_t *p;
01229 unsigned int v;
01230 
01231 afc = (packet[3] >> 4) & 3;
01232 if (afc <= 1)
01233 return -1;
01234 p = packet + 4;
01235 len = p[0];
01236 p++;
01237 if (len == 0)
01238 return -1;
01239 flags = *p++;
01240 len--;
01241 if (!(flags & 0x10))
01242 return -1;
01243 if (len < 6)
01244 return -1;
01245 v = AV_RB32(p);
01246 *ppcr_high = ((int64_t)v << 1) | (p[4] >> 7);
01247 *ppcr_low = ((p[4] & 1) << 8) | p[5];
01248 return 0;
01249 }
01250 
01251 static int mpegts_read_header(AVFormatContext *s,
01252 AVFormatParameters *ap)
01253 {
01254 MpegTSContext *ts = s->priv_data;
01255 ByteIOContext *pb = s->pb;
01256 uint8_t buf[5*1024];
01257 int len;
01258 int64_t pos;
01259 
01260 if (ap) {
01261 ts->mpeg2ts_compute_pcr = ap->mpeg2ts_compute_pcr;
01262 if(ap->mpeg2ts_raw){
01263 av_log(s, AV_LOG_ERROR, "use mpegtsraw_demuxer!\n");
01264 return -1;
01265 }
01266 }
01267 
01268 /* read the first 1024 bytes to get packet size */
01269 pos = url_ftell(pb);
01270 len = get_buffer(pb, buf, sizeof(buf));
01271 if (len != sizeof(buf))
01272 goto fail;
01273 ts->raw_packet_size = get_packet_size(buf, sizeof(buf));
01274 if (ts->raw_packet_size <= 0)
01275 goto fail;
01276 ts->stream = s;
01277 ts->auto_guess = 0;
01278 
01279 if (s->iformat == &mpegts_demuxer) {
01280 /* normal demux */
01281 
01282 /* first do a scaning to get all the services */
01283 url_fseek(pb, pos, SEEK_SET);
01284 mpegts_scan_sdt(ts);
01285 
01286 mpegts_set_service(ts);
01287 
01288 handle_packets(ts, s->probesize);
01289 /* if could not find service, enable auto_guess */
01290 
01291 ts->auto_guess = 1;
01292 
01293 #ifdef DEBUG_SI
01294 av_log(ts->stream, AV_LOG_DEBUG, "tuning done\n");
01295 #endif
01296 s->ctx_flags |= AVFMTCTX_NOHEADER;
01297 } else {
01298 AVStream *st;
01299 int pcr_pid, pid, nb_packets, nb_pcrs, ret, pcr_l;
01300 int64_t pcrs[2], pcr_h;
01301 int packet_count[2];
01302 uint8_t packet[TS_PACKET_SIZE];
01303 
01304 /* only read packets */
01305 
01306 st = av_new_stream(s, 0);
01307 if (!st)
01308 goto fail;
01309 av_set_pts_info(st, 60, 1, 27000000);
01310 st->codec->codec_type = CODEC_TYPE_DATA;
01311 st->codec->codec_id = CODEC_ID_MPEG2TS;
01312 
01313 /* we iterate until we find two PCRs to estimate the bitrate */
01314 pcr_pid = -1;
01315 nb_pcrs = 0;
01316 nb_packets = 0;
01317 for(;;) {
01318 ret = read_packet(s->pb, packet, ts->raw_packet_size);
01319 if (ret < 0)
01320 return -1;
01321 pid = AV_RB16(packet + 1) & 0x1fff;
01322 if ((pcr_pid == -1 || pcr_pid == pid) &&
01323 parse_pcr(&pcr_h, &pcr_l, packet) == 0) {
01324 pcr_pid = pid;
01325 packet_count[nb_pcrs] = nb_packets;
01326 pcrs[nb_pcrs] = pcr_h * 300 + pcr_l;
01327 nb_pcrs++;
01328 if (nb_pcrs >= 2)
01329 break;
01330 }
01331 nb_packets++;
01332 }
01333 
01334 /* NOTE1: the bitrate is computed without the FEC */
01335 /* NOTE2: it is only the bitrate of the start of the stream */
01336 ts->pcr_incr = (pcrs[1] - pcrs[0]) / (packet_count[1] - packet_count[0]);
01337 ts->cur_pcr = pcrs[0] - ts->pcr_incr * packet_count[0];
01338 s->bit_rate = (TS_PACKET_SIZE * 8) * 27e6 / ts->pcr_incr;
01339 st->codec->bit_rate = s->bit_rate;
01340 st->start_time = ts->cur_pcr;
01341 #if 0
01342 av_log(ts->stream, AV_LOG_DEBUG, "start=%0.3f pcr=%0.3f incr=%d\n",
01343 st->start_time / 1000000.0, pcrs[0] / 27e6, ts->pcr_incr);
01344 #endif
01345 }
01346 
01347 url_fseek(pb, pos, SEEK_SET);
01348 return 0;
01349 fail:
01350 return -1;
01351 }
01352 
01353 #define MAX_PACKET_READAHEAD ((128 * 1024) / 188)
01354 
01355 static int mpegts_raw_read_packet(AVFormatContext *s,
01356 AVPacket *pkt)
01357 {
01358 MpegTSContext *ts = s->priv_data;
01359 int ret, i;
01360 int64_t pcr_h, next_pcr_h, pos;
01361 int pcr_l, next_pcr_l;
01362 uint8_t pcr_buf[12];
01363 
01364 if (av_new_packet(pkt, TS_PACKET_SIZE) < 0)
01365 return AVERROR(ENOMEM);
01366 pkt->pos= url_ftell(s->pb);
01367 ret = read_packet(s->pb, pkt->data, ts->raw_packet_size);
01368 if (ret < 0) {
01369 av_free_packet(pkt);
01370 return ret;
01371 }
01372 if (ts->mpeg2ts_compute_pcr) {
01373 /* compute exact PCR for each packet */
01374 if (parse_pcr(&pcr_h, &pcr_l, pkt->data) == 0) {
01375 /* we read the next PCR (XXX: optimize it by using a bigger buffer */
01376 pos = url_ftell(s->pb);
01377 for(i = 0; i < MAX_PACKET_READAHEAD; i++) {
01378 url_fseek(s->pb, pos + i * ts->raw_packet_size, SEEK_SET);
01379 get_buffer(s->pb, pcr_buf, 12);
01380 if (parse_pcr(&next_pcr_h, &next_pcr_l, pcr_buf) == 0) {
01381 /* XXX: not precise enough */
01382 ts->pcr_incr = ((next_pcr_h - pcr_h) * 300 + (next_pcr_l - pcr_l)) /
01383 (i + 1);
01384 break;
01385 }
01386 }
01387 url_fseek(s->pb, pos, SEEK_SET);
01388 /* no next PCR found: we use previous increment */
01389 ts->cur_pcr = pcr_h * 300 + pcr_l;
01390 }
01391 pkt->pts = ts->cur_pcr;
01392 pkt->duration = ts->pcr_incr;
01393 ts->cur_pcr += ts->pcr_incr;
01394 }
01395 pkt->stream_index = 0;
01396 return 0;
01397 }
01398 
01399 static int mpegts_read_packet(AVFormatContext *s,
01400 AVPacket *pkt)
01401 {
01402 MpegTSContext *ts = s->priv_data;
01403 
01404 ts->pkt = pkt;
01405 return handle_packets(ts, 0);
01406 }
01407 
01408 static int mpegts_read_close(AVFormatContext *s)
01409 {
01410 MpegTSContext *ts = s->priv_data;
01411 int i;
01412 
01413 clear_programs(ts);
01414 
01415 for(i=0;i<NB_PID_MAX;i++)
01416 if (ts->pids[i]) mpegts_close_filter(ts, ts->pids[i]);
01417 
01418 return 0;
01419 }
01420 
01421 static int64_t mpegts_get_pcr(AVFormatContext *s, int stream_index,
01422 int64_t *ppos, int64_t pos_limit)
01423 {
01424 MpegTSContext *ts = s->priv_data;
01425 int64_t pos, timestamp;
01426 uint8_t buf[TS_PACKET_SIZE];
01427 int pcr_l, pcr_pid = ((PESContext*)s->streams[stream_index]->priv_data)->pcr_pid;
01428 const int find_next= 1;
01429 pos = ((*ppos + ts->raw_packet_size - 1 - ts->pos47) / ts->raw_packet_size) * ts->raw_packet_size + ts->pos47;
01430 if (find_next) {
01431 for(;;) {
01432 url_fseek(s->pb, pos, SEEK_SET);
01433 if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
01434 return AV_NOPTS_VALUE;
01435 if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
01436 parse_pcr(&timestamp, &pcr_l, buf) == 0) {
01437 break;
01438 }
01439 pos += ts->raw_packet_size;
01440 }
01441 } else {
01442 for(;;) {
01443 pos -= ts->raw_packet_size;
01444 if (pos < 0)
01445 return AV_NOPTS_VALUE;
01446 url_fseek(s->pb, pos, SEEK_SET);
01447 if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
01448 return AV_NOPTS_VALUE;
01449 if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
01450 parse_pcr(&timestamp, &pcr_l, buf) == 0) {
01451 break;
01452 }
01453 }
01454 }
01455 *ppos = pos;
01456 
01457 return timestamp;
01458 }
01459 
01460 static int read_seek(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
01461 MpegTSContext *ts = s->priv_data;
01462 uint8_t buf[TS_PACKET_SIZE];
01463 int64_t pos;
01464 
01465 if(av_seek_frame_binary(s, stream_index, target_ts, flags) < 0)
01466 return -1;
01467 
01468 pos= url_ftell(s->pb);
01469 
01470 for(;;) {
01471 url_fseek(s->pb, pos, SEEK_SET);
01472 if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
01473 return -1;
01474 // pid = AV_RB16(buf + 1) & 0x1fff;
01475 if(buf[1] & 0x40) break;
01476 pos += ts->raw_packet_size;
01477 }
01478 url_fseek(s->pb, pos, SEEK_SET);
01479 
01480 return 0;
01481 }
01482 
01483 /**************************************************************/
01484 /* parsing functions - called from other demuxers such as RTP */
01485 
01486 MpegTSContext *mpegts_parse_open(AVFormatContext *s)
01487 {
01488 MpegTSContext *ts;
01489 
01490 ts = av_mallocz(sizeof(MpegTSContext));
01491 if (!ts)
01492 return NULL;
01493 /* no stream case, currently used by RTP */
01494 ts->raw_packet_size = TS_PACKET_SIZE;
01495 ts->stream = s;
01496 ts->auto_guess = 1;
01497 return ts;
01498 }
01499 
01500 /* return the consumed length if a packet was output, or -1 if no
01501  packet is output */
01502 int mpegts_parse_packet(MpegTSContext *ts, AVPacket *pkt,
01503 const uint8_t *buf, int len)
01504 {
01505 int len1;
01506 
01507 len1 = len;
01508 ts->pkt = pkt;
01509 ts->stop_parse = 0;
01510 for(;;) {
01511 if (ts->stop_parse>0)
01512 break;
01513 if (len < TS_PACKET_SIZE)
01514 return -1;
01515 if (buf[0] != 0x47) {
01516 buf++;
01517 len--;
01518 } else {
01519 handle_packet(ts, buf);
01520 buf += TS_PACKET_SIZE;
01521 len -= TS_PACKET_SIZE;
01522 }
01523 }
01524 return len1 - len;
01525 }
01526 
01527 void mpegts_parse_close(MpegTSContext *ts)
01528 {
01529 int i;
01530 
01531 for(i=0;i<NB_PID_MAX;i++)
01532 av_free(ts->pids[i]);
01533 av_free(ts);
01534 }
01535 
01536 AVInputFormat mpegts_demuxer = {
01537 "mpegts",
01538 NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
01539 sizeof(MpegTSContext),
01540 mpegts_probe,
01541 mpegts_read_header,
01542 mpegts_read_packet,
01543 mpegts_read_close,
01544 read_seek,
01545 mpegts_get_pcr,
01546 .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
01547 };
01548 
01549 AVInputFormat mpegtsraw_demuxer = {
01550 "mpegtsraw",
01551 NULL_IF_CONFIG_SMALL("MPEG-2 raw transport stream format"),
01552 sizeof(MpegTSContext),
01553 NULL,
01554 mpegts_read_header,
01555 mpegts_raw_read_packet,
01556 mpegts_read_close,
01557 read_seek,
01558 mpegts_get_pcr,
01559 .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
01560 };