falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2752 Commits
32 Branches
552MB
Tree: 27f388aa24
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '27f388aa24'
${ noResults }
FFmpeg/libavformat/mpegts.c

1435 lines
40KB
Raw Blame History 

  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);

  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_AUDIO_AC3:

  407.             add_pes_stream(ts, pid);

  408.             break;

  409.         default:

  410.             /* we ignore the other streams */

  411.             break;

  412.         }

  413.     }

  414.     /* all parameters are there */

  415.     ts->set_service_cb(ts->set_service_opaque, 0);

  416.     mpegts_close_filter(ts, ts->pmt_filter);

  417.     ts->pmt_filter = NULL;

  418. }

  419. 

  420. static void pat_cb(void *opaque, const uint8_t *section, int section_len)

  421. {

  422.     MpegTSContext *ts = opaque;

  423.     SectionHeader h1, *h = &h1;

  424.     const uint8_t *p, *p_end;

  425.     int sid, pmt_pid;

  426. 

  427. #ifdef DEBUG_SI

  428.     printf("PAT:\n");

  429.     av_hex_dump((uint8_t *)section, section_len);

  430. #endif

  431.     p_end = section + section_len - 4;

  432.     p = section;

  433.     if (parse_section_header(h, &p, p_end) < 0)

  434.         return;

  435.     if (h->tid != PAT_TID)

  436.         return;

  437. 

  438.     for(;;) {

  439.         sid = get16(&p, p_end);

  440.         if (sid < 0)

  441.             break;

  442.         pmt_pid = get16(&p, p_end) & 0x1fff;

  443.         if (pmt_pid < 0)

  444.             break;

  445. #ifdef DEBUG_SI

  446.         printf("sid=0x%x pid=0x%x\n", sid, pmt_pid);

  447. #endif

  448.         if (sid == 0x0000) {

  449.             /* NIT info */

  450.         } else {

  451.             if (ts->req_sid == sid) {

  452.                 ts->pmt_filter = mpegts_open_section_filter(ts, pmt_pid, 

  453.                                                             pmt_cb, ts, 1);

  454.                 goto found;

  455.             }

  456.         }

  457.     }

  458.     /* not found */

  459.     ts->set_service_cb(ts->set_service_opaque, -1);

  460. 

  461.  found:

  462.     mpegts_close_filter(ts, ts->pat_filter);

  463.     ts->pat_filter = NULL;

  464. }

  465. 

  466. /* add all services found in the PAT */

  467. static void pat_scan_cb(void *opaque, const uint8_t *section, int section_len)

  468. {

  469.     MpegTSContext *ts = opaque;

  470.     SectionHeader h1, *h = &h1;

  471.     const uint8_t *p, *p_end;

  472.     int sid, pmt_pid;

  473.     char *provider_name, *name;

  474.     char buf[256];

  475. 

  476. #ifdef DEBUG_SI

  477.     printf("PAT:\n");

  478.     av_hex_dump((uint8_t *)section, section_len);

  479. #endif

  480.     p_end = section + section_len - 4;

  481.     p = section;

  482.     if (parse_section_header(h, &p, p_end) < 0)

  483.         return;

  484.     if (h->tid != PAT_TID)

  485.         return;

  486. 

  487.     for(;;) {

  488.         sid = get16(&p, p_end);

  489.         if (sid < 0)

  490.             break;

  491.         pmt_pid = get16(&p, p_end) & 0x1fff;

  492.         if (pmt_pid < 0)

  493.             break;

  494. #ifdef DEBUG_SI

  495.         printf("sid=0x%x pid=0x%x\n", sid, pmt_pid);

  496. #endif

  497.         if (sid == 0x0000) {

  498.             /* NIT info */

  499.         } else {

  500.             /* add the service with a dummy name */

  501.             snprintf(buf, sizeof(buf), "Service %x\n", sid);

  502.             name = av_strdup(buf);

  503.             provider_name = av_strdup("");

  504.             if (name && provider_name) {

  505.                 new_service(ts, sid, provider_name, name);

  506.             } else {

  507.                 av_freep(&name);

  508.                 av_freep(&provider_name);

  509.             }

  510.         }

  511.     }

  512.     ts->stop_parse = 1;

  513. 

  514.     /* remove filter */

  515.     mpegts_close_filter(ts, ts->pat_filter);

  516.     ts->pat_filter = NULL;

  517. }

  518. 

  519. void mpegts_set_service(MpegTSContext *ts, int sid,

  520.                         SetServiceCallback *set_service_cb, void *opaque)

  521. {

  522.     ts->set_service_cb = set_service_cb;

  523.     ts->set_service_opaque = opaque;

  524.     ts->req_sid = sid;

  525.     ts->pat_filter = mpegts_open_section_filter(ts, PAT_PID, 

  526.                                                 pat_cb, ts, 1);

  527. }

  528. 

  529. static void sdt_cb(void *opaque, const uint8_t *section, int section_len)

  530. {

  531.     MpegTSContext *ts = opaque;

  532.     SectionHeader h1, *h = &h1;

  533.     const uint8_t *p, *p_end, *desc_list_end, *desc_end;

  534.     int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type;

  535.     char *name, *provider_name;

  536. 

  537. #ifdef DEBUG_SI

  538.     printf("SDT:\n");

  539.     av_hex_dump((uint8_t *)section, section_len);

  540. #endif

  541. 

  542.     p_end = section + section_len - 4;

  543.     p = section;

  544.     if (parse_section_header(h, &p, p_end) < 0)

  545.         return;

  546.     if (h->tid != SDT_TID)

  547.         return;

  548.     onid = get16(&p, p_end);

  549.     if (onid < 0)

  550.         return;

  551.     val = get8(&p, p_end);

  552.     if (val < 0)

  553.         return;

  554.     for(;;) {

  555.         sid = get16(&p, p_end);

  556.         if (sid < 0)

  557.             break;

  558.         val = get8(&p, p_end);

  559.         if (val < 0)

  560.             break;

  561.         desc_list_len = get16(&p, p_end) & 0xfff;

  562.         if (desc_list_len < 0)

  563.             break;

  564.         desc_list_end = p + desc_list_len;

  565.         if (desc_list_end > p_end)

  566.             break;

  567.         for(;;) {

  568.             desc_tag = get8(&p, desc_list_end);

  569.             if (desc_tag < 0)

  570.                 break;

  571.             desc_len = get8(&p, desc_list_end);

  572.             desc_end = p + desc_len;

  573.             if (desc_end > desc_list_end)

  574.                 break;

  575. #ifdef DEBUG_SI

  576.             printf("tag: 0x%02x len=%d\n", desc_tag, desc_len);

  577. #endif

  578.             switch(desc_tag) {

  579.             case 0x48:

  580.                 service_type = get8(&p, p_end);

  581.                 if (service_type < 0)

  582.                     break;

  583.                 provider_name = getstr8(&p, p_end);

  584.                 if (!provider_name)

  585.                     break;

  586.                 name = getstr8(&p, p_end);

  587.                 if (!name)

  588.                     break;

  589.                 new_service(ts, sid, provider_name, name);

  590.                 break;

  591.             default:

  592.                 break;

  593.             }

  594.             p = desc_end;

  595.         }

  596.         p = desc_list_end;

  597.     }

  598.     ts->stop_parse = 1;

  599. 

  600.     /* remove filter */

  601.     mpegts_close_filter(ts, ts->sdt_filter);

  602.     ts->sdt_filter = NULL;

  603. }

  604. 

  605. /* scan services in a transport stream by looking at the SDT */

  606. void mpegts_scan_sdt(MpegTSContext *ts)

  607. {

  608.     ts->sdt_filter = mpegts_open_section_filter(ts, SDT_PID, 

  609.                                                 sdt_cb, ts, 1);

  610. }

  611. 

  612. /* scan services in a transport stream by looking at the PAT (better

  613.    than nothing !) */

  614. void mpegts_scan_pat(MpegTSContext *ts)

  615. {

  616.     ts->pat_filter = mpegts_open_section_filter(ts, PAT_PID, 

  617.                                                 pat_scan_cb, ts, 1);

  618. }

  619. 

  620. /* TS stream handling */

  621. 

  622. enum MpegTSState {

  623.     MPEGTS_HEADER = 0,

  624.     MPEGTS_PESHEADER_FILL,

  625.     MPEGTS_PAYLOAD,

  626.     MPEGTS_SKIP,

  627. };

  628. 

  629. /* enough for PES header + length */

  630. #define PES_START_SIZE 9

  631. #define MAX_PES_HEADER_SIZE (9 + 255)

  632. 

  633. typedef struct PESContext {

  634.     int pid;

  635.     MpegTSContext *ts;

  636.     AVFormatContext *stream;

  637.     AVStream *st;

  638.     enum MpegTSState state;

  639.     /* used to get the format */

  640.     int data_index;

  641.     int total_size;

  642.     int pes_header_size;

  643.     int64_t pts, dts;

  644.     uint8_t header[MAX_PES_HEADER_SIZE];

  645. } PESContext;

  646. 

  647. static int64_t get_pts(const uint8_t *p)

  648. {

  649.     int64_t pts;

  650.     int val;

  651. 

  652.     pts = (int64_t)((p[0] >> 1) & 0x07) << 30;

  653.     val = (p[1] << 8) | p[2];

  654.     pts |= (int64_t)(val >> 1) << 15;

  655.     val = (p[3] << 8) | p[4];

  656.     pts |= (int64_t)(val >> 1);

  657.     return pts;

  658. }

  659. 

  660. /* return non zero if a packet could be constructed */

  661. static void mpegts_push_data(void *opaque,

  662.                              const uint8_t *buf, int buf_size, int is_start)

  663. {

  664.     PESContext *pes = opaque;

  665.     MpegTSContext *ts = pes->ts;

  666.     AVStream *st;

  667.     const uint8_t *p;

  668.     int len, code, codec_type, codec_id;

  669.     

  670.     if (is_start) {

  671.         pes->state = MPEGTS_HEADER;

  672.         pes->data_index = 0;

  673.     }

  674.     p = buf;

  675.     while (buf_size > 0) {

  676.         switch(pes->state) {

  677.         case MPEGTS_HEADER:

  678.             len = PES_START_SIZE - pes->data_index;

  679.             if (len > buf_size)

  680.                 len = buf_size;

  681.             memcpy(pes->header + pes->data_index, p, len);

  682.             pes->data_index += len;

  683.             p += len;

  684.             buf_size -= len;

  685.             if (pes->data_index == PES_START_SIZE) {

  686.                 /* we got all the PES or section header. We can now

  687.                    decide */

  688. #if 0

  689.                 av_hex_dump(pes->header, pes->data_index);

  690. #endif

  691.                 if (pes->header[0] == 0x00 && pes->header[1] == 0x00 &&

  692.                     pes->header[2] == 0x01) {

  693.                     /* it must be an mpeg2 PES stream */

  694.                     code = pes->header[3] | 0x100;

  695.                     if (!((code >= 0x1c0 && code <= 0x1df) ||

  696.                           (code >= 0x1e0 && code <= 0x1ef) ||

  697.                           (code == 0x1bd)))

  698.                         goto skip;

  699.                     if (!pes->st) {

  700.                         /* allocate stream */

  701.                         if (code >= 0x1c0 && code <= 0x1df) {

  702.                             codec_type = CODEC_TYPE_AUDIO;

  703.                             codec_id = CODEC_ID_MP2;

  704.                         } else if (code == 0x1bd) {

  705.                             codec_type = CODEC_TYPE_AUDIO;

  706.                             codec_id = CODEC_ID_AC3;

  707.                         } else {

  708.                             codec_type = CODEC_TYPE_VIDEO;

  709.                             codec_id = CODEC_ID_MPEG1VIDEO;

  710.                         }

  711.                         st = av_new_stream(pes->stream, pes->pid);

  712.                         if (st) {

  713.                             st->priv_data = pes;

  714.                             st->codec.codec_type = codec_type;

  715.                             st->codec.codec_id = codec_id;

  716.                             st->need_parsing = 1;

  717.                             pes->st = st;

  718.                         }

  719.                     }

  720.                     pes->state = MPEGTS_PESHEADER_FILL;

  721.                     pes->total_size = (pes->header[4] << 8) | pes->header[5];

  722.                     /* NOTE: a zero total size means the PES size is

  723.                        unbounded */

  724.                     if (pes->total_size)

  725.                         pes->total_size += 6;

  726.                     pes->pes_header_size = pes->header[8] + 9;

  727.                 } else {

  728.                     /* otherwise, it should be a table */

  729.                     /* skip packet */

  730.                 skip:

  731.                     pes->state = MPEGTS_SKIP;

  732.                     continue;

  733.                 }

  734.             }

  735.             break;

  736.             /**********************************************/

  737.             /* PES packing parsing */

  738.         case MPEGTS_PESHEADER_FILL:

  739.             len = pes->pes_header_size - pes->data_index;

  740.             if (len > buf_size)

  741.                 len = buf_size;

  742.             memcpy(pes->header + pes->data_index, p, len);

  743.             pes->data_index += len;

  744.             p += len;

  745.             buf_size -= len;

  746.             if (pes->data_index == pes->pes_header_size) {

  747.                 const uint8_t *r;

  748.                 unsigned int flags;

  749. 

  750.                 flags = pes->header[7];

  751.                 r = pes->header + 9;

  752.                 pes->pts = AV_NOPTS_VALUE;

  753.                 pes->dts = AV_NOPTS_VALUE;

  754.                 if ((flags & 0xc0) == 0x80) {

  755.                     pes->pts = get_pts(r);

  756.                     r += 5;

  757.                 } else if ((flags & 0xc0) == 0xc0) {

  758.                     pes->pts = get_pts(r);

  759.                     r += 5;

  760.                     pes->dts = get_pts(r);

  761.                     r += 5;

  762.                 }

  763.                 /* we got the full header. We parse it and get the payload */

  764.                 pes->state = MPEGTS_PAYLOAD;

  765.             }

  766.             break;

  767.         case MPEGTS_PAYLOAD:

  768.             if (pes->total_size) {

  769.                 len = pes->total_size - pes->data_index;

  770.                 if (len > buf_size)

  771.                     len = buf_size;

  772.             } else {

  773.                 len = buf_size;

  774.             }

  775.             if (len > 0) {

  776.                 AVPacket *pkt = ts->pkt;

  777.                 if (pes->st && av_new_packet(pkt, len) == 0) {

  778.                     memcpy(pkt->data, p, len);

  779.                     pkt->stream_index = pes->st->index;

  780.                     pkt->pts = pes->pts;

  781.                     /* reset pts values */

  782.                     pes->pts = AV_NOPTS_VALUE;

  783.                     pes->dts = AV_NOPTS_VALUE;

  784.                     ts->stop_parse = 1;

  785.                     return;

  786.                 }

  787.             }

  788.             buf_size = 0;

  789.             break;

  790.         case MPEGTS_SKIP:

  791.             buf_size = 0;

  792.             break;

  793.         }

  794.     }

  795. }

  796. 

  797. static int add_pes_stream(MpegTSContext *ts, int pid)

  798. {

  799.     MpegTSFilter *tss;

  800.     PESContext *pes;

  801. 

  802.     /* if no pid found, then add a pid context */

  803.     pes = av_mallocz(sizeof(PESContext));

  804.     if (!pes)

  805.         return -1;

  806.     pes->ts = ts;

  807.     pes->stream = ts->stream;

  808.     pes->pid = pid;

  809.     tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes);

  810.     if (!tss) {

  811.         av_free(pes);

  812.         return -1;

  813.     }

  814.     return 0;

  815. }

  816. 

  817. /* handle one TS packet */

  818. static void handle_packet(MpegTSContext *ts, const uint8_t *packet)

  819. {

  820.     AVFormatContext *s = ts->stream;

  821.     MpegTSFilter *tss;

  822.     int len, pid, cc, cc_ok, afc, is_start;

  823.     const uint8_t *p, *p_end;

  824. 

  825.     pid = ((packet[1] & 0x1f) << 8) | packet[2];

  826.     is_start = packet[1] & 0x40;

  827.     tss = ts->pids[pid];

  828.     if (ts->auto_guess && tss == NULL && is_start) {

  829.         add_pes_stream(ts, pid);

  830.         tss = ts->pids[pid];

  831.     }

  832.     if (!tss)

  833.         return;

  834. 

  835.     /* continuity check (currently not used) */

  836.     cc = (packet[3] & 0xf);

  837.     cc_ok = (tss->last_cc < 0) || ((((tss->last_cc + 1) & 0x0f) == cc));

  838.     tss->last_cc = cc;

  839.     

  840.     /* skip adaptation field */

  841.     afc = (packet[3] >> 4) & 3;

  842.     p = packet + 4;

  843.     if (afc == 0) /* reserved value */

  844.         return;

  845.     if (afc == 2) /* adaptation field only */

  846.         return;

  847.     if (afc == 3) {

  848.         /* skip adapation field */

  849.         p += p[0] + 1;

  850.     }

  851.     /* if past the end of packet, ignore */

  852.     p_end = packet + TS_PACKET_SIZE;

  853.     if (p >= p_end)

  854.         return;

  855.     

  856.     if (tss->type == MPEGTS_SECTION) {

  857.         if (is_start) {

  858.             /* pointer field present */

  859.             len = *p++;

  860.             if (p + len > p_end)

  861.                 return;

  862.             if (len && cc_ok) {

  863.                 /* write remaning section bytes */

  864.                 write_section_data(s, tss, 

  865.                                    p, len, 0);

  866.             }

  867.             p += len;

  868.             if (p < p_end) {

  869.                 write_section_data(s, tss, 

  870.                                    p, p_end - p, 1);

  871.             }

  872.         } else {

  873.             if (cc_ok) {

  874.                 write_section_data(s, tss, 

  875.                                    p, p_end - p, 0);

  876.             }

  877.         }

  878.     } else {

  879.         tss->u.pes_filter.pes_cb(tss->u.pes_filter.opaque, 

  880.                                  p, p_end - p, is_start);

  881.     }

  882. }

  883. 

  884. /* XXX: try to find a better synchro over several packets (use

  885.    get_packet_size() ?) */

  886. static int mpegts_resync(ByteIOContext *pb)

  887. {

  888.     int c, i;

  889. 

  890.     for(i = 0;i < MAX_RESYNC_SIZE; i++) {

  891.         c = url_fgetc(pb);

  892.         if (c < 0)

  893.             return -1;

  894.         if (c == 0x47) {

  895.             url_fseek(pb, -1, SEEK_CUR);

  896.             return 0;

  897.         }

  898.     }

  899.     /* no sync found */

  900.     return -1;

  901. }

  902. 

  903. /* return -1 if error or EOF. Return 0 if OK. */

  904. static int read_packet(ByteIOContext *pb, uint8_t *buf, int raw_packet_size)

  905. {

  906.     int skip, len;

  907. 

  908.     for(;;) {

  909.         len = get_buffer(pb, buf, TS_PACKET_SIZE);

  910.         if (len != TS_PACKET_SIZE)

  911.             return AVERROR_IO;

  912.         /* check paquet sync byte */

  913.         if (buf[0] != 0x47) {

  914.             /* find a new packet start */

  915.             url_fseek(pb, -TS_PACKET_SIZE, SEEK_CUR);

  916.             if (mpegts_resync(pb) < 0)

  917.                 return AVERROR_INVALIDDATA;

  918.             else

  919.                 continue;

  920.         } else {

  921.             skip = raw_packet_size - TS_PACKET_SIZE;

  922.             if (skip > 0)

  923.                 url_fskip(pb, skip);

  924.             break;

  925.         }

  926.     }

  927.     return 0;

  928. }

  929. 

  930. static int handle_packets(MpegTSContext *ts, int nb_packets)

  931. {

  932.     AVFormatContext *s = ts->stream;

  933.     ByteIOContext *pb = &s->pb;

  934.     uint8_t packet[TS_PACKET_SIZE];

  935.     int packet_num, ret;

  936. 

  937.     ts->stop_parse = 0;

  938.     packet_num = 0;

  939.     for(;;) {

  940.         if (ts->stop_parse)

  941.             break;

  942.         packet_num++;

  943.         if (nb_packets != 0 && packet_num >= nb_packets)

  944.             break;

  945.         ret = read_packet(pb, packet, ts->raw_packet_size);

  946.         if (ret != 0)

  947.             return ret;

  948.         handle_packet(ts, packet);

  949.     }

  950.     return 0;

  951. }

  952. 

  953. static int mpegts_probe(AVProbeData *p)

  954. {

  955. #if 1

  956.     int size;

  957.     size = get_packet_size(p->buf, p->buf_size);

  958.     if (size < 0)

  959.         return 0;

  960.     return AVPROBE_SCORE_MAX - 1;

  961. #else

  962.     /* only use the extension for safer guess */

  963.     if (match_ext(p->filename, "ts"))

  964.         return AVPROBE_SCORE_MAX;

  965.     else

  966.         return 0;

  967. #endif

  968. }

  969. 

  970. void set_service_cb(void *opaque, int ret)

  971. {

  972.     MpegTSContext *ts = opaque;

  973.     ts->set_service_ret = ret;

  974.     ts->stop_parse = 1;

  975. }

  976. 

  977. /* return the 90 kHz PCR and the extension for the 27 MHz PCR. return

  978.    (-1) if not available */

  979. static int parse_pcr(int64_t *ppcr_high, int *ppcr_low, 

  980.                      const uint8_t *packet)

  981. {

  982.     int afc, len, flags;

  983.     const uint8_t *p;

  984.     unsigned int v;

  985. 

  986.     afc = (packet[3] >> 4) & 3;

  987.     if (afc <= 1)

  988.         return -1;

  989.     p = packet + 4;

  990.     len = p[0];

  991.     p++;

  992.     if (len == 0)

  993.         return -1;

  994.     flags = *p++;

  995.     len--;

  996.     if (!(flags & 0x10))

  997.         return -1;

  998.     if (len < 6)

  999.         return -1;

  1000.     v = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];

  1001.     *ppcr_high = ((int64_t)v << 1) | (p[4] >> 7);

  1002.     *ppcr_low = ((p[4] & 1) << 8) | p[5];

  1003.     return 0;

  1004. }

  1005. 

  1006. static int mpegts_read_header(AVFormatContext *s,

  1007.                               AVFormatParameters *ap)

  1008. {

  1009.     MpegTSContext *ts = s->priv_data;

  1010.     ByteIOContext *pb = &s->pb;

  1011.     uint8_t buf[1024];

  1012.     int len, sid;

  1013.     int64_t pos;

  1014.     MpegTSService *service;

  1015.     

  1016.     if (ap) {

  1017.         ts->mpeg2ts_raw = ap->mpeg2ts_raw;

  1018.         ts->mpeg2ts_compute_pcr = ap->mpeg2ts_compute_pcr;

  1019.     }

  1020. 

  1021.     /* read the first 1024 bytes to get packet size */

  1022.     pos = url_ftell(pb);

  1023.     len = get_buffer(pb, buf, sizeof(buf));

  1024.     if (len != sizeof(buf))

  1025.         goto fail;

  1026.     ts->raw_packet_size = get_packet_size(buf, sizeof(buf));

  1027.     if (ts->raw_packet_size <= 0)

  1028.         goto fail;

  1029.     ts->stream = s;

  1030.     ts->auto_guess = 0;

  1031. 

  1032.     if (!ts->mpeg2ts_raw) {

  1033.         /* normal demux */

  1034. 

  1035.         if (!ts->auto_guess) {

  1036.             ts->set_service_ret = -1;

  1037. 

  1038.             /* first do a scaning to get all the services */

  1039.             url_fseek(pb, pos, SEEK_SET);

  1040.             mpegts_scan_sdt(ts);

  1041.             

  1042.             handle_packets(ts, MAX_SCAN_PACKETS);

  1043.             

  1044.             if (ts->nb_services <= 0) {

  1045.                 /* no SDT found, we try to look at the PAT */

  1046.                 

  1047.                 /* First remove the SDT filters from each PID */

  1048.                 int i;

  1049.                 for (i=0; i < NB_PID_MAX; i++) {

  1050.                     if (ts->pids[i])

  1051.                         mpegts_close_filter(ts, ts->pids[i]);

  1052.                 }

  1053.                 url_fseek(pb, pos, SEEK_SET);

  1054.                 mpegts_scan_pat(ts);

  1055.                 

  1056.                 handle_packets(ts, MAX_SCAN_PACKETS);

  1057.             }

  1058.             

  1059.             if (ts->nb_services <= 0)

  1060.                 return -1;

  1061.             

  1062.             /* tune to first service found */

  1063.             service = ts->services[0];

  1064.             sid = service->sid;

  1065. #ifdef DEBUG_SI

  1066.             printf("tuning to '%s'\n", service->name);

  1067. #endif

  1068.             

  1069.             /* now find the info for the first service if we found any,

  1070.                otherwise try to filter all PATs */

  1071.             

  1072.             url_fseek(pb, pos, SEEK_SET);

  1073.             mpegts_set_service(ts, sid, set_service_cb, ts);

  1074.             

  1075.             handle_packets(ts, MAX_SCAN_PACKETS);

  1076.             

  1077.             /* if could not find service, exit */

  1078.             if (ts->set_service_ret != 0)

  1079.                 return -1;

  1080.             

  1081. #ifdef DEBUG_SI

  1082.             printf("tuning done\n");

  1083. #endif

  1084.         }

  1085.         s->ctx_flags |= AVFMTCTX_NOHEADER;

  1086.     } else {

  1087.         AVStream *st;

  1088.         int pcr_pid, pid, nb_packets, nb_pcrs, ret, pcr_l;

  1089.         int64_t pcrs[2], pcr_h;

  1090.         int packet_count[2];

  1091.         uint8_t packet[TS_PACKET_SIZE];

  1092.         

  1093.         /* only read packets */

  1094. 

  1095.         s->pts_num = 1;

  1096.         s->pts_den = 27000000;

  1097.         

  1098.         st = av_new_stream(s, 0);

  1099.         if (!st)

  1100.             goto fail;

  1101.         st->codec.codec_type = CODEC_TYPE_DATA;

  1102.         st->codec.codec_id = CODEC_ID_MPEG2TS;

  1103.         

  1104.         /* we iterate until we find two PCRs to estimate the bitrate */

  1105.         pcr_pid = -1;

  1106.         nb_pcrs = 0;

  1107.         nb_packets = 0;

  1108.         for(;;) {

  1109.             ret = read_packet(&s->pb, packet, ts->raw_packet_size);

  1110.             if (ret < 0)

  1111.                 return -1;

  1112.             pid = ((packet[1] & 0x1f) << 8) | packet[2];

  1113.             if ((pcr_pid == -1 || pcr_pid == pid) &&

  1114.                 parse_pcr(&pcr_h, &pcr_l, packet) == 0) {

  1115.                 pcr_pid = pid;

  1116.                 packet_count[nb_pcrs] = nb_packets;

  1117.                 pcrs[nb_pcrs] = pcr_h * 300 + pcr_l;

  1118.                 nb_pcrs++;

  1119.                 if (nb_pcrs >= 2)

  1120.                     break;

  1121.             }

  1122.             nb_packets++;

  1123.         }

  1124.         ts->pcr_pid = pcr_pid;

  1125. 

  1126.         /* NOTE1: the bitrate is computed without the FEC */

  1127.         /* NOTE2: it is only the bitrate of the start of the stream */

  1128.         ts->pcr_incr = (pcrs[1] - pcrs[0]) / (packet_count[1] - packet_count[0]);

  1129.         ts->cur_pcr = pcrs[0] - ts->pcr_incr * packet_count[0];

  1130.         s->bit_rate = (TS_PACKET_SIZE * 8) * 27e6 / ts->pcr_incr;

  1131.         st->codec.bit_rate = s->bit_rate;

  1132.         st->start_time = ts->cur_pcr * 1000000.0 / 27.0e6;

  1133. #if 0

  1134.         printf("start=%0.3f pcr=%0.3f incr=%d\n",

  1135.                st->start_time / 1000000.0, pcrs[0] / 27e6, ts->pcr_incr);

  1136. #endif

  1137.     }

  1138. 

  1139.     url_fseek(pb, pos, SEEK_SET);

  1140.     return 0;

  1141.  fail:

  1142.     return -1;

  1143. }

  1144. 

  1145. #define MAX_PACKET_READAHEAD ((128 * 1024) / 188)

  1146. 

  1147. static int mpegts_raw_read_packet(AVFormatContext *s,

  1148.                                   AVPacket *pkt)

  1149. {

  1150.     MpegTSContext *ts = s->priv_data;

  1151.     int ret, i;

  1152.     int64_t pcr_h, next_pcr_h, pos;

  1153.     int pcr_l, next_pcr_l;

  1154.     uint8_t pcr_buf[12];

  1155. 

  1156.     if (av_new_packet(pkt, TS_PACKET_SIZE) < 0)

  1157.         return -ENOMEM;

  1158.     ret = read_packet(&s->pb, pkt->data, ts->raw_packet_size);

  1159.     if (ret < 0) {

  1160.         av_free_packet(pkt);

  1161.         return ret;

  1162.     }

  1163.     if (ts->mpeg2ts_compute_pcr) {

  1164.         /* compute exact PCR for each packet */

  1165.         if (parse_pcr(&pcr_h, &pcr_l, pkt->data) == 0) {

  1166.             /* we read the next PCR (XXX: optimize it by using a bigger buffer */

  1167.             pos = url_ftell(&s->pb);

  1168.             for(i = 0; i < MAX_PACKET_READAHEAD; i++) {

  1169.                 url_fseek(&s->pb, pos + i * ts->raw_packet_size, SEEK_SET);

  1170.                 get_buffer(&s->pb, pcr_buf, 12);

  1171.                 if (parse_pcr(&next_pcr_h, &next_pcr_l, pcr_buf) == 0) {

  1172.                     /* XXX: not precise enough */

  1173.                     ts->pcr_incr = ((next_pcr_h - pcr_h) * 300 + (next_pcr_l - pcr_l)) / 

  1174.                         (i + 1);

  1175.                     break;

  1176.                 }

  1177.             }

  1178.             url_fseek(&s->pb, pos, SEEK_SET);

  1179.             /* no next PCR found: we use previous increment */

  1180.             ts->cur_pcr = pcr_h * 300 + pcr_l;

  1181.         }

  1182.         pkt->pts = ts->cur_pcr;

  1183.         pkt->duration = ts->pcr_incr;

  1184.         ts->cur_pcr += ts->pcr_incr;

  1185.     }

  1186.     pkt->stream_index = 0;

  1187.     return 0;

  1188. }

  1189. 

  1190. static int mpegts_read_packet(AVFormatContext *s,

  1191.                               AVPacket *pkt)

  1192. {

  1193.     MpegTSContext *ts = s->priv_data;

  1194. 

  1195.     if (!ts->mpeg2ts_raw) {

  1196.         ts->pkt = pkt;

  1197.         return handle_packets(ts, 0);

  1198.     } else {

  1199.         return mpegts_raw_read_packet(s, pkt);

  1200.     }

  1201. }

  1202. 

  1203. static int mpegts_read_close(AVFormatContext *s)

  1204. {

  1205.     MpegTSContext *ts = s->priv_data;

  1206.     int i;

  1207.     for(i=0;i<NB_PID_MAX;i++)

  1208.         av_free(ts->pids[i]);

  1209.     return 0;

  1210. }

  1211. 

  1212. static int64_t mpegts_get_pcr(AVFormatContext *s, int stream_index, 

  1213.                               int64_t *ppos, int find_next)

  1214. {

  1215.     MpegTSContext *ts = s->priv_data;

  1216.     int64_t pos, timestamp;

  1217.     uint8_t buf[TS_PACKET_SIZE];

  1218.     int pcr_l, pid;

  1219. 

  1220.     pos = *ppos;

  1221.     if (find_next) {

  1222.         for(;;) {

  1223.             url_fseek(&s->pb, pos, SEEK_SET);

  1224.             if (get_buffer(&s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)

  1225.                 return AV_NOPTS_VALUE;

  1226.             pid = ((buf[1] & 0x1f) << 8) | buf[2];

  1227.             if (pid == ts->pcr_pid &&

  1228.                 parse_pcr(&timestamp, &pcr_l, buf) == 0) {

  1229.                 break;

  1230.             }

  1231.             pos += ts->raw_packet_size;

  1232.         }

  1233.     } else {

  1234.         for(;;) {

  1235.             pos -= ts->raw_packet_size;

  1236.             if (pos < 0)

  1237.                 return AV_NOPTS_VALUE;

  1238.             url_fseek(&s->pb, pos, SEEK_SET);

  1239.             if (get_buffer(&s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)

  1240.                 return AV_NOPTS_VALUE;

  1241.             pid = ((buf[1] & 0x1f) << 8) | buf[2];

  1242.             if (pid == ts->pcr_pid &&

  1243.                 parse_pcr(&timestamp, &pcr_l, buf) == 0) {

  1244.                 break;

  1245.             }

  1246.         }

  1247.     }

  1248.     *ppos = pos;

  1249.     return timestamp;

  1250. }

  1251. 

  1252. typedef int64_t ReadTimestampFunc(AVFormatContext *s, int stream_index, 

  1253.                                   int64_t *ppos, int find_next);

  1254. 

  1255. static int64_t do_block_align(int64_t val, int block_align)

  1256. {

  1257.     return (val / block_align) * block_align;

  1258. }

  1259. 

  1260. /* XXX: use it in other formats */

  1261. static int timestamp_read_seek(AVFormatContext *s, 

  1262.                                int stream_index, int64_t timestamp,

  1263.                                ReadTimestampFunc *read_timestamp,

  1264.                                int block_align)

  1265. {

  1266.     int64_t pos_min, pos_max, pos;

  1267.     int64_t dts_min, dts_max, dts;

  1268. 

  1269. #ifdef DEBUG_SEEK

  1270.     printf("read_seek: %d %0.3f\n", stream_index, timestamp / 90000.0);

  1271. #endif

  1272. 

  1273.     pos_min = 0;

  1274.     dts_min = read_timestamp(s, stream_index, &pos_min, 1);

  1275.     if (dts_min == AV_NOPTS_VALUE) {

  1276.         /* we can reach this case only if no PTS are present in

  1277.            the whole stream */

  1278.         return -1;

  1279.     }

  1280.     pos_max = do_block_align(url_filesize(url_fileno(&s->pb)), block_align) - 

  1281.         block_align;

  1282.     dts_max = read_timestamp(s, stream_index, &pos_max, 0);

  1283.     

  1284.     while (pos_min <= pos_max) {

  1285. #ifdef DEBUG_SEEK

  1286.         printf("pos_min=0x%llx pos_max=0x%llx dts_min=%0.3f dts_max=%0.3f\n", 

  1287.                pos_min, pos_max,

  1288.                dts_min / 90000.0, dts_max / 90000.0);

  1289. #endif

  1290.         if (timestamp <= dts_min) {

  1291.             pos = pos_min;

  1292.             goto found;

  1293.         } else if (timestamp >= dts_max) {

  1294.             pos = pos_max;

  1295.             goto found;

  1296.         } else {

  1297.             /* interpolate position (better than dichotomy) */

  1298.             pos = (int64_t)((double)(pos_max - pos_min) * 

  1299.                             (double)(timestamp - dts_min) /

  1300.                             (double)(dts_max - dts_min)) + pos_min;

  1301.             pos = do_block_align(pos, block_align);

  1302.         }

  1303. #ifdef DEBUG_SEEK

  1304.         printf("pos=0x%llx\n", pos);

  1305. #endif

  1306.         /* read the next timestamp */

  1307.         dts = read_timestamp(s, stream_index, &pos, 1);

  1308.         /* check if we are lucky */

  1309.         if (dts == AV_NOPTS_VALUE) {

  1310.             /* should never happen */

  1311.             pos = pos_min;

  1312.             goto found;

  1313.         } else if (timestamp == dts) {

  1314.             goto found;

  1315.         } else if (timestamp < dts) {

  1316.             pos_max = pos;

  1317.             dts_max = read_timestamp(s, stream_index, &pos_max, 0);

  1318.             if (dts_max == AV_NOPTS_VALUE) {

  1319.                 /* should never happen */

  1320.                 break;

  1321.             } else if (timestamp >= dts_max) {

  1322.                 pos = pos_max;

  1323.                 goto found;

  1324.             }

  1325.         } else {

  1326.             pos_min = pos + block_align;

  1327.             dts_min = read_timestamp(s, stream_index, &pos_min, 1);

  1328.             if (dts_min == AV_NOPTS_VALUE) {

  1329.                 /* should never happen */

  1330.                 goto found;

  1331.             } else if (timestamp <= dts_min) {

  1332.                 goto found;

  1333.             }

  1334.         }

  1335.     }

  1336.     pos = pos_min;

  1337.  found:

  1338. #ifdef DEBUG_SEEK

  1339.     pos_min = pos;

  1340.     dts_min = read_timestamp(s, stream_index, &pos_min, 1);

  1341.     pos_min += block_align;

  1342.     dts_max = read_timestamp(s, stream_index, &pos_min, 1);

  1343.     printf("pos=0x%llx %0.3f<=%0.3f<=%0.3f\n", 

  1344.            pos, dts_min / 90000.0, timestamp / 90000.0, dts_max / 90000.0);

  1345. #endif

  1346.     /* do the seek */

  1347.     url_fseek(&s->pb, pos, SEEK_SET);

  1348.     return 0;

  1349. }

  1350. 

  1351. static int mpegts_read_seek(AVFormatContext *s, 

  1352.                             int stream_index, int64_t timestamp)

  1353. {

  1354.     MpegTSContext *ts = s->priv_data;

  1355. 

  1356.     timestamp = (timestamp * 90000) / AV_TIME_BASE;

  1357. 

  1358.     return timestamp_read_seek(s, stream_index, timestamp, 

  1359.                                mpegts_get_pcr, ts->raw_packet_size);

  1360. }

  1361. 

  1362. /**************************************************************/

  1363. /* parsing functions - called from other demuxers such as RTP */

  1364. 

  1365. MpegTSContext *mpegts_parse_open(AVFormatContext *s)

  1366. {

  1367.     MpegTSContext *ts;

  1368.     

  1369.     ts = av_mallocz(sizeof(MpegTSContext));

  1370.     if (!ts)

  1371.         return NULL;

  1372.     /* no stream case, currently used by RTP */

  1373.     ts->raw_packet_size = TS_PACKET_SIZE;

  1374.     ts->stream = s;

  1375.     ts->auto_guess = 1;

  1376.     return ts;

  1377. }

  1378. 

  1379. /* return the consumed length if a packet was output, or -1 if no

  1380.    packet is output */

  1381. int mpegts_parse_packet(MpegTSContext *ts, AVPacket *pkt,

  1382.                         const uint8_t *buf, int len)

  1383. {

  1384.     int len1;

  1385. 

  1386.     len1 = len;

  1387.     ts->pkt = pkt;

  1388.     ts->stop_parse = 0;

  1389.     for(;;) {

  1390.         if (ts->stop_parse)

  1391.             break;

  1392.         if (len < TS_PACKET_SIZE)

  1393.             return -1;

  1394.         if (buf[0] != 0x47) {

  1395.             buf--;

  1396.             len--;

  1397.         } else {

  1398.             handle_packet(ts, buf);

  1399.             buf += TS_PACKET_SIZE;

  1400.             len -= TS_PACKET_SIZE;

  1401.         }

  1402.     }

  1403.     return len1 - len;

  1404. }

  1405. 

  1406. void mpegts_parse_close(MpegTSContext *ts)

  1407. {

  1408.     int i;

  1409. 

  1410.     for(i=0;i<NB_PID_MAX;i++)

  1411.         av_free(ts->pids[i]);

  1412.     av_free(ts);

  1413. }

  1414. 

  1415. AVInputFormat mpegts_demux = {

  1416.     "mpegts",

  1417.     "MPEG2 transport stream format",

  1418.     sizeof(MpegTSContext),

  1419.     mpegts_probe,

  1420.     mpegts_read_header,

  1421.     mpegts_read_packet,

  1422.     mpegts_read_close,

  1423.     mpegts_read_seek,

  1424.     .flags = AVFMT_SHOW_IDS,

  1425. };

  1426. 

  1427. int mpegts_init(void)

  1428. {

  1429.     av_register_input_format(&mpegts_demux);

  1430. #ifdef CONFIG_ENCODERS

  1431.     av_register_output_format(&mpegts_mux);

  1432. #endif

  1433.     return 0;

  1434. }