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.
3964 Commits
32 Branches
511MB
Tree: 35ef76b51c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '35ef76b51c'
${ noResults }
FFmpeg/libavformat/mpegts.c

1431 lines
41KB
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, 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.     else if (filter->type == MPEGTS_PES)

  218.         av_freep(&filter->u.pes_filter.opaque);

  219. 

  220.     av_free(filter);

  221.     ts->pids[pid] = NULL;

  222. }

  223. 

  224. static int analyze(const uint8_t *buf, int size, int packet_size, int *index){

  225.     int stat[packet_size];

  226.     int i;

  227.     int x=0;

  228.     int best_score=0;

  229. 

  230.     memset(stat, 0, packet_size*sizeof(int));

  231. 

  232.     for(x=i=0; i<size; i++){

  233.         if(buf[i] == 0x47){

  234.             stat[x]++;

  235.             if(stat[x] > best_score){

  236.                 best_score= stat[x];

  237.                 if(index) *index= x;

  238.             }

  239.         }

  240. 

  241.         x++;

  242.         if(x == packet_size) x= 0;

  243.     }

  244. 

  245.     return best_score;

  246. }

  247. 

  248. /* autodetect fec presence. Must have at least 1024 bytes  */

  249. static int get_packet_size(const uint8_t *buf, int size)

  250. {

  251.     int score, fec_score;

  252. 

  253.     if (size < (TS_FEC_PACKET_SIZE * 5 + 1))

  254.         return -1;

  255.         

  256.     score    = analyze(buf, size, TS_PACKET_SIZE, NULL);

  257.     fec_score= analyze(buf, size, TS_FEC_PACKET_SIZE, NULL);

  258. //    av_log(NULL, AV_LOG_DEBUG, "score: %d, fec_score: %d \n", score, fec_score);

  259.     

  260.     if     (score > fec_score) return TS_PACKET_SIZE;

  261.     else if(score < fec_score) return TS_FEC_PACKET_SIZE;

  262.     else                       return -1;

  263. }

  264. 

  265. typedef struct SectionHeader {

  266.     uint8_t tid;

  267.     uint16_t id;

  268.     uint8_t version;

  269.     uint8_t sec_num;

  270.     uint8_t last_sec_num;

  271. } SectionHeader;

  272. 

  273. static inline int get8(const uint8_t **pp, const uint8_t *p_end)

  274. {

  275.     const uint8_t *p;

  276.     int c;

  277. 

  278.     p = *pp;

  279.     if (p >= p_end)

  280.         return -1;

  281.     c = *p++;

  282.     *pp = p;

  283.     return c;

  284. }

  285. 

  286. static inline int get16(const uint8_t **pp, const uint8_t *p_end)

  287. {

  288.     const uint8_t *p;

  289.     int c;

  290. 

  291.     p = *pp;

  292.     if ((p + 1) >= p_end)

  293.         return -1;

  294.     c = (p[0] << 8) | p[1];

  295.     p += 2;

  296.     *pp = p;

  297.     return c;

  298. }

  299. 

  300. /* read and allocate a DVB string preceeded by its length */

  301. static char *getstr8(const uint8_t **pp, const uint8_t *p_end)

  302. {

  303.     int len;

  304.     const uint8_t *p;

  305.     char *str;

  306. 

  307.     p = *pp;

  308.     len = get8(&p, p_end);

  309.     if (len < 0)

  310.         return NULL;

  311.     if ((p + len) > p_end)

  312.         return NULL;

  313.     str = av_malloc(len + 1);

  314.     if (!str)

  315.         return NULL;

  316.     memcpy(str, p, len);

  317.     str[len] = '\0';

  318.     p += len;

  319.     *pp = p;

  320.     return str;

  321. }

  322. 

  323. static int parse_section_header(SectionHeader *h, 

  324.                                 const uint8_t **pp, const uint8_t *p_end)

  325. {

  326.     int val;

  327. 

  328.     val = get8(pp, p_end);

  329.     if (val < 0)

  330.         return -1;

  331.     h->tid = val;

  332.     *pp += 2;

  333.     val = get16(pp, p_end);

  334.     if (val < 0)

  335.         return -1;

  336.     h->id = val;

  337.     val = get8(pp, p_end);

  338.     if (val < 0)

  339.         return -1;

  340.     h->version = (val >> 1) & 0x1f;

  341.     val = get8(pp, p_end);

  342.     if (val < 0)

  343.         return -1;

  344.     h->sec_num = val;

  345.     val = get8(pp, p_end);

  346.     if (val < 0)

  347.         return -1;

  348.     h->last_sec_num = val;

  349.     return 0;

  350. }

  351. 

  352. static MpegTSService *new_service(MpegTSContext *ts, int sid, 

  353.                                   char *provider_name, char *name)

  354. {

  355.     MpegTSService *service;

  356. 

  357. #ifdef DEBUG_SI

  358.     printf("new_service: sid=0x%04x provider='%s' name='%s'\n", 

  359.            sid, provider_name, name);

  360. #endif

  361. 

  362.     service = av_mallocz(sizeof(MpegTSService));

  363.     if (!service)

  364.         return NULL;

  365.     service->sid = sid;

  366.     service->provider_name = provider_name;

  367.     service->name = name;

  368.     dynarray_add(&ts->services, &ts->nb_services, service);

  369.     return service;

  370. }

  371. 

  372. static void pmt_cb(void *opaque, const uint8_t *section, int section_len)

  373. {

  374.     MpegTSContext *ts = opaque;

  375.     SectionHeader h1, *h = &h1;

  376.     const uint8_t *p, *p_end;

  377.     int program_info_length, pcr_pid, pid, stream_type, desc_length;

  378.     

  379. #ifdef DEBUG_SI

  380.     printf("PMT:\n");

  381.     av_hex_dump(stdout, (uint8_t *)section, section_len);

  382. #endif

  383.     p_end = section + section_len - 4;

  384.     p = section;

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

  386.         return;

  387. #ifdef DEBUG_SI

  388.     printf("sid=0x%x sec_num=%d/%d\n", h->id, h->sec_num, h->last_sec_num);

  389. #endif

  390.     if (h->tid != PMT_TID || (ts->req_sid >= 0 && h->id != ts->req_sid) )

  391.         return;

  392. 

  393.     pcr_pid = get16(&p, p_end) & 0x1fff;

  394.     if (pcr_pid < 0)

  395.         return;

  396.     ts->pcr_pid = pcr_pid;

  397. #ifdef DEBUG_SI

  398.     printf("pcr_pid=0x%x\n", pcr_pid);

  399. #endif

  400.     program_info_length = get16(&p, p_end) & 0xfff;

  401.     if (program_info_length < 0)

  402.         return;

  403.     p += program_info_length;

  404.     if (p >= p_end)

  405.         return;

  406.     for(;;) {

  407.         stream_type = get8(&p, p_end);

  408.         if (stream_type < 0)

  409.             break;

  410.         pid = get16(&p, p_end) & 0x1fff;

  411.         if (pid < 0)

  412.             break;

  413.         desc_length = get16(&p, p_end) & 0xfff;

  414.         if (desc_length < 0)

  415.             break;

  416.         p += desc_length;

  417.         if (p > p_end)

  418.             return;

  419. 

  420. #ifdef DEBUG_SI

  421.         printf("stream_type=%d pid=0x%x\n", stream_type, pid);

  422. #endif

  423. 

  424.         /* now create ffmpeg stream */

  425.         switch(stream_type) {

  426.         case STREAM_TYPE_AUDIO_MPEG1:

  427.         case STREAM_TYPE_AUDIO_MPEG2:

  428.         case STREAM_TYPE_VIDEO_MPEG1:

  429.         case STREAM_TYPE_VIDEO_MPEG2:

  430.         case STREAM_TYPE_VIDEO_MPEG4:

  431.         case STREAM_TYPE_VIDEO_H264:

  432.         case STREAM_TYPE_AUDIO_AAC:

  433.         case STREAM_TYPE_AUDIO_AC3:

  434.         case STREAM_TYPE_AUDIO_DTS:

  435.             add_pes_stream(ts, pid, stream_type);

  436.             break;

  437.         default:

  438.             /* we ignore the other streams */

  439.             break;

  440.         }

  441.     }

  442.     /* all parameters are there */

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

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

  445.     ts->pmt_filter = NULL;

  446. }

  447. 

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

  449. {

  450.     MpegTSContext *ts = opaque;

  451.     SectionHeader h1, *h = &h1;

  452.     const uint8_t *p, *p_end;

  453.     int sid, pmt_pid;

  454. 

  455. #ifdef DEBUG_SI

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

  457.     av_hex_dump(stdout, (uint8_t *)section, section_len);

  458. #endif

  459.     p_end = section + section_len - 4;

  460.     p = section;

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

  462.         return;

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

  464.         return;

  465. 

  466.     for(;;) {

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

  468.         if (sid < 0)

  469.             break;

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

  471.         if (pmt_pid < 0)

  472.             break;

  473. #ifdef DEBUG_SI

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

  475. #endif

  476.         if (sid == 0x0000) {

  477.             /* NIT info */

  478.         } else {

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

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

  481.                                                             pmt_cb, ts, 1);

  482.                 goto found;

  483.             }

  484.         }

  485.     }

  486.     /* not found */

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

  488. 

  489.  found:

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

  491.     ts->pat_filter = NULL;

  492. }

  493. 

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

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

  496. {

  497.     MpegTSContext *ts = opaque;

  498.     SectionHeader h1, *h = &h1;

  499.     const uint8_t *p, *p_end;

  500.     int sid, pmt_pid;

  501.     char *provider_name, *name;

  502.     char buf[256];

  503. 

  504. #ifdef DEBUG_SI

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

  506.     av_hex_dump(stdout, (uint8_t *)section, section_len);

  507. #endif

  508.     p_end = section + section_len - 4;

  509.     p = section;

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

  511.         return;

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

  513.         return;

  514. 

  515.     for(;;) {

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

  517.         if (sid < 0)

  518.             break;

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

  520.         if (pmt_pid < 0)

  521.             break;

  522. #ifdef DEBUG_SI

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

  524. #endif

  525.         if (sid == 0x0000) {

  526.             /* NIT info */

  527.         } else {

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

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

  530.             name = av_strdup(buf);

  531.             provider_name = av_strdup("");

  532.             if (name && provider_name) {

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

  534.             } else {

  535.                 av_freep(&name);

  536.                 av_freep(&provider_name);

  537.             }

  538.         }

  539.     }

  540.     ts->stop_parse = 1;

  541. 

  542.     /* remove filter */

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

  544.     ts->pat_filter = NULL;

  545. }

  546. 

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

  548.                         SetServiceCallback *set_service_cb, void *opaque)

  549. {

  550.     ts->set_service_cb = set_service_cb;

  551.     ts->set_service_opaque = opaque;

  552.     ts->req_sid = sid;

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

  554.                                                 pat_cb, ts, 1);

  555. }

  556. 

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

  558. {

  559.     MpegTSContext *ts = opaque;

  560.     SectionHeader h1, *h = &h1;

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

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

  563.     char *name, *provider_name;

  564. 

  565. #ifdef DEBUG_SI

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

  567.     av_hex_dump(stdout, (uint8_t *)section, section_len);

  568. #endif

  569. 

  570.     p_end = section + section_len - 4;

  571.     p = section;

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

  573.         return;

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

  575.         return;

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

  577.     if (onid < 0)

  578.         return;

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

  580.     if (val < 0)

  581.         return;

  582.     for(;;) {

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

  584.         if (sid < 0)

  585.             break;

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

  587.         if (val < 0)

  588.             break;

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

  590.         if (desc_list_len < 0)

  591.             break;

  592.         desc_list_end = p + desc_list_len;

  593.         if (desc_list_end > p_end)

  594.             break;

  595.         for(;;) {

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

  597.             if (desc_tag < 0)

  598.                 break;

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

  600.             desc_end = p + desc_len;

  601.             if (desc_end > desc_list_end)

  602.                 break;

  603. #ifdef DEBUG_SI

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

  605. #endif

  606.             switch(desc_tag) {

  607.             case 0x48:

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

  609.                 if (service_type < 0)

  610.                     break;

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

  612.                 if (!provider_name)

  613.                     break;

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

  615.                 if (!name)

  616.                     break;

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

  618.                 break;

  619.             default:

  620.                 break;

  621.             }

  622.             p = desc_end;

  623.         }

  624.         p = desc_list_end;

  625.     }

  626.     ts->stop_parse = 1;

  627. 

  628.     /* remove filter */

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

  630.     ts->sdt_filter = NULL;

  631. }

  632. 

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

  634. void mpegts_scan_sdt(MpegTSContext *ts)

  635. {

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

  637.                                                 sdt_cb, ts, 1);

  638. }

  639. 

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

  641.    than nothing !) */

  642. void mpegts_scan_pat(MpegTSContext *ts)

  643. {

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

  645.                                                 pat_scan_cb, ts, 1);

  646. }

  647. 

  648. /* TS stream handling */

  649. 

  650. enum MpegTSState {

  651.     MPEGTS_HEADER = 0,

  652.     MPEGTS_PESHEADER_FILL,

  653.     MPEGTS_PAYLOAD,

  654.     MPEGTS_SKIP,

  655. };

  656. 

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

  658. #define PES_START_SIZE 9

  659. #define MAX_PES_HEADER_SIZE (9 + 255)

  660. 

  661. typedef struct PESContext {

  662.     int pid;

  663.     int stream_type;

  664.     MpegTSContext *ts;

  665.     AVFormatContext *stream;

  666.     AVStream *st;

  667.     enum MpegTSState state;

  668.     /* used to get the format */

  669.     int data_index;

  670.     int total_size;

  671.     int pes_header_size;

  672.     int64_t pts, dts;

  673.     uint8_t header[MAX_PES_HEADER_SIZE];

  674. } PESContext;

  675. 

  676. static int64_t get_pts(const uint8_t *p)

  677. {

  678.     int64_t pts;

  679.     int val;

  680. 

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

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

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

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

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

  686.     return pts;

  687. }

  688. 

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

  690. static void mpegts_push_data(void *opaque,

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

  692. {

  693.     PESContext *pes = opaque;

  694.     MpegTSContext *ts = pes->ts;

  695.     AVStream *st;

  696.     const uint8_t *p;

  697.     int len, code, codec_type, codec_id;

  698.     

  699.     if (is_start) {

  700.         pes->state = MPEGTS_HEADER;

  701.         pes->data_index = 0;

  702.     }

  703.     p = buf;

  704.     while (buf_size > 0) {

  705.         switch(pes->state) {

  706.         case MPEGTS_HEADER:

  707.             len = PES_START_SIZE - pes->data_index;

  708.             if (len > buf_size)

  709.                 len = buf_size;

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

  711.             pes->data_index += len;

  712.             p += len;

  713.             buf_size -= len;

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

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

  716.                    decide */

  717. #if 0

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

  719. #endif

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

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

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

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

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

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

  726.                           (code == 0x1bd)))

  727.                         goto skip;

  728.                     if (!pes->st) {

  729.                         /* allocate stream */

  730.                         switch(pes->stream_type){

  731.                         case STREAM_TYPE_AUDIO_MPEG1:

  732.                         case STREAM_TYPE_AUDIO_MPEG2:

  733.                             codec_type = CODEC_TYPE_AUDIO;

  734.                             codec_id = CODEC_ID_MP3;

  735.                             break;

  736.                         case STREAM_TYPE_VIDEO_MPEG1:

  737.                         case STREAM_TYPE_VIDEO_MPEG2:

  738.                             codec_type = CODEC_TYPE_VIDEO;

  739.                             codec_id = CODEC_ID_MPEG2VIDEO;

  740.                             break;

  741.                         case STREAM_TYPE_VIDEO_MPEG4:

  742.                             codec_type = CODEC_TYPE_VIDEO;

  743.                             codec_id = CODEC_ID_MPEG4;

  744.                             break;

  745.                         case STREAM_TYPE_VIDEO_H264:

  746.                             codec_type = CODEC_TYPE_VIDEO;

  747.                             codec_id = CODEC_ID_H264;

  748.                             break;

  749.                         case STREAM_TYPE_AUDIO_AAC:

  750.                             codec_type = CODEC_TYPE_AUDIO;

  751.                             codec_id = CODEC_ID_AAC;

  752.                             break;

  753.                         case STREAM_TYPE_AUDIO_AC3:

  754.                             codec_type = CODEC_TYPE_AUDIO;

  755.                             codec_id = CODEC_ID_AC3;

  756.                             break;

  757.                         case STREAM_TYPE_AUDIO_DTS:

  758.                             codec_type = CODEC_TYPE_AUDIO;

  759.                             codec_id = CODEC_ID_DTS;

  760.                             break;

  761.                         default:

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

  763.                                 codec_type = CODEC_TYPE_AUDIO;

  764.                                 codec_id = CODEC_ID_MP2;

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

  766.                                 codec_type = CODEC_TYPE_AUDIO;

  767.                                 codec_id = CODEC_ID_AC3;

  768.                             } else {

  769.                                 codec_type = CODEC_TYPE_VIDEO;

  770.                                 codec_id = CODEC_ID_MPEG1VIDEO;

  771.                             }

  772.                             break;

  773.                         }

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

  775.                         if (st) {

  776.                             av_set_pts_info(st, 60, 1, 90000);

  777.                             st->priv_data = pes;

  778.                             st->codec.codec_type = codec_type;

  779.                             st->codec.codec_id = codec_id;

  780.                             st->need_parsing = 1;

  781.                             pes->st = st;

  782.                         }

  783.                     }

  784.                     pes->state = MPEGTS_PESHEADER_FILL;

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

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

  787.                        unbounded */

  788.                     if (pes->total_size)

  789.                         pes->total_size += 6;

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

  791.                 } else {

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

  793.                     /* skip packet */

  794.                 skip:

  795.                     pes->state = MPEGTS_SKIP;

  796.                     continue;

  797.                 }

  798.             }

  799.             break;

  800.             /**********************************************/

  801.             /* PES packing parsing */

  802.         case MPEGTS_PESHEADER_FILL:

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

  804.             if (len > buf_size)

  805.                 len = buf_size;

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

  807.             pes->data_index += len;

  808.             p += len;

  809.             buf_size -= len;

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

  811.                 const uint8_t *r;

  812.                 unsigned int flags;

  813. 

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

  815.                 r = pes->header + 9;

  816.                 pes->pts = AV_NOPTS_VALUE;

  817.                 pes->dts = AV_NOPTS_VALUE;

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

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

  820.                     r += 5;

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

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

  823.                     r += 5;

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

  825.                     r += 5;

  826.                 }

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

  828.                 pes->state = MPEGTS_PAYLOAD;

  829.             }

  830.             break;

  831.         case MPEGTS_PAYLOAD:

  832.             if (pes->total_size) {

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

  834.                 if (len > buf_size)

  835.                     len = buf_size;

  836.             } else {

  837.                 len = buf_size;

  838.             }

  839.             if (len > 0) {

  840.                 AVPacket *pkt = ts->pkt;

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

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

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

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

  845.                     pkt->dts = pes->dts;

  846.                     /* reset pts values */

  847.                     pes->pts = AV_NOPTS_VALUE;

  848.                     pes->dts = AV_NOPTS_VALUE;

  849.                     ts->stop_parse = 1;

  850.                     return;

  851.                 }

  852.             }

  853.             buf_size = 0;

  854.             break;

  855.         case MPEGTS_SKIP:

  856.             buf_size = 0;

  857.             break;

  858.         }

  859.     }

  860. }

  861. 

  862. static int add_pes_stream(MpegTSContext *ts, int pid, int stream_type)

  863. {

  864.     MpegTSFilter *tss;

  865.     PESContext *pes;

  866. 

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

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

  869.     if (!pes)

  870.         return -1;

  871.     pes->ts = ts;

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

  873.     pes->pid = pid;

  874.     pes->stream_type = stream_type;

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

  876.     if (!tss) {

  877.         av_free(pes);

  878.         return -1;

  879.     }

  880.     return 0;

  881. }

  882. 

  883. /* handle one TS packet */

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

  885. {

  886.     AVFormatContext *s = ts->stream;

  887.     MpegTSFilter *tss;

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

  889.     const uint8_t *p, *p_end;

  890. 

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

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

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

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

  895.         add_pes_stream(ts, pid, 0);

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

  897.     }

  898.     if (!tss)

  899.         return;

  900. 

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

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

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

  904.     tss->last_cc = cc;

  905.     

  906.     /* skip adaptation field */

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

  908.     p = packet + 4;

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

  910.         return;

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

  912.         return;

  913.     if (afc == 3) {

  914.         /* skip adapation field */

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

  916.     }

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

  918.     p_end = packet + TS_PACKET_SIZE;

  919.     if (p >= p_end)

  920.         return;

  921.     

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

  923.         if (is_start) {

  924.             /* pointer field present */

  925.             len = *p++;

  926.             if (p + len > p_end)

  927.                 return;

  928.             if (len && cc_ok) {

  929.                 /* write remaning section bytes */

  930.                 write_section_data(s, tss, 

  931.                                    p, len, 0);

  932.             }

  933.             p += len;

  934.             if (p < p_end) {

  935.                 write_section_data(s, tss, 

  936.                                    p, p_end - p, 1);

  937.             }

  938.         } else {

  939.             if (cc_ok) {

  940.                 write_section_data(s, tss, 

  941.                                    p, p_end - p, 0);

  942.             }

  943.         }

  944.     } else {

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

  946.                                  p, p_end - p, is_start);

  947.     }

  948. }

  949. 

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

  951.    get_packet_size() ?) */

  952. static int mpegts_resync(ByteIOContext *pb)

  953. {

  954.     int c, i;

  955. 

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

  957.         c = url_fgetc(pb);

  958.         if (c < 0)

  959.             return -1;

  960.         if (c == 0x47) {

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

  962.             return 0;

  963.         }

  964.     }

  965.     /* no sync found */

  966.     return -1;

  967. }

  968. 

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

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

  971. {

  972.     int skip, len;

  973. 

  974.     for(;;) {

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

  976.         if (len != TS_PACKET_SIZE)

  977.             return AVERROR_IO;

  978.         /* check paquet sync byte */

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

  980.             /* find a new packet start */

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

  982.             if (mpegts_resync(pb) < 0)

  983.                 return AVERROR_INVALIDDATA;

  984.             else

  985.                 continue;

  986.         } else {

  987.             skip = raw_packet_size - TS_PACKET_SIZE;

  988.             if (skip > 0)

  989.                 url_fskip(pb, skip);

  990.             break;

  991.         }

  992.     }

  993.     return 0;

  994. }

  995. 

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

  997. {

  998.     AVFormatContext *s = ts->stream;

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

  1000.     uint8_t packet[TS_PACKET_SIZE];

  1001.     int packet_num, ret;

  1002. 

  1003.     ts->stop_parse = 0;

  1004.     packet_num = 0;

  1005.     for(;;) {

  1006.         if (ts->stop_parse)

  1007.             break;

  1008.         packet_num++;

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

  1010.             break;

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

  1012.         if (ret != 0)

  1013.             return ret;

  1014.         handle_packet(ts, packet);

  1015.     }

  1016.     return 0;

  1017. }

  1018. 

  1019. static int mpegts_probe(AVProbeData *p)

  1020. {

  1021. #if 1

  1022.     const int size= p->buf_size;

  1023.     int score, fec_score;

  1024. #define CHECK_COUNT 10

  1025.     

  1026.     if (size < (TS_FEC_PACKET_SIZE * CHECK_COUNT))

  1027.         return -1;

  1028.     

  1029.     score    = analyze(p->buf, TS_PACKET_SIZE    *CHECK_COUNT, TS_PACKET_SIZE, NULL);

  1030.     fec_score= analyze(p->buf, TS_FEC_PACKET_SIZE*CHECK_COUNT, TS_FEC_PACKET_SIZE, NULL);

  1031. //    av_log(NULL, AV_LOG_DEBUG, "score: %d, fec_score: %d \n", score, fec_score);

  1032.   

  1033. // we need a clear definition for the returned score otherwise things will become messy sooner or later

  1034.     if     (score > fec_score && score > 6) return AVPROBE_SCORE_MAX + score     - CHECK_COUNT;

  1035.     else if(                 fec_score > 6) return AVPROBE_SCORE_MAX + fec_score - CHECK_COUNT;

  1036.     else                                    return -1;

  1037. #else

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

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

  1040.         return AVPROBE_SCORE_MAX;

  1041.     else

  1042.         return 0;

  1043. #endif

  1044. }

  1045. 

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

  1047. {

  1048.     MpegTSContext *ts = opaque;

  1049.     ts->set_service_ret = ret;

  1050.     ts->stop_parse = 1;

  1051. }

  1052. 

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

  1054.    (-1) if not available */

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

  1056.                      const uint8_t *packet)

  1057. {

  1058.     int afc, len, flags;

  1059.     const uint8_t *p;

  1060.     unsigned int v;

  1061. 

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

  1063.     if (afc <= 1)

  1064.         return -1;

  1065.     p = packet + 4;

  1066.     len = p[0];

  1067.     p++;

  1068.     if (len == 0)

  1069.         return -1;

  1070.     flags = *p++;

  1071.     len--;

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

  1073.         return -1;

  1074.     if (len < 6)

  1075.         return -1;

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

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

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

  1079.     return 0;

  1080. }

  1081. 

  1082. static int mpegts_read_header(AVFormatContext *s,

  1083.                               AVFormatParameters *ap)

  1084. {

  1085.     MpegTSContext *ts = s->priv_data;

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

  1087.     uint8_t buf[1024];

  1088.     int len, sid, i;

  1089.     int64_t pos;

  1090.     MpegTSService *service;

  1091. 

  1092.     if (ap) {

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

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

  1095.     }

  1096. 

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

  1098.     pos = url_ftell(pb);

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

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

  1101.         goto fail;

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

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

  1104.         goto fail;

  1105.     ts->stream = s;

  1106.     ts->auto_guess = 0;

  1107. 

  1108.     if (!ts->mpeg2ts_raw) {

  1109.         /* normal demux */

  1110. 

  1111.         if (!ts->auto_guess) {

  1112.             ts->set_service_ret = -1;

  1113. 

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

  1115.             url_fseek(pb, pos, SEEK_SET);

  1116.             mpegts_scan_sdt(ts);

  1117.             

  1118.             handle_packets(ts, MAX_SCAN_PACKETS);

  1119.             

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

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

  1122.                 

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

  1124.                 int i;

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

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

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

  1128.                 }

  1129.                 url_fseek(pb, pos, SEEK_SET);

  1130.                 mpegts_scan_pat(ts);

  1131.                 

  1132.                 handle_packets(ts, MAX_SCAN_PACKETS);

  1133.             }

  1134.             

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

  1136. 		/* raw transport stream */

  1137. 		ts->auto_guess = 1;

  1138. 		s->ctx_flags |= AVFMTCTX_NOHEADER;

  1139. 		goto do_pcr;

  1140. 	    }

  1141.             

  1142.             /* tune to first service found */

  1143.             for(i=0; i<ts->nb_services && ts->set_service_ret; i++){

  1144.                 service = ts->services[i];

  1145.                 sid = service->sid;

  1146. #ifdef DEBUG_SI

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

  1148. #endif

  1149.             

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

  1151.                 otherwise try to filter all PATs */

  1152.                 

  1153.                 url_fseek(pb, pos, SEEK_SET);

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

  1155.                 

  1156.                 handle_packets(ts, MAX_SCAN_PACKETS);

  1157.             }

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

  1159.             

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

  1161.                 return -1;

  1162.             

  1163. #ifdef DEBUG_SI

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

  1165. #endif

  1166.         }

  1167.         s->ctx_flags |= AVFMTCTX_NOHEADER;

  1168.     } else {

  1169.         AVStream *st;

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

  1171.         int64_t pcrs[2], pcr_h;

  1172.         int packet_count[2];

  1173.         uint8_t packet[TS_PACKET_SIZE];

  1174.         

  1175.         /* only read packets */

  1176.         

  1177.     do_pcr:

  1178.         st = av_new_stream(s, 0);

  1179.         if (!st)

  1180.             goto fail;

  1181.         av_set_pts_info(st, 60, 1, 27000000);

  1182.         st->codec.codec_type = CODEC_TYPE_DATA;

  1183.         st->codec.codec_id = CODEC_ID_MPEG2TS;

  1184.         

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

  1186.         pcr_pid = -1;

  1187.         nb_pcrs = 0;

  1188.         nb_packets = 0;

  1189.         for(;;) {

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

  1191.             if (ret < 0)

  1192.                 return -1;

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

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

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

  1196.                 pcr_pid = pid;

  1197.                 packet_count[nb_pcrs] = nb_packets;

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

  1199.                 nb_pcrs++;

  1200.                 if (nb_pcrs >= 2)

  1201.                     break;

  1202.             }

  1203.             nb_packets++;

  1204.         }

  1205.         ts->pcr_pid = pcr_pid;

  1206. 

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

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

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

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

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

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

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

  1214. #if 0

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

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

  1217. #endif

  1218.     }

  1219. 

  1220.     url_fseek(pb, pos, SEEK_SET);

  1221.     return 0;

  1222.  fail:

  1223.     return -1;

  1224. }

  1225. 

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

  1227. 

  1228. static int mpegts_raw_read_packet(AVFormatContext *s,

  1229.                                   AVPacket *pkt)

  1230. {

  1231.     MpegTSContext *ts = s->priv_data;

  1232.     int ret, i;

  1233.     int64_t pcr_h, next_pcr_h, pos;

  1234.     int pcr_l, next_pcr_l;

  1235.     uint8_t pcr_buf[12];

  1236. 

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

  1238.         return -ENOMEM;

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

  1240.     if (ret < 0) {

  1241.         av_free_packet(pkt);

  1242.         return ret;

  1243.     }

  1244.     if (ts->mpeg2ts_compute_pcr) {

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

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

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

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

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

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

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

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

  1253.                     /* XXX: not precise enough */

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

  1255.                         (i + 1);

  1256.                     break;

  1257.                 }

  1258.             }

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

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

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

  1262.         }

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

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

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

  1266.     }

  1267.     pkt->stream_index = 0;

  1268.     return 0;

  1269. }

  1270. 

  1271. static int mpegts_read_packet(AVFormatContext *s,

  1272.                               AVPacket *pkt)

  1273. {

  1274.     MpegTSContext *ts = s->priv_data;

  1275. 

  1276.     if (!ts->mpeg2ts_raw) {

  1277.         ts->pkt = pkt;

  1278.         return handle_packets(ts, 0);

  1279.     } else {

  1280.         return mpegts_raw_read_packet(s, pkt);

  1281.     }

  1282. }

  1283. 

  1284. static int mpegts_read_close(AVFormatContext *s)

  1285. {

  1286.     MpegTSContext *ts = s->priv_data;

  1287.     int i;

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

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

  1290.     return 0;

  1291. }

  1292. 

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

  1294.                               int64_t *ppos, int64_t pos_limit)

  1295. {

  1296.     MpegTSContext *ts = s->priv_data;

  1297.     int64_t pos, timestamp;

  1298.     uint8_t buf[TS_PACKET_SIZE];

  1299.     int pcr_l, pid;

  1300.     const int find_next= 1;

  1301.     pos = ((*ppos  + ts->raw_packet_size - 1) / ts->raw_packet_size) * ts->raw_packet_size;

  1302.     if (find_next) {

  1303.         for(;;) {

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

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

  1306.                 return AV_NOPTS_VALUE;

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

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

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

  1310.                 break;

  1311.             }

  1312.             pos += ts->raw_packet_size;

  1313.         }

  1314.     } else {

  1315.         for(;;) {

  1316.             pos -= ts->raw_packet_size;

  1317.             if (pos < 0)

  1318.                 return AV_NOPTS_VALUE;

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

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

  1321.                 return AV_NOPTS_VALUE;

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

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

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

  1325.                 break;

  1326.             }

  1327.         }

  1328.     }

  1329.     *ppos = pos;

  1330. 

  1331.     return timestamp;

  1332. }

  1333. 

  1334. static int read_seek(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){

  1335.     MpegTSContext *ts = s->priv_data;

  1336.     uint8_t buf[TS_PACKET_SIZE];

  1337.     int64_t pos;

  1338. 

  1339.     if(av_seek_frame_binary(s, stream_index, target_ts, flags) < 0)

  1340.         return -1;

  1341. 

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

  1343. 

  1344.     for(;;) {

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

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

  1347.             return -1;

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

  1349.         if(buf[1] & 0x40) break;

  1350.         pos += ts->raw_packet_size;

  1351.     }    

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

  1353. 

  1354.     return 0;

  1355. }

  1356. 

  1357. /**************************************************************/

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

  1359. 

  1360. MpegTSContext *mpegts_parse_open(AVFormatContext *s)

  1361. {

  1362.     MpegTSContext *ts;

  1363.     

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

  1365.     if (!ts)

  1366.         return NULL;

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

  1368.     ts->raw_packet_size = TS_PACKET_SIZE;

  1369.     ts->stream = s;

  1370.     ts->auto_guess = 1;

  1371.     return ts;

  1372. }

  1373. 

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

  1375.    packet is output */

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

  1377.                         const uint8_t *buf, int len)

  1378. {

  1379.     int len1;

  1380. 

  1381.     len1 = len;

  1382.     ts->pkt = pkt;

  1383.     ts->stop_parse = 0;

  1384.     for(;;) {

  1385.         if (ts->stop_parse)

  1386.             break;

  1387.         if (len < TS_PACKET_SIZE)

  1388.             return -1;

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

  1390.             buf++;

  1391.             len--;

  1392.         } else {

  1393.             handle_packet(ts, buf);

  1394.             buf += TS_PACKET_SIZE;

  1395.             len -= TS_PACKET_SIZE;

  1396.         }

  1397.     }

  1398.     return len1 - len;

  1399. }

  1400. 

  1401. void mpegts_parse_close(MpegTSContext *ts)

  1402. {

  1403.     int i;

  1404. 

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

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

  1407.     av_free(ts);

  1408. }

  1409. 

  1410. AVInputFormat mpegts_demux = {

  1411.     "mpegts",

  1412.     "MPEG2 transport stream format",

  1413.     sizeof(MpegTSContext),

  1414.     mpegts_probe,

  1415.     mpegts_read_header,

  1416.     mpegts_read_packet,

  1417.     mpegts_read_close,

  1418.     read_seek,

  1419.     mpegts_get_pcr,

  1420.     .flags = AVFMT_SHOW_IDS,

  1421. };

  1422. 

  1423. int mpegts_init(void)

  1424. {

  1425.     av_register_input_format(&mpegts_demux);

  1426. #ifdef CONFIG_ENCODERS

  1427.     av_register_output_format(&mpegts_mux);

  1428. #endif

  1429.     return 0;

  1430. }