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

1553 lines
45KB
Raw Blame History 

  1. /*

  2.  * MPEG2 transport stream (aka DVB) demuxer

  3.  * Copyright (c) 2002-2003 Fabrice Bellard.

  4.  *

  5.  * This file is part of FFmpeg.

  6.  *

  7.  * FFmpeg is free software; you can redistribute it and/or

  8.  * modify it under the terms of the GNU Lesser General Public

  9.  * License as published by the Free Software Foundation; either

  10.  * version 2.1 of the License, or (at your option) any later version.

  11.  *

  12.  * FFmpeg is distributed in the hope that it will be useful,

  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  15.  * Lesser General Public License for more details.

  16.  *

  17.  * You should have received a copy of the GNU Lesser General Public

  18.  * License along with FFmpeg; if not, write to the Free Software

  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  20.  */

  21. #include "avformat.h"

  22. #include "crc.h"

  23. #include "mpegts.h"

  24. 

  25. //#define DEBUG_SI

  26. //#define DEBUG_SEEK

  27. 

  28. /* 1.0 second at 24Mbit/s */

  29. #define MAX_SCAN_PACKETS 32000

  30. 

  31. /* maximum size in which we look for synchronisation if

  32.    synchronisation is lost */

  33. #define MAX_RESYNC_SIZE 4096

  34. 

  35. typedef struct PESContext PESContext;

  36. 

  37. static PESContext* add_pes_stream(MpegTSContext *ts, int pid, int stream_type);

  38. static AVStream* new_pes_av_stream(PESContext *pes, uint32_t code);

  39. 

  40. enum MpegTSFilterType {

  41.     MPEGTS_PES,

  42.     MPEGTS_SECTION,

  43. };

  44. 

  45. typedef void PESCallback(void *opaque, const uint8_t *buf, int len, int is_start);

  46. 

  47. typedef struct MpegTSPESFilter {

  48.     PESCallback *pes_cb;

  49.     void *opaque;

  50. } MpegTSPESFilter;

  51. 

  52. typedef void SectionCallback(void *opaque, const uint8_t *buf, int len);

  53. 

  54. typedef void SetServiceCallback(void *opaque, int ret);

  55. 

  56. typedef struct MpegTSSectionFilter {

  57.     int section_index;

  58.     int section_h_size;

  59.     uint8_t *section_buf;

  60.     int check_crc:1;

  61.     int end_of_section_reached:1;

  62.     SectionCallback *section_cb;

  63.     void *opaque;

  64. } MpegTSSectionFilter;

  65. 

  66. typedef struct MpegTSFilter {

  67.     int pid;

  68.     int last_cc; /* last cc code (-1 if first packet) */

  69.     enum MpegTSFilterType type;

  70.     union {

  71.         MpegTSPESFilter pes_filter;

  72.         MpegTSSectionFilter section_filter;

  73.     } u;

  74. } MpegTSFilter;

  75. 

  76. typedef struct MpegTSService {

  77.     int running:1;

  78.     int sid;    /**< MPEG Program Number of stream */

  79.     char *provider_name; /**< DVB Network name, "" if not DVB stream */

  80.     char *name; /**< DVB Service name, "MPEG Program [sid]" if not DVB stream*/

  81. } MpegTSService;

  82. 

  83. struct MpegTSContext {

  84.     /* user data */

  85.     AVFormatContext *stream;

  86.     /** raw packet size, including FEC if present            */

  87.     int raw_packet_size;

  88.     /** if true, all pids are analyzed to find streams       */

  89.     int auto_guess;

  90.     int set_service_ret;

  91. 

  92.     /** force raw MPEG2 transport stream output, if possible */

  93.     int mpeg2ts_raw;

  94.     /** compute exact PCR for each transport stream packet   */

  95.     int mpeg2ts_compute_pcr;

  96. 

  97.     int64_t cur_pcr;    /**< used to estimate the exact PCR  */

  98.     int pcr_incr;       /**< used to estimate the exact PCR  */

  99.     int pcr_pid;        /**< used to estimate the exact PCR  */

  100. 

  101.     /* data needed to handle file based ts */

  102.     /** stop parsing loop                                    */

  103.     int stop_parse;

  104.     /** packet containing Audio/Video data                   */

  105.     AVPacket *pkt;

  106. 

  107.     /******************************************/

  108.     /* private mpegts data */

  109.     /* scan context */

  110.     MpegTSFilter *sdt_filter;

  111.     /** number of PMTs in the last PAT seen                  */

  112.     int nb_services;

  113.     /** list of PMTs in the last PAT seen                    */

  114.     MpegTSService **services;

  115. 

  116.     /* set service context (XXX: allocated it ?) */

  117.     SetServiceCallback *set_service_cb;

  118.     void *set_service_opaque;

  119.     /** filter for the PAT                                   */

  120.     MpegTSFilter *pat_filter;

  121.     /** filter for the PMT for the MPEG program number specified by req_sid */

  122.     MpegTSFilter *pmt_filter;

  123.     /** MPEG program number of stream we want to decode      */

  124.     int req_sid;

  125. 

  126.     /** filters for various streams specified by PMT + for the PAT and PMT */

  127.     MpegTSFilter *pids[NB_PID_MAX];

  128. };

  129. 

  130. /**

  131.  *  Assembles PES packets out of TS packets, and then calls the "section_cb"

  132.  *  function when they are complete.

  133.  */

  134. static void write_section_data(AVFormatContext *s, MpegTSFilter *tss1,

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

  136. {

  137.     MpegTSSectionFilter *tss = &tss1->u.section_filter;

  138.     int len;

  139. 

  140.     if (is_start) {

  141.         memcpy(tss->section_buf, buf, buf_size);

  142.         tss->section_index = buf_size;

  143.         tss->section_h_size = -1;

  144.         tss->end_of_section_reached = 0;

  145.     } else {

  146.         if (tss->end_of_section_reached)

  147.             return;

  148.         len = 4096 - tss->section_index;

  149.         if (buf_size < len)

  150.             len = buf_size;

  151.         memcpy(tss->section_buf + tss->section_index, buf, len);

  152.         tss->section_index += len;

  153.     }

  154. 

  155.     /* compute section length if possible */

  156.     if (tss->section_h_size == -1 && tss->section_index >= 3) {

  157.         len = (((tss->section_buf[1] & 0xf) << 8) | tss->section_buf[2]) + 3;

  158.         if (len > 4096)

  159.             return;

  160.         tss->section_h_size = len;

  161.     }

  162. 

  163.     if (tss->section_h_size != -1 && tss->section_index >= tss->section_h_size) {

  164.         tss->end_of_section_reached = 1;

  165.         if (!tss->check_crc ||

  166.             av_crc(av_crc04C11DB7, -1, tss->section_buf, tss->section_h_size) == 0)

  167.             tss->section_cb(tss->opaque, tss->section_buf, tss->section_h_size);

  168.     }

  169. }

  170. 

  171. static MpegTSFilter *mpegts_open_section_filter(MpegTSContext *ts, unsigned int pid,

  172.                                          SectionCallback *section_cb, void *opaque,

  173.                                          int check_crc)

  174. 

  175. {

  176.     MpegTSFilter *filter;

  177.     MpegTSSectionFilter *sec;

  178. 

  179. #ifdef DEBUG_SI

  180.     av_log(ts->stream, AV_LOG_DEBUG, "Filter: pid=0x%x\n", pid);

  181. #endif

  182.     if (pid >= NB_PID_MAX || ts->pids[pid])

  183.         return NULL;

  184.     filter = av_mallocz(sizeof(MpegTSFilter));

  185.     if (!filter)

  186.         return NULL;

  187.     ts->pids[pid] = filter;

  188.     filter->type = MPEGTS_SECTION;

  189.     filter->pid = pid;

  190.     filter->last_cc = -1;

  191.     sec = &filter->u.section_filter;

  192.     sec->section_cb = section_cb;

  193.     sec->opaque = opaque;

  194.     sec->section_buf = av_malloc(MAX_SECTION_SIZE);

  195.     sec->check_crc = check_crc;

  196.     if (!sec->section_buf) {

  197.         av_free(filter);

  198.         return NULL;

  199.     }

  200.     return filter;

  201. }

  202. 

  203. static MpegTSFilter *mpegts_open_pes_filter(MpegTSContext *ts, unsigned int pid,

  204.                                      PESCallback *pes_cb,

  205.                                      void *opaque)

  206. {

  207.     MpegTSFilter *filter;

  208.     MpegTSPESFilter *pes;

  209. 

  210.     if (pid >= NB_PID_MAX || ts->pids[pid])

  211.         return NULL;

  212.     filter = av_mallocz(sizeof(MpegTSFilter));

  213.     if (!filter)

  214.         return NULL;

  215.     ts->pids[pid] = filter;

  216.     filter->type = MPEGTS_PES;

  217.     filter->pid = pid;

  218.     filter->last_cc = -1;

  219.     pes = &filter->u.pes_filter;

  220.     pes->pes_cb = pes_cb;

  221.     pes->opaque = opaque;

  222.     return filter;

  223. }

  224. 

  225. static void mpegts_close_filter(MpegTSContext *ts, MpegTSFilter *filter)

  226. {

  227.     int pid;

  228. 

  229.     pid = filter->pid;

  230.     if (filter->type == MPEGTS_SECTION)

  231.         av_freep(&filter->u.section_filter.section_buf);

  232.     else if (filter->type == MPEGTS_PES)

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

  234. 

  235.     av_free(filter);

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

  237. }

  238. 

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

  240.     int stat[packet_size];

  241.     int i;

  242.     int x=0;

  243.     int best_score=0;

  244. 

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

  246. 

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

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

  249.             stat[x]++;

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

  251.                 best_score= stat[x];

  252.                 if(index) *index= x;

  253.             }

  254.         }

  255. 

  256.         x++;

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

  258.     }

  259. 

  260.     return best_score;

  261. }

  262. 

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

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

  265. {

  266.     int score, fec_score, dvhs_score;

  267. 

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

  269.         return -1;

  270. 

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

  272.     dvhs_score    = analyze(buf, size, TS_DVHS_PACKET_SIZE, NULL);

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

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

  275. 

  276.     if     (score > fec_score && score > dvhs_score) return TS_PACKET_SIZE;

  277.     else if(dvhs_score > score && dvhs_score > fec_score) return TS_DVHS_PACKET_SIZE;

  278.     else if(score < fec_score && dvhs_score < fec_score) return TS_FEC_PACKET_SIZE;

  279.     else                       return -1;

  280. }

  281. 

  282. typedef struct SectionHeader {

  283.     uint8_t tid;

  284.     uint16_t id;

  285.     uint8_t version;

  286.     uint8_t sec_num;

  287.     uint8_t last_sec_num;

  288. } SectionHeader;

  289. 

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

  291. {

  292.     const uint8_t *p;

  293.     int c;

  294. 

  295.     p = *pp;

  296.     if (p >= p_end)

  297.         return -1;

  298.     c = *p++;

  299.     *pp = p;

  300.     return c;

  301. }

  302. 

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

  304. {

  305.     const uint8_t *p;

  306.     int c;

  307. 

  308.     p = *pp;

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

  310.         return -1;

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

  312.     p += 2;

  313.     *pp = p;

  314.     return c;

  315. }

  316. 

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

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

  319. {

  320.     int len;

  321.     const uint8_t *p;

  322.     char *str;

  323. 

  324.     p = *pp;

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

  326.     if (len < 0)

  327.         return NULL;

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

  329.         return NULL;

  330.     str = av_malloc(len + 1);

  331.     if (!str)

  332.         return NULL;

  333.     memcpy(str, p, len);

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

  335.     p += len;

  336.     *pp = p;

  337.     return str;

  338. }

  339. 

  340. static int parse_section_header(SectionHeader *h,

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

  342. {

  343.     int val;

  344. 

  345.     val = get8(pp, p_end);

  346.     if (val < 0)

  347.         return -1;

  348.     h->tid = val;

  349.     *pp += 2;

  350.     val = get16(pp, p_end);

  351.     if (val < 0)

  352.         return -1;

  353.     h->id = val;

  354.     val = get8(pp, p_end);

  355.     if (val < 0)

  356.         return -1;

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

  358.     val = get8(pp, p_end);

  359.     if (val < 0)

  360.         return -1;

  361.     h->sec_num = val;

  362.     val = get8(pp, p_end);

  363.     if (val < 0)

  364.         return -1;

  365.     h->last_sec_num = val;

  366.     return 0;

  367. }

  368. 

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

  370.                                   char *provider_name, char *name)

  371. {

  372.     MpegTSService *service;

  373. 

  374. #ifdef DEBUG_SI

  375.     av_log(ts->stream, AV_LOG_DEBUG, "new_service: "

  376.            "sid=0x%04x provider='%s' name='%s'\n",

  377.            sid, provider_name, name);

  378. #endif

  379. 

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

  381.     if (!service)

  382.         return NULL;

  383.     service->sid = sid;

  384.     service->provider_name = provider_name;

  385.     service->name = name;

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

  387.     return service;

  388. }

  389. 

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

  391. {

  392.     MpegTSContext *ts = opaque;

  393.     SectionHeader h1, *h = &h1;

  394.     PESContext *pes;

  395.     AVStream *st;

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

  397.     int program_info_length, pcr_pid, pid, stream_type;

  398.     int desc_list_len, desc_len, desc_tag;

  399.     int comp_page = 0, anc_page = 0; /* initialize to kill warnings */

  400.     char language[4];

  401. 

  402. #ifdef DEBUG_SI

  403.     av_log(ts->stream, AV_LOG_DEBUG, "PMT: len %i\n", section_len);

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

  405. #endif

  406.     p_end = section + section_len - 4;

  407.     p = section;

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

  409.         return;

  410. #ifdef DEBUG_SI

  411.     av_log(ts->stream, AV_LOG_DEBUG, "sid=0x%x sec_num=%d/%d\n",

  412.            h->id, h->sec_num, h->last_sec_num);

  413. #endif

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

  415.         return;

  416. 

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

  418.     if (pcr_pid < 0)

  419.         return;

  420.     ts->pcr_pid = pcr_pid;

  421. #ifdef DEBUG_SI

  422.     av_log(ts->stream, AV_LOG_DEBUG, "pcr_pid=0x%x\n", pcr_pid);

  423. #endif

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

  425.     if (program_info_length < 0)

  426.         return;

  427.     p += program_info_length;

  428.     if (p >= p_end)

  429.         return;

  430.     for(;;) {

  431.         language[0] = 0;

  432.         st = 0;

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

  434.         if (stream_type < 0)

  435.             break;

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

  437.         if (pid < 0)

  438.             break;

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

  440.         if (desc_list_len < 0)

  441.             break;

  442.         desc_list_end = p + desc_list_len;

  443.         if (desc_list_end > p_end)

  444.             break;

  445.         for(;;) {

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

  447.             if (desc_tag < 0)

  448.                 break;

  449.             if (stream_type == STREAM_TYPE_PRIVATE_DATA) {

  450.                 if((desc_tag == 0x6A) || (desc_tag == 0x7A)) {

  451.                     /*assume DVB AC-3 Audio*/

  452.                     stream_type = STREAM_TYPE_AUDIO_AC3;

  453.                 } else if(desc_tag == 0x7B) {

  454.                     /* DVB DTS audio */

  455.                     stream_type = STREAM_TYPE_AUDIO_DTS;

  456.                 }

  457.             }

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

  459.             desc_end = p + desc_len;

  460.             if (desc_end > desc_list_end)

  461.                 break;

  462. #ifdef DEBUG_SI

  463.             av_log(ts->stream, AV_LOG_DEBUG, "tag: 0x%02x len=%d\n",

  464.                    desc_tag, desc_len);

  465. #endif

  466.             switch(desc_tag) {

  467.             case DVB_SUBT_DESCID:

  468.                 if (stream_type == STREAM_TYPE_PRIVATE_DATA)

  469.                     stream_type = STREAM_TYPE_SUBTITLE_DVB;

  470. 

  471.                 language[0] = get8(&p, desc_end);

  472.                 language[1] = get8(&p, desc_end);

  473.                 language[2] = get8(&p, desc_end);

  474.                 language[3] = 0;

  475.                 get8(&p, desc_end);

  476.                 comp_page = get16(&p, desc_end);

  477.                 anc_page = get16(&p, desc_end);

  478. 

  479.                 break;

  480.             case 0x0a: /* ISO 639 language descriptor */

  481.                 language[0] = get8(&p, desc_end);

  482.                 language[1] = get8(&p, desc_end);

  483.                 language[2] = get8(&p, desc_end);

  484.                 language[3] = 0;

  485.                 break;

  486.             default:

  487.                 break;

  488.             }

  489.             p = desc_end;

  490.         }

  491.         p = desc_list_end;

  492. 

  493. #ifdef DEBUG_SI

  494.         av_log(ts->stream, AV_LOG_DEBUG, "stream_type=%d pid=0x%x\n",

  495.                stream_type, pid);

  496. #endif

  497. 

  498.         /* now create ffmpeg stream */

  499.         switch(stream_type) {

  500.         case STREAM_TYPE_AUDIO_MPEG1:

  501.         case STREAM_TYPE_AUDIO_MPEG2:

  502.         case STREAM_TYPE_VIDEO_MPEG1:

  503.         case STREAM_TYPE_VIDEO_MPEG2:

  504.         case STREAM_TYPE_VIDEO_MPEG4:

  505.         case STREAM_TYPE_VIDEO_H264:

  506.         case STREAM_TYPE_VIDEO_VC1:

  507.         case STREAM_TYPE_AUDIO_AAC:

  508.         case STREAM_TYPE_AUDIO_AC3:

  509.         case STREAM_TYPE_AUDIO_DTS:

  510.         case STREAM_TYPE_SUBTITLE_DVB:

  511.             pes = add_pes_stream(ts, pid, stream_type);

  512.             if (pes)

  513.                 st = new_pes_av_stream(pes, 0);

  514.             break;

  515.         default:

  516.             /* we ignore the other streams */

  517.             break;

  518.         }

  519. 

  520.         if (st) {

  521.             if (language[0] != 0) {

  522.                 st->language[0] = language[0];

  523.                 st->language[1] = language[1];

  524.                 st->language[2] = language[2];

  525.                 st->language[3] = language[3];

  526.             }

  527. 

  528.             if (stream_type == STREAM_TYPE_SUBTITLE_DVB) {

  529.                 st->codec->sub_id = (anc_page << 16) | comp_page;

  530.             }

  531.         }

  532.     }

  533.     /* all parameters are there */

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

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

  536.     ts->pmt_filter = NULL;

  537. }

  538. 

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

  540. {

  541.     MpegTSContext *ts = opaque;

  542.     SectionHeader h1, *h = &h1;

  543.     const uint8_t *p, *p_end;

  544.     int sid, pmt_pid;

  545. 

  546. #ifdef DEBUG_SI

  547.     av_log(ts->stream, AV_LOG_DEBUG, "PAT:\n");

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

  549. #endif

  550.     p_end = section + section_len - 4;

  551.     p = section;

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

  553.         return;

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

  555.         return;

  556. 

  557.     for(;;) {

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

  559.         if (sid < 0)

  560.             break;

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

  562.         if (pmt_pid < 0)

  563.             break;

  564. #ifdef DEBUG_SI

  565.         av_log(ts->stream, AV_LOG_DEBUG, "sid=0x%x pid=0x%x\n", sid, pmt_pid);

  566. #endif

  567.         if (sid == 0x0000) {

  568.             /* NIT info */

  569.         } else {

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

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

  572.                                                             pmt_cb, ts, 1);

  573.                 goto found;

  574.             }

  575.         }

  576.     }

  577.     /* not found */

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

  579. 

  580.  found:

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

  582.     ts->pat_filter = NULL;

  583. }

  584. 

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

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

  587. {

  588.     MpegTSContext *ts = opaque;

  589.     SectionHeader h1, *h = &h1;

  590.     const uint8_t *p, *p_end;

  591.     int sid, pmt_pid;

  592.     char *provider_name, *name;

  593.     char buf[256];

  594. 

  595. #ifdef DEBUG_SI

  596.     av_log(ts->stream, AV_LOG_DEBUG, "PAT:\n");

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

  598. #endif

  599.     p_end = section + section_len - 4;

  600.     p = section;

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

  602.         return;

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

  604.         return;

  605. 

  606.     for(;;) {

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

  608.         if (sid < 0)

  609.             break;

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

  611.         if (pmt_pid < 0)

  612.             break;

  613. #ifdef DEBUG_SI

  614.         av_log(ts->stream, AV_LOG_DEBUG, "sid=0x%x pid=0x%x\n", sid, pmt_pid);

  615. #endif

  616.         if (sid == 0x0000) {

  617.             /* NIT info */

  618.         } else {

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

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

  621.             name = av_strdup(buf);

  622.             provider_name = av_strdup("");

  623.             if (name && provider_name) {

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

  625.             } else {

  626.                 av_freep(&name);

  627.                 av_freep(&provider_name);

  628.             }

  629.         }

  630.     }

  631.     ts->stop_parse = 1;

  632. 

  633.     /* remove filter */

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

  635.     ts->pat_filter = NULL;

  636. }

  637. 

  638. static void mpegts_set_service(MpegTSContext *ts, int sid,

  639.                         SetServiceCallback *set_service_cb, void *opaque)

  640. {

  641.     ts->set_service_cb = set_service_cb;

  642.     ts->set_service_opaque = opaque;

  643.     ts->req_sid = sid;

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

  645.                                                 pat_cb, ts, 1);

  646. }

  647. 

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

  649. {

  650.     MpegTSContext *ts = opaque;

  651.     SectionHeader h1, *h = &h1;

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

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

  654.     char *name, *provider_name;

  655. 

  656. #ifdef DEBUG_SI

  657.     av_log(ts->stream, AV_LOG_DEBUG, "SDT:\n");

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

  659. #endif

  660. 

  661.     p_end = section + section_len - 4;

  662.     p = section;

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

  664.         return;

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

  666.         return;

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

  668.     if (onid < 0)

  669.         return;

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

  671.     if (val < 0)

  672.         return;

  673.     for(;;) {

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

  675.         if (sid < 0)

  676.             break;

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

  678.         if (val < 0)

  679.             break;

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

  681.         if (desc_list_len < 0)

  682.             break;

  683.         desc_list_end = p + desc_list_len;

  684.         if (desc_list_end > p_end)

  685.             break;

  686.         for(;;) {

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

  688.             if (desc_tag < 0)

  689.                 break;

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

  691.             desc_end = p + desc_len;

  692.             if (desc_end > desc_list_end)

  693.                 break;

  694. #ifdef DEBUG_SI

  695.             av_log(ts->stream, AV_LOG_DEBUG, "tag: 0x%02x len=%d\n",

  696.                    desc_tag, desc_len);

  697. #endif

  698.             switch(desc_tag) {

  699.             case 0x48:

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

  701.                 if (service_type < 0)

  702.                     break;

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

  704.                 if (!provider_name)

  705.                     break;

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

  707.                 if (!name)

  708.                     break;

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

  710.                 break;

  711.             default:

  712.                 break;

  713.             }

  714.             p = desc_end;

  715.         }

  716.         p = desc_list_end;

  717.     }

  718.     ts->stop_parse = 1;

  719. 

  720.     /* remove filter */

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

  722.     ts->sdt_filter = NULL;

  723. }

  724. 

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

  726. static void mpegts_scan_sdt(MpegTSContext *ts)

  727. {

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

  729.                                                 sdt_cb, ts, 1);

  730. }

  731. 

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

  733.    than nothing !) */

  734. static void mpegts_scan_pat(MpegTSContext *ts)

  735. {

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

  737.                                                 pat_scan_cb, ts, 1);

  738. }

  739. 

  740. /* TS stream handling */

  741. 

  742. enum MpegTSState {

  743.     MPEGTS_HEADER = 0,

  744.     MPEGTS_PESHEADER_FILL,

  745.     MPEGTS_PAYLOAD,

  746.     MPEGTS_SKIP,

  747. };

  748. 

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

  750. #define PES_START_SIZE 9

  751. #define MAX_PES_HEADER_SIZE (9 + 255)

  752. 

  753. struct PESContext {

  754.     int pid;

  755.     int stream_type;

  756.     MpegTSContext *ts;

  757.     AVFormatContext *stream;

  758.     AVStream *st;

  759.     enum MpegTSState state;

  760.     /* used to get the format */

  761.     int data_index;

  762.     int total_size;

  763.     int pes_header_size;

  764.     int64_t pts, dts;

  765.     uint8_t header[MAX_PES_HEADER_SIZE];

  766. };

  767. 

  768. static int64_t get_pts(const uint8_t *p)

  769. {

  770.     int64_t pts;

  771.     int val;

  772. 

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

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

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

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

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

  778.     return pts;

  779. }

  780. 

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

  782. static void mpegts_push_data(void *opaque,

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

  784. {

  785.     PESContext *pes = opaque;

  786.     MpegTSContext *ts = pes->ts;

  787.     const uint8_t *p;

  788.     int len, code;

  789. 

  790.     if (is_start) {

  791.         pes->state = MPEGTS_HEADER;

  792.         pes->data_index = 0;

  793.     }

  794.     p = buf;

  795.     while (buf_size > 0) {

  796.         switch(pes->state) {

  797.         case MPEGTS_HEADER:

  798.             len = PES_START_SIZE - pes->data_index;

  799.             if (len > buf_size)

  800.                 len = buf_size;

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

  802.             pes->data_index += len;

  803.             p += len;

  804.             buf_size -= len;

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

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

  807.                    decide */

  808. #if 0

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

  810. #endif

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

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

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

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

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

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

  817.                           (code == 0x1bd) || (code == 0x1fd)))

  818.                         goto skip;

  819.                     if (!pes->st) {

  820.                         /* allocate stream */

  821.                         new_pes_av_stream(pes, code);

  822.                     }

  823.                     pes->state = MPEGTS_PESHEADER_FILL;

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

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

  826.                        unbounded */

  827.                     if (pes->total_size)

  828.                         pes->total_size += 6;

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

  830.                 } else {

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

  832.                     /* skip packet */

  833.                 skip:

  834.                     pes->state = MPEGTS_SKIP;

  835.                     continue;

  836.                 }

  837.             }

  838.             break;

  839.             /**********************************************/

  840.             /* PES packing parsing */

  841.         case MPEGTS_PESHEADER_FILL:

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

  843.             if (len > buf_size)

  844.                 len = buf_size;

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

  846.             pes->data_index += len;

  847.             p += len;

  848.             buf_size -= len;

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

  850.                 const uint8_t *r;

  851.                 unsigned int flags;

  852. 

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

  854.                 r = pes->header + 9;

  855.                 pes->pts = AV_NOPTS_VALUE;

  856.                 pes->dts = AV_NOPTS_VALUE;

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

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

  859.                     r += 5;

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

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

  862.                     r += 5;

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

  864.                     r += 5;

  865.                 }

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

  867.                 pes->state = MPEGTS_PAYLOAD;

  868.             }

  869.             break;

  870.         case MPEGTS_PAYLOAD:

  871.             if (pes->total_size) {

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

  873.                 if (len > buf_size)

  874.                     len = buf_size;

  875.             } else {

  876.                 len = buf_size;

  877.             }

  878.             if (len > 0) {

  879.                 AVPacket *pkt = ts->pkt;

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

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

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

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

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

  885.                     /* reset pts values */

  886.                     pes->pts = AV_NOPTS_VALUE;

  887.                     pes->dts = AV_NOPTS_VALUE;

  888.                     ts->stop_parse = 1;

  889.                     return;

  890.                 }

  891.             }

  892.             buf_size = 0;

  893.             break;

  894.         case MPEGTS_SKIP:

  895.             buf_size = 0;

  896.             break;

  897.         }

  898.     }

  899. }

  900. 

  901. static AVStream* new_pes_av_stream(PESContext *pes, uint32_t code)

  902. {

  903.     AVStream *st;

  904.     int codec_type, codec_id;

  905. 

  906.     switch(pes->stream_type){

  907.     case STREAM_TYPE_AUDIO_MPEG1:

  908.     case STREAM_TYPE_AUDIO_MPEG2:

  909.         codec_type = CODEC_TYPE_AUDIO;

  910.         codec_id = CODEC_ID_MP3;

  911.         break;

  912.     case STREAM_TYPE_VIDEO_MPEG1:

  913.     case STREAM_TYPE_VIDEO_MPEG2:

  914.         codec_type = CODEC_TYPE_VIDEO;

  915.         codec_id = CODEC_ID_MPEG2VIDEO;

  916.         break;

  917.     case STREAM_TYPE_VIDEO_MPEG4:

  918.         codec_type = CODEC_TYPE_VIDEO;

  919.         codec_id = CODEC_ID_MPEG4;

  920.         break;

  921.     case STREAM_TYPE_VIDEO_H264:

  922.         codec_type = CODEC_TYPE_VIDEO;

  923.         codec_id = CODEC_ID_H264;

  924.         break;

  925.     case STREAM_TYPE_VIDEO_VC1:

  926.         codec_type = CODEC_TYPE_VIDEO;

  927.         codec_id = CODEC_ID_VC1;

  928.         break;

  929.     case STREAM_TYPE_AUDIO_AAC:

  930.         codec_type = CODEC_TYPE_AUDIO;

  931.         codec_id = CODEC_ID_AAC;

  932.         break;

  933.     case STREAM_TYPE_AUDIO_AC3:

  934.         codec_type = CODEC_TYPE_AUDIO;

  935.         codec_id = CODEC_ID_AC3;

  936.         break;

  937.     case STREAM_TYPE_AUDIO_DTS:

  938.         codec_type = CODEC_TYPE_AUDIO;

  939.         codec_id = CODEC_ID_DTS;

  940.         break;

  941.     case STREAM_TYPE_SUBTITLE_DVB:

  942.         codec_type = CODEC_TYPE_SUBTITLE;

  943.         codec_id = CODEC_ID_DVB_SUBTITLE;

  944.         break;

  945.     default:

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

  947.             codec_type = CODEC_TYPE_AUDIO;

  948.             codec_id = CODEC_ID_MP2;

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

  950.             codec_type = CODEC_TYPE_AUDIO;

  951.             codec_id = CODEC_ID_AC3;

  952.         } else {

  953.             codec_type = CODEC_TYPE_VIDEO;

  954.             codec_id = CODEC_ID_MPEG1VIDEO;

  955.         }

  956.         break;

  957.     }

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

  959.     if (st) {

  960.         av_set_pts_info(st, 33, 1, 90000);

  961.         st->priv_data = pes;

  962.         st->codec->codec_type = codec_type;

  963.         st->codec->codec_id = codec_id;

  964.         st->need_parsing = 1;

  965.         pes->st = st;

  966.     }

  967.     return st;

  968. }

  969. 

  970. 

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

  972. {

  973.     MpegTSFilter *tss;

  974.     PESContext *pes;

  975. 

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

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

  978.     if (!pes)

  979.         return 0;

  980.     pes->ts = ts;

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

  982.     pes->pid = pid;

  983.     pes->stream_type = stream_type;

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

  985.     if (!tss) {

  986.         av_free(pes);

  987.         return 0;

  988.     }

  989.     return pes;

  990. }

  991. 

  992. /* handle one TS packet */

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

  994. {

  995.     AVFormatContext *s = ts->stream;

  996.     MpegTSFilter *tss;

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

  998.     const uint8_t *p, *p_end;

  999. 

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

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

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

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

  1004.         add_pes_stream(ts, pid, 0);

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

  1006.     }

  1007.     if (!tss)

  1008.         return;

  1009. 

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

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

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

  1013.     tss->last_cc = cc;

  1014. 

  1015.     /* skip adaptation field */

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

  1017.     p = packet + 4;

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

  1019.         return;

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

  1021.         return;

  1022.     if (afc == 3) {

  1023.         /* skip adapation field */

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

  1025.     }

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

  1027.     p_end = packet + TS_PACKET_SIZE;

  1028.     if (p >= p_end)

  1029.         return;

  1030. 

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

  1032.         if (is_start) {

  1033.             /* pointer field present */

  1034.             len = *p++;

  1035.             if (p + len > p_end)

  1036.                 return;

  1037.             if (len && cc_ok) {

  1038.                 /* write remaining section bytes */

  1039.                 write_section_data(s, tss,

  1040.                                    p, len, 0);

  1041.                 /* check whether filter has been closed */

  1042.                 if (!ts->pids[pid])

  1043.                     return;

  1044.             }

  1045.             p += len;

  1046.             if (p < p_end) {

  1047.                 write_section_data(s, tss,

  1048.                                    p, p_end - p, 1);

  1049.             }

  1050.         } else {

  1051.             if (cc_ok) {

  1052.                 write_section_data(s, tss,

  1053.                                    p, p_end - p, 0);

  1054.             }

  1055.         }

  1056.     } else {

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

  1058.                                  p, p_end - p, is_start);

  1059.     }

  1060. }

  1061. 

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

  1063.    get_packet_size() ?) */

  1064. static int mpegts_resync(ByteIOContext *pb)

  1065. {

  1066.     int c, i;

  1067. 

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

  1069.         c = url_fgetc(pb);

  1070.         if (c < 0)

  1071.             return -1;

  1072.         if (c == 0x47) {

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

  1074.             return 0;

  1075.         }

  1076.     }

  1077.     /* no sync found */

  1078.     return -1;

  1079. }

  1080. 

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

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

  1083. {

  1084.     int skip, len;

  1085. 

  1086.     for(;;) {

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

  1088.         if (len != TS_PACKET_SIZE)

  1089.             return AVERROR_IO;

  1090.         /* check paquet sync byte */

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

  1092.             /* find a new packet start */

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

  1094.             if (mpegts_resync(pb) < 0)

  1095.                 return AVERROR_INVALIDDATA;

  1096.             else

  1097.                 continue;

  1098.         } else {

  1099.             skip = raw_packet_size - TS_PACKET_SIZE;

  1100.             if (skip > 0)

  1101.                 url_fskip(pb, skip);

  1102.             break;

  1103.         }

  1104.     }

  1105.     return 0;

  1106. }

  1107. 

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

  1109. {

  1110.     AVFormatContext *s = ts->stream;

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

  1112.     uint8_t packet[TS_PACKET_SIZE];

  1113.     int packet_num, ret;

  1114. 

  1115.     ts->stop_parse = 0;

  1116.     packet_num = 0;

  1117.     for(;;) {

  1118.         if (ts->stop_parse)

  1119.             break;

  1120.         packet_num++;

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

  1122.             break;

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

  1124.         if (ret != 0)

  1125.             return ret;

  1126.         handle_packet(ts, packet);

  1127.     }

  1128.     return 0;

  1129. }

  1130. 

  1131. static int mpegts_probe(AVProbeData *p)

  1132. {

  1133. #if 1

  1134.     const int size= p->buf_size;

  1135.     int score, fec_score, dvhs_score;

  1136. #define CHECK_COUNT 10

  1137. 

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

  1139.         return -1;

  1140. 

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

  1142.     dvhs_score  = analyze(p->buf, TS_DVHS_PACKET_SIZE    *CHECK_COUNT, TS_DVHS_PACKET_SIZE, NULL);

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

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

  1145. 

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

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

  1148.     else if(dvhs_score > score && dvhs_score > fec_score && dvhs_score > 6) return AVPROBE_SCORE_MAX + dvhs_score  - CHECK_COUNT;

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

  1150.     else                                    return -1;

  1151. #else

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

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

  1154.         return AVPROBE_SCORE_MAX;

  1155.     else

  1156.         return 0;

  1157. #endif

  1158. }

  1159. 

  1160. static void set_service_cb(void *opaque, int ret)

  1161. {

  1162.     MpegTSContext *ts = opaque;

  1163.     ts->set_service_ret = ret;

  1164.     ts->stop_parse = 1;

  1165. }

  1166. 

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

  1168.    (-1) if not available */

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

  1170.                      const uint8_t *packet)

  1171. {

  1172.     int afc, len, flags;

  1173.     const uint8_t *p;

  1174.     unsigned int v;

  1175. 

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

  1177.     if (afc <= 1)

  1178.         return -1;

  1179.     p = packet + 4;

  1180.     len = p[0];

  1181.     p++;

  1182.     if (len == 0)

  1183.         return -1;

  1184.     flags = *p++;

  1185.     len--;

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

  1187.         return -1;

  1188.     if (len < 6)

  1189.         return -1;

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

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

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

  1193.     return 0;

  1194. }

  1195. 

  1196. static int mpegts_read_header(AVFormatContext *s,

  1197.                               AVFormatParameters *ap)

  1198. {

  1199.     MpegTSContext *ts = s->priv_data;

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

  1201.     uint8_t buf[1024];

  1202.     int len, sid, i;

  1203.     int64_t pos;

  1204.     MpegTSService *service;

  1205. 

  1206.     if (ap) {

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

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

  1209.     }

  1210. 

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

  1212.     pos = url_ftell(pb);

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

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

  1215.         goto fail;

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

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

  1218.         goto fail;

  1219.     ts->stream = s;

  1220.     ts->auto_guess = 0;

  1221. 

  1222. goto_auto_guess:

  1223.     if (!ts->mpeg2ts_raw) {

  1224.         /* normal demux */

  1225. 

  1226.         if (!ts->auto_guess) {

  1227.             ts->set_service_ret = -1;

  1228. 

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

  1230.             url_fseek(pb, pos, SEEK_SET);

  1231.             mpegts_scan_sdt(ts);

  1232. 

  1233.             handle_packets(ts, s->probesize);

  1234. 

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

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

  1237. 

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

  1239.                 int i;

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

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

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

  1243.                 }

  1244.                 url_fseek(pb, pos, SEEK_SET);

  1245.                 mpegts_scan_pat(ts);

  1246. 

  1247.                 handle_packets(ts, s->probesize);

  1248.             }

  1249. 

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

  1251.                 /* raw transport stream */

  1252.                 ts->auto_guess = 1;

  1253.                 s->ctx_flags |= AVFMTCTX_NOHEADER;

  1254.                 goto do_pcr;

  1255.             }

  1256. 

  1257.             /* tune to first service found */

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

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

  1260.                 sid = service->sid;

  1261. #ifdef DEBUG_SI

  1262.                 av_log(ts->stream, AV_LOG_DEBUG, "tuning to '%s'\n", service->name);

  1263. #endif

  1264. 

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

  1266.                 otherwise try to filter all PATs */

  1267. 

  1268.                 url_fseek(pb, pos, SEEK_SET);

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

  1270. 

  1271.                 handle_packets(ts, s->probesize);

  1272.             }

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

  1274. 

  1275.             if (ts->set_service_ret != 0) {

  1276.                 if(ts->auto_guess)

  1277.                   return -1;

  1278.                 else {

  1279.                   //let's retry with auto_guess set

  1280.                  ts->auto_guess = 1;

  1281.                  goto goto_auto_guess;

  1282.                 }

  1283.             }

  1284. 

  1285. #ifdef DEBUG_SI

  1286.             av_log(ts->stream, AV_LOG_DEBUG, "tuning done\n");

  1287. #endif

  1288.         }

  1289.         s->ctx_flags |= AVFMTCTX_NOHEADER;

  1290.     } else {

  1291.         AVStream *st;

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

  1293.         int64_t pcrs[2], pcr_h;

  1294.         int packet_count[2];

  1295.         uint8_t packet[TS_PACKET_SIZE];

  1296. 

  1297.         /* only read packets */

  1298. 

  1299.     do_pcr:

  1300.         st = av_new_stream(s, 0);

  1301.         if (!st)

  1302.             goto fail;

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

  1304.         st->codec->codec_type = CODEC_TYPE_DATA;

  1305.         st->codec->codec_id = CODEC_ID_MPEG2TS;

  1306. 

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

  1308.         pcr_pid = -1;

  1309.         nb_pcrs = 0;

  1310.         nb_packets = 0;

  1311.         for(;;) {

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

  1313.             if (ret < 0)

  1314.                 return -1;

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

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

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

  1318.                 pcr_pid = pid;

  1319.                 packet_count[nb_pcrs] = nb_packets;

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

  1321.                 nb_pcrs++;

  1322.                 if (nb_pcrs >= 2)

  1323.                     break;

  1324.             }

  1325.             nb_packets++;

  1326.         }

  1327.         ts->pcr_pid = pcr_pid;

  1328. 

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

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

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

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

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

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

  1335.         st->start_time = ts->cur_pcr;

  1336. #if 0

  1337.         av_log(ts->stream, AV_LOG_DEBUG, "start=%0.3f pcr=%0.3f incr=%d\n",

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

  1339. #endif

  1340.     }

  1341. 

  1342.     url_fseek(pb, pos, SEEK_SET);

  1343.     return 0;

  1344.  fail:

  1345.     return -1;

  1346. }

  1347. 

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

  1349. 

  1350. static int mpegts_raw_read_packet(AVFormatContext *s,

  1351.                                   AVPacket *pkt)

  1352. {

  1353.     MpegTSContext *ts = s->priv_data;

  1354.     int ret, i;

  1355.     int64_t pcr_h, next_pcr_h, pos;

  1356.     int pcr_l, next_pcr_l;

  1357.     uint8_t pcr_buf[12];

  1358. 

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

  1360.         return AVERROR(ENOMEM);

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

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

  1363.     if (ret < 0) {

  1364.         av_free_packet(pkt);

  1365.         return ret;

  1366.     }

  1367.     if (ts->mpeg2ts_compute_pcr) {

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

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

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

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

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

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

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

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

  1376.                     /* XXX: not precise enough */

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

  1378.                         (i + 1);

  1379.                     break;

  1380.                 }

  1381.             }

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

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

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

  1385.         }

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

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

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

  1389.     }

  1390.     pkt->stream_index = 0;

  1391.     return 0;

  1392. }

  1393. 

  1394. static int mpegts_read_packet(AVFormatContext *s,

  1395.                               AVPacket *pkt)

  1396. {

  1397.     MpegTSContext *ts = s->priv_data;

  1398. 

  1399.     if (!ts->mpeg2ts_raw) {

  1400.         ts->pkt = pkt;

  1401.         return handle_packets(ts, 0);

  1402.     } else {

  1403.         return mpegts_raw_read_packet(s, pkt);

  1404.     }

  1405. }

  1406. 

  1407. static int mpegts_read_close(AVFormatContext *s)

  1408. {

  1409.     MpegTSContext *ts = s->priv_data;

  1410.     int i;

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

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

  1413. 

  1414.     for(i = 0; i < ts->nb_services; i++){

  1415.         av_free(ts->services[i]->provider_name);

  1416.         av_free(ts->services[i]->name);

  1417.         av_free(ts->services[i]);

  1418.     }

  1419.     av_freep(&ts->services);

  1420. 

  1421.     return 0;

  1422. }

  1423. 

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

  1425.                               int64_t *ppos, int64_t pos_limit)

  1426. {

  1427.     MpegTSContext *ts = s->priv_data;

  1428.     int64_t pos, timestamp;

  1429.     uint8_t buf[TS_PACKET_SIZE];

  1430.     int pcr_l, pid;

  1431.     const int find_next= 1;

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

  1433.     if (find_next) {

  1434.         for(;;) {

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

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

  1437.                 return AV_NOPTS_VALUE;

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

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

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

  1441.                 break;

  1442.             }

  1443.             pos += ts->raw_packet_size;

  1444.         }

  1445.     } else {

  1446.         for(;;) {

  1447.             pos -= ts->raw_packet_size;

  1448.             if (pos < 0)

  1449.                 return AV_NOPTS_VALUE;

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

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

  1452.                 return AV_NOPTS_VALUE;

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

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

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

  1456.                 break;

  1457.             }

  1458.         }

  1459.     }

  1460.     *ppos = pos;

  1461. 

  1462.     return timestamp;

  1463. }

  1464. 

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

  1466.     MpegTSContext *ts = s->priv_data;

  1467.     uint8_t buf[TS_PACKET_SIZE];

  1468.     int64_t pos;

  1469. 

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

  1471.         return -1;

  1472. 

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

  1474. 

  1475.     for(;;) {

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

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

  1478.             return -1;

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

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

  1481.         pos += ts->raw_packet_size;

  1482.     }

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

  1484. 

  1485.     return 0;

  1486. }

  1487. 

  1488. /**************************************************************/

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

  1490. 

  1491. MpegTSContext *mpegts_parse_open(AVFormatContext *s)

  1492. {

  1493.     MpegTSContext *ts;

  1494. 

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

  1496.     if (!ts)

  1497.         return NULL;

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

  1499.     ts->raw_packet_size = TS_PACKET_SIZE;

  1500.     ts->stream = s;

  1501.     ts->auto_guess = 1;

  1502.     return ts;

  1503. }

  1504. 

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

  1506.    packet is output */

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

  1508.                         const uint8_t *buf, int len)

  1509. {

  1510.     int len1;

  1511. 

  1512.     len1 = len;

  1513.     ts->pkt = pkt;

  1514.     ts->stop_parse = 0;

  1515.     for(;;) {

  1516.         if (ts->stop_parse)

  1517.             break;

  1518.         if (len < TS_PACKET_SIZE)

  1519.             return -1;

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

  1521.             buf++;

  1522.             len--;

  1523.         } else {

  1524.             handle_packet(ts, buf);

  1525.             buf += TS_PACKET_SIZE;

  1526.             len -= TS_PACKET_SIZE;

  1527.         }

  1528.     }

  1529.     return len1 - len;

  1530. }

  1531. 

  1532. void mpegts_parse_close(MpegTSContext *ts)

  1533. {

  1534.     int i;

  1535. 

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

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

  1538.     av_free(ts);

  1539. }

  1540. 

  1541. AVInputFormat mpegts_demuxer = {

  1542.     "mpegts",

  1543.     "MPEG2 transport stream format",

  1544.     sizeof(MpegTSContext),

  1545.     mpegts_probe,

  1546.     mpegts_read_header,

  1547.     mpegts_read_packet,

  1548.     mpegts_read_close,

  1549.     read_seek,

  1550.     mpegts_get_pcr,

  1551.     .flags = AVFMT_SHOW_IDS,

  1552. };