git.sesse.net Git - ffmpeg/blob - libavformat/mpegts.c

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